refactor: fix imports, etc based on restructure

move some functions out of ngit and into lib/mod
and lib/git_events

remove MockConnect from binaries so it is only used in the library.
this was done:
* mainly because automocks were not being imported from
  lib into each binary
* but also because the these functions were being
  tested with MockConnect

3 files changed, 704 insertions, 259 deletions

diff --git a/src/lib/git/identify_ahead_behind.rs b/src/lib/git/identify_ahead_behind.rs
new file mode 100644
index 0000000..c98c994
--- /dev/null
+++ b/src/lib/git/identify_ahead_behind.rs
@@ -0,0 +1,196 @@
+use anyhow::{Context, Result};
+use nostr_sdk::hashes::sha1::Hash as Sha1Hash;
+
+use super::{Repo, RepoActions};
+
+/**
+ * returns `(from_branch,to_branch,ahead,behind)`
+ */
+pub fn identify_ahead_behind(
+    git_repo: &Repo,
+    from_branch: &Option<String>,
+    to_branch: &Option<String>,
+) -> Result<(String, String, Vec<Sha1Hash>, Vec<Sha1Hash>)> {
+    let (from_branch, from_tip) = match from_branch {
+        Some(name) => (
+            name.to_string(),
+            git_repo
+                .get_tip_of_branch(name)
+                .context(format!("cannot find from_branch '{name}'"))?,
+        ),
+        None => (
+            if let Ok(name) = git_repo.get_checked_out_branch_name() {
+                name
+            } else {
+                "head".to_string()
+            },
+            git_repo
+                .get_head_commit()
+                .context("failed to get head commit")
+                .context(
+                    "checkout a commit or specify a from_branch. head does not reveal a commit",
+                )?,
+        ),
+    };
+
+    let (to_branch, to_tip) = match to_branch {
+        Some(name) => (
+            name.to_string(),
+            git_repo
+                .get_tip_of_branch(name)
+                .context(format!("cannot find to_branch '{name}'"))?,
+        ),
+        None => {
+            let (name, commit) = git_repo
+                .get_main_or_master_branch()
+                .context("the default branches (main or master) do not exist")?;
+            (name.to_string(), commit)
+        }
+    };
+
+    match git_repo.get_commits_ahead_behind(&to_tip, &from_tip) {
+        Err(e) => {
+            if e.to_string().contains("is not an ancestor of") {
+                return Err(e).context(format!(
+                    "'{from_branch}' is not branched from '{to_branch}'"
+                ));
+            }
+            Err(e).context(format!(
+                "failed to get commits ahead and behind from '{from_branch}' to '{to_branch}'"
+            ))
+        }
+        Ok((ahead, behind)) => Ok((from_branch, to_branch, ahead, behind)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use test_utils::git::GitTestRepo;
+
+    use super::*;
+    use crate::git::oid_to_sha1;
+
+    #[test]
+    fn when_from_branch_doesnt_exist_return_error() -> Result<()> {
+        let test_repo = GitTestRepo::default();
+        let git_repo = Repo::from_path(&test_repo.dir)?;
+
+        test_repo.populate()?;
+        let branch_name = "doesnt_exist";
+        assert_eq!(
+            identify_ahead_behind(&git_repo, &Some(branch_name.to_string()), &None)
+                .unwrap_err()
+                .to_string(),
+            format!("cannot find from_branch '{}'", &branch_name),
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn when_to_branch_doesnt_exist_return_error() -> Result<()> {
+        let test_repo = GitTestRepo::default();
+        let git_repo = Repo::from_path(&test_repo.dir)?;
+
+        test_repo.populate()?;
+        let branch_name = "doesnt_exist";
+        assert_eq!(
+            identify_ahead_behind(&git_repo, &None, &Some(branch_name.to_string()))
+                .unwrap_err()
+                .to_string(),
+            format!("cannot find to_branch '{}'", &branch_name),
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn when_to_branch_is_none_and_no_main_or_master_branch_return_error() -> Result<()> {
+        let test_repo = GitTestRepo::new("notmain")?;
+        let git_repo = Repo::from_path(&test_repo.dir)?;
+
+        test_repo.populate()?;
+
+        assert_eq!(
+            identify_ahead_behind(&git_repo, &None, &None)
+                .unwrap_err()
+                .to_string(),
+            "the default branches (main or master) do not exist",
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn when_from_branch_is_not_head_return_as_from_branch() -> Result<()> {
+        let test_repo = GitTestRepo::default();
+        let git_repo = Repo::from_path(&test_repo.dir)?;
+
+        test_repo.populate()?;
+        // create feature branch with 1 commit ahead
+        test_repo.create_branch("feature")?;
+        test_repo.checkout("feature")?;
+        std::fs::write(test_repo.dir.join("t3.md"), "some content")?;
+        let head_oid = test_repo.stage_and_commit("add t3.md")?;
+
+        // make feature branch 1 commit behind
+        test_repo.checkout("main")?;
+        std::fs::write(test_repo.dir.join("t4.md"), "some content")?;
+        let main_oid = test_repo.stage_and_commit("add t4.md")?;
+
+        let (from_branch, to_branch, ahead, behind) =
+            identify_ahead_behind(&git_repo, &Some("feature".to_string()), &None)?;
+
+        assert_eq!(from_branch, "feature");
+        assert_eq!(ahead, vec![oid_to_sha1(&head_oid)]);
+        assert_eq!(to_branch, "main");
+        assert_eq!(behind, vec![oid_to_sha1(&main_oid)]);
+        Ok(())
+    }
+
+    #[test]
+    fn when_to_branch_is_not_main_return_as_to_branch() -> Result<()> {
+        let test_repo = GitTestRepo::default();
+        let git_repo = Repo::from_path(&test_repo.dir)?;
+
+        test_repo.populate()?;
+        // create dev branch with 1 commit ahead
+        test_repo.create_branch("dev")?;
+        test_repo.checkout("dev")?;
+        std::fs::write(test_repo.dir.join("t3.md"), "some content")?;
+        let dev_oid_first = test_repo.stage_and_commit("add t3.md")?;
+
+        // create feature branch with 1 commit ahead of dev
+        test_repo.create_branch("feature")?;
+        test_repo.checkout("feature")?;
+        std::fs::write(test_repo.dir.join("t4.md"), "some content")?;
+        let feature_oid = test_repo.stage_and_commit("add t4.md")?;
+
+        // make feature branch 1 behind
+        test_repo.checkout("dev")?;
+        std::fs::write(test_repo.dir.join("t3.md"), "some content")?;
+        let dev_oid = test_repo.stage_and_commit("add t3.md")?;
+
+        let (from_branch, to_branch, ahead, behind) = identify_ahead_behind(
+            &git_repo,
+            &Some("feature".to_string()),
+            &Some("dev".to_string()),
+        )?;
+
+        assert_eq!(from_branch, "feature");
+        assert_eq!(ahead, vec![oid_to_sha1(&feature_oid)]);
+        assert_eq!(to_branch, "dev");
+        assert_eq!(behind, vec![oid_to_sha1(&dev_oid)]);
+
+        let (from_branch, to_branch, ahead, behind) =
+            identify_ahead_behind(&git_repo, &Some("feature".to_string()), &None)?;
+
+        assert_eq!(from_branch, "feature");
+        assert_eq!(
+            ahead,
+            vec![oid_to_sha1(&feature_oid), oid_to_sha1(&dev_oid_first)]
+        );
+        assert_eq!(to_branch, "main");
+        assert_eq!(behind, vec![]);
+
+        Ok(())
+    }
+}
diff --git a/src/lib/git/mod.rs b/src/lib/git/mod.rs
index 5919667..f92272f 100644
--- a/src/lib/git/mod.rs
+++ b/src/lib/git/mod.rs
@@ -1,18 +1,16 @@
 use std::{
-    collections::HashSet,
     env::current_dir,
     path::{Path, PathBuf},
 };
 
 use anyhow::{bail, Context, Result};
 use git2::{DiffOptions, Oid, Revwalk};
-use nostr::nips::nip01::Coordinate;
-use nostr_sdk::{
-    hashes::{sha1::Hash as Sha1Hash, Hash},
-    PublicKey, Url,
-};
+pub use identify_ahead_behind::identify_ahead_behind;
+use nostr_sdk::hashes::{sha1::Hash as Sha1Hash, Hash};
 
-use crate::sub_commands::list::{get_commit_id_from_patch, tag_value};
+use crate::git_events::{get_commit_id_from_patch, tag_value};
+pub mod identify_ahead_behind;
+pub mod nostr_url;
 
 pub struct Repo {
     pub git_repo: git2::Repository,
@@ -835,188 +833,6 @@ fn extract_sig_from_patch_tags<'a>(
     .context("failed to create git signature")
 }
 
-#[derive(Debug, PartialEq)]
-pub enum ServerProtocol {
-    Ssh,
-    Https,
-    Http,
-    Git,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct NostrUrlDecoded {
-    pub coordinates: HashSet<Coordinate>,
-    pub protocol: Option<ServerProtocol>,
-    pub user: Option<String>,
-}
-
-static INCORRECT_NOSTR_URL_FORMAT_ERROR: &str = "incorrect nostr git url format. try nostr://naddr123 or nostr://npub123/my-repo or nostr://ssh/npub123/relay.damus.io/my-repo";
-
-impl NostrUrlDecoded {
-    pub fn from_str(url: &str) -> Result<Self> {
-        let mut coordinates = HashSet::new();
-        let mut protocol = None;
-        let mut user = None;
-        let mut relays = vec![];
-
-        if !url.starts_with("nostr://") {
-            bail!("nostr git url must start with nostr://");
-        }
-        // process get url parameters if present
-        for (name, value) in Url::parse(url)?.query_pairs() {
-            if name.contains("relay") {
-                let mut decoded = urlencoding::decode(&value)
-                    .context("could not parse relays in nostr git url")?
-                    .to_string();
-                if !decoded.starts_with("ws://") && !decoded.starts_with("wss://") {
-                    decoded = format!("wss://{decoded}");
-                }
-                let url =
-                    Url::parse(&decoded).context("could not parse relays in nostr git url")?;
-                relays.push(url.to_string());
-            } else if name == "protocol" {
-                protocol = match value.as_ref() {
-                    "ssh" => Some(ServerProtocol::Ssh),
-                    "https" => Some(ServerProtocol::Https),
-                    "http" => Some(ServerProtocol::Http),
-                    "git" => Some(ServerProtocol::Git),
-                    _ => None,
-                };
-            } else if name == "user" {
-                user = Some(value.to_string());
-            }
-        }
-
-        let mut parts: Vec<&str> = url[8..]
-            .split('?')
-            .next()
-            .unwrap_or("")
-            .split('/')
-            .collect();
-
-        // extract optional protocol
-        if protocol.is_none() {
-            let part = parts.first().context(INCORRECT_NOSTR_URL_FORMAT_ERROR)?;
-            let protocol_str = if let Some(at_index) = part.find('@') {
-                user = Some(part[..at_index].to_string());
-                &part[at_index + 1..]
-            } else {
-                part
-            };
-            protocol = match protocol_str {
-                "ssh" => Some(ServerProtocol::Ssh),
-                "https" => Some(ServerProtocol::Https),
-                "http" => Some(ServerProtocol::Http),
-                "git" => Some(ServerProtocol::Git),
-                _ => protocol,
-            };
-            if protocol.is_some() {
-                parts.remove(0);
-            }
-        }
-        // extract naddr npub/<optional-relays>/identifer
-        let part = parts.first().context(INCORRECT_NOSTR_URL_FORMAT_ERROR)?;
-        // naddr used
-        if let Ok(coordinate) = Coordinate::parse(part) {
-            if coordinate.kind.eq(&nostr_sdk::Kind::GitRepoAnnouncement) {
-                coordinates.insert(coordinate);
-            } else {
-                bail!("naddr doesnt point to a git repository announcement");
-            }
-        // npub/<optional-relays>/identifer used
-        } else if let Ok(public_key) = PublicKey::parse(part) {
-            parts.remove(0);
-            let identifier = parts
-                .pop()
-                .context("nostr url must have an identifier eg. nostr://npub123/repo-identifier")?
-                .to_string();
-            for relay in parts {
-                let mut decoded = urlencoding::decode(relay)
-                    .context("could not parse relays in nostr git url")?
-                    .to_string();
-                if !decoded.starts_with("ws://") && !decoded.starts_with("wss://") {
-                    decoded = format!("wss://{decoded}");
-                }
-                let url =
-                    Url::parse(&decoded).context("could not parse relays in nostr git url")?;
-                relays.push(url.to_string());
-            }
-            coordinates.insert(Coordinate {
-                identifier,
-                public_key,
-                kind: nostr_sdk::Kind::GitRepoAnnouncement,
-                relays,
-            });
-        } else {
-            bail!(INCORRECT_NOSTR_URL_FORMAT_ERROR);
-        }
-
-        Ok(Self {
-            coordinates,
-            protocol,
-            user,
-        })
-    }
-}
-
-/** produce error when using local repo or custom protocols */
-pub fn convert_clone_url_to_https(url: &str) -> Result<String> {
-    // Strip credentials if present
-    let stripped_url = strip_credentials(url);
-
-    // Check if the URL is already in HTTPS format
-    if stripped_url.starts_with("https://") {
-        return Ok(stripped_url);
-    }
-    // Convert http:// to https://
-    else if stripped_url.starts_with("http://") {
-        return Ok(stripped_url.replace("http://", "https://"));
-    }
-    // Check if the URL starts with SSH
-    else if stripped_url.starts_with("ssh://") {
-        // Convert SSH to HTTPS
-        let parts: Vec<&str> = stripped_url
-            .trim_start_matches("ssh://")
-            .split('/')
-            .collect();
-        if parts.len() >= 2 {
-            // Construct the HTTPS URL
-            return Ok(format!("https://{}/{}", parts[0], parts[1..].join("/")));
-        }
-        bail!("Invalid SSH URL format: {}", url);
-    }
-    // Convert ftp:// to https://
-    else if stripped_url.starts_with("ftp://") {
-        return Ok(stripped_url.replace("ftp://", "https://"));
-    }
-    // Convert git:// to https://
-    else if stripped_url.starts_with("git://") {
-        return Ok(stripped_url.replace("git://", "https://"));
-    }
-
-    // If the URL is neither HTTPS, SSH, nor git@, return an error
-    bail!("Unsupported URL protocol: {}", url);
-}
-
-// Function to strip username and password from the URL
-fn strip_credentials(url: &str) -> String {
-    if let Some(pos) = url.find("://") {
-        let (protocol, rest) = url.split_at(pos + 3); // Split at "://"
-        let rest_parts: Vec<&str> = rest.split('@').collect();
-        if rest_parts.len() > 1 {
-            // If there are credentials, return the URL without them
-            return format!("{}{}", protocol, rest_parts[1]);
-        }
-    } else if let Some(at_pos) = url.find('@') {
-        // Handle user@host:path format
-        let (_, rest) = url.split_at(at_pos);
-        // This is a git@ syntax
-        let host_and_repo = &rest[1..]; // Skip the ':'
-        return format!("ssh://{}", host_and_repo.replace(':', "/"));
-    }
-    url.to_string() // Return the original URL if no credentials are found
-}
-
 #[cfg(test)]
 mod tests {
     use std::fs;
@@ -1813,7 +1629,7 @@ mod tests {
         use test_utils::TEST_KEY_1_SIGNER;
 
         use super::*;
-        use crate::{repo_ref::RepoRef, sub_commands::send::generate_patch_event};
+        use crate::{git_events::generate_patch_event, repo_ref::RepoRef};
 
         async fn generate_patch_from_head_commit(test_repo: &GitTestRepo) -> Result<nostr::Event> {
             let original_oid = test_repo.git_repo.head()?.peel_to_commit()?.id();
@@ -1959,9 +1775,7 @@ mod tests {
         use test_utils::TEST_KEY_1_SIGNER;
 
         use super::*;
-        use crate::{
-            repo_ref::RepoRef, sub_commands::send::generate_cover_letter_and_patch_events,
-        };
+        use crate::{git_events::generate_cover_letter_and_patch_events, repo_ref::RepoRef};
 
         static BRANCH_NAME: &str = "add-example-feature";
         // returns original_repo, cover_letter_event, patch_events
@@ -2497,70 +2311,4 @@ mod tests {
             Ok(())
         }
     }
-    mod convert_clone_url_to_https {
-        use super::*;
-
-        #[test]
-        fn test_https_url() {
-            let url = "https://github.com/user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_http_url() {
-            let url = "http://github.com/user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_http_url_with_credentials() {
-            let url = "http://username:password@github.com/user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_git_at_url() {
-            let url = "git@github.com:user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_user_at_url() {
-            let url = "user1@github.com:user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_ssh_url() {
-            let url = "ssh://github.com/user/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://github.com/user/repo.git");
-        }
-
-        #[test]
-        fn test_ftp_url() {
-            let url = "ftp://example.com/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://example.com/repo.git");
-        }
-
-        #[test]
-        fn test_git_protocol_url() {
-            let url = "git://example.com/repo.git";
-            let result = convert_clone_url_to_https(url).unwrap();
-            assert_eq!(result, "https://example.com/repo.git");
-        }
-
-        #[test]
-        fn test_invalid_url() {
-            let url = "unsupported://example.com/repo.git";
-            let result = convert_clone_url_to_https(url);
-            assert!(result.is_err());
-        }
-    }
 }
diff --git a/src/lib/git/nostr_url.rs b/src/lib/git/nostr_url.rs
new file mode 100644
index 0000000..ce3e973
--- /dev/null
+++ b/src/lib/git/nostr_url.rs
@@ -0,0 +1,501 @@
+use std::collections::HashSet;
+
+use anyhow::{bail, Context, Result};
+use nostr::nips::nip01::Coordinate;
+use nostr_sdk::{PublicKey, Url};
+
+#[derive(Debug, PartialEq)]
+pub enum ServerProtocol {
+    Ssh,
+    Https,
+    Http,
+    Git,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct NostrUrlDecoded {
+    pub coordinates: HashSet<Coordinate>,
+    pub protocol: Option<ServerProtocol>,
+    pub user: Option<String>,
+}
+
+static INCORRECT_NOSTR_URL_FORMAT_ERROR: &str = "incorrect nostr git url format. try nostr://naddr123 or nostr://npub123/my-repo or nostr://ssh/npub123/relay.damus.io/my-repo";
+
+impl NostrUrlDecoded {
+    pub fn from_str(url: &str) -> Result<Self> {
+        let mut coordinates = HashSet::new();
+        let mut protocol = None;
+        let mut user = None;
+        let mut relays = vec![];
+
+        if !url.starts_with("nostr://") {
+            bail!("nostr git url must start with nostr://");
+        }
+        // process get url parameters if present
+        for (name, value) in Url::parse(url)?.query_pairs() {
+            if name.contains("relay") {
+                let mut decoded = urlencoding::decode(&value)
+                    .context("could not parse relays in nostr git url")?
+                    .to_string();
+                if !decoded.starts_with("ws://") && !decoded.starts_with("wss://") {
+                    decoded = format!("wss://{decoded}");
+                }
+                let url =
+                    Url::parse(&decoded).context("could not parse relays in nostr git url")?;
+                relays.push(url.to_string());
+            } else if name == "protocol" {
+                protocol = match value.as_ref() {
+                    "ssh" => Some(ServerProtocol::Ssh),
+                    "https" => Some(ServerProtocol::Https),
+                    "http" => Some(ServerProtocol::Http),
+                    "git" => Some(ServerProtocol::Git),
+                    _ => None,
+                };
+            } else if name == "user" {
+                user = Some(value.to_string());
+            }
+        }
+
+        let mut parts: Vec<&str> = url[8..]
+            .split('?')
+            .next()
+            .unwrap_or("")
+            .split('/')
+            .collect();
+
+        // extract optional protocol
+        if protocol.is_none() {
+            let part = parts.first().context(INCORRECT_NOSTR_URL_FORMAT_ERROR)?;
+            let protocol_str = if let Some(at_index) = part.find('@') {
+                user = Some(part[..at_index].to_string());
+                &part[at_index + 1..]
+            } else {
+                part
+            };
+            protocol = match protocol_str {
+                "ssh" => Some(ServerProtocol::Ssh),
+                "https" => Some(ServerProtocol::Https),
+                "http" => Some(ServerProtocol::Http),
+                "git" => Some(ServerProtocol::Git),
+                _ => protocol,
+            };
+            if protocol.is_some() {
+                parts.remove(0);
+            }
+        }
+        // extract naddr npub/<optional-relays>/identifer
+        let part = parts.first().context(INCORRECT_NOSTR_URL_FORMAT_ERROR)?;
+        // naddr used
+        if let Ok(coordinate) = Coordinate::parse(part) {
+            if coordinate.kind.eq(&nostr_sdk::Kind::GitRepoAnnouncement) {
+                coordinates.insert(coordinate);
+            } else {
+                bail!("naddr doesnt point to a git repository announcement");
+            }
+        // npub/<optional-relays>/identifer used
+        } else if let Ok(public_key) = PublicKey::parse(part) {
+            parts.remove(0);
+            let identifier = parts
+                .pop()
+                .context("nostr url must have an identifier eg. nostr://npub123/repo-identifier")?
+                .to_string();
+            for relay in parts {
+                let mut decoded = urlencoding::decode(relay)
+                    .context("could not parse relays in nostr git url")?
+                    .to_string();
+                if !decoded.starts_with("ws://") && !decoded.starts_with("wss://") {
+                    decoded = format!("wss://{decoded}");
+                }
+                let url =
+                    Url::parse(&decoded).context("could not parse relays in nostr git url")?;
+                relays.push(url.to_string());
+            }
+            coordinates.insert(Coordinate {
+                identifier,
+                public_key,
+                kind: nostr_sdk::Kind::GitRepoAnnouncement,
+                relays,
+            });
+        } else {
+            bail!(INCORRECT_NOSTR_URL_FORMAT_ERROR);
+        }
+
+        Ok(Self {
+            coordinates,
+            protocol,
+            user,
+        })
+    }
+}
+
+/** produce error when using local repo or custom protocols */
+pub fn convert_clone_url_to_https(url: &str) -> Result<String> {
+    // Strip credentials if present
+    let stripped_url = strip_credentials(url);
+
+    // Check if the URL is already in HTTPS format
+    if stripped_url.starts_with("https://") {
+        return Ok(stripped_url);
+    }
+    // Convert http:// to https://
+    else if stripped_url.starts_with("http://") {
+        return Ok(stripped_url.replace("http://", "https://"));
+    }
+    // Check if the URL starts with SSH
+    else if stripped_url.starts_with("ssh://") {
+        // Convert SSH to HTTPS
+        let parts: Vec<&str> = stripped_url
+            .trim_start_matches("ssh://")
+            .split('/')
+            .collect();
+        if parts.len() >= 2 {
+            // Construct the HTTPS URL
+            return Ok(format!("https://{}/{}", parts[0], parts[1..].join("/")));
+        }
+        bail!("Invalid SSH URL format: {}", url);
+    }
+    // Convert ftp:// to https://
+    else if stripped_url.starts_with("ftp://") {
+        return Ok(stripped_url.replace("ftp://", "https://"));
+    }
+    // Convert git:// to https://
+    else if stripped_url.starts_with("git://") {
+        return Ok(stripped_url.replace("git://", "https://"));
+    }
+
+    // If the URL is neither HTTPS, SSH, nor git@, return an error
+    bail!("Unsupported URL protocol: {}", url);
+}
+
+// Function to strip username and password from the URL
+fn strip_credentials(url: &str) -> String {
+    if let Some(pos) = url.find("://") {
+        let (protocol, rest) = url.split_at(pos + 3); // Split at "://"
+        let rest_parts: Vec<&str> = rest.split('@').collect();
+        if rest_parts.len() > 1 {
+            // If there are credentials, return the URL without them
+            return format!("{}{}", protocol, rest_parts[1]);
+        }
+    } else if let Some(at_pos) = url.find('@') {
+        // Handle user@host:path format
+        let (_, rest) = url.split_at(at_pos);
+        // This is a git@ syntax
+        let host_and_repo = &rest[1..]; // Skip the ':'
+        return format!("ssh://{}", host_and_repo.replace(':', "/"));
+    }
+    url.to_string() // Return the original URL if no credentials are found
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    mod convert_clone_url_to_https {
+        use super::*;
+
+        #[test]
+        fn test_https_url() {
+            let url = "https://github.com/user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_http_url() {
+            let url = "http://github.com/user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_http_url_with_credentials() {
+            let url = "http://username:password@github.com/user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_git_at_url() {
+            let url = "git@github.com:user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_user_at_url() {
+            let url = "user1@github.com:user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_ssh_url() {
+            let url = "ssh://github.com/user/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://github.com/user/repo.git");
+        }
+
+        #[test]
+        fn test_ftp_url() {
+            let url = "ftp://example.com/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://example.com/repo.git");
+        }
+
+        #[test]
+        fn test_git_protocol_url() {
+            let url = "git://example.com/repo.git";
+            let result = convert_clone_url_to_https(url).unwrap();
+            assert_eq!(result, "https://example.com/repo.git");
+        }
+
+        #[test]
+        fn test_invalid_url() {
+            let url = "unsupported://example.com/repo.git";
+            let result = convert_clone_url_to_https(url);
+            assert!(result.is_err());
+        }
+    }
+
+    mod nostr_git_url_paramemters_from_str {
+        use super::*;
+
+        fn get_model_coordinate(relays: bool) -> Coordinate {
+            Coordinate {
+                identifier: "ngit".to_string(),
+                public_key: PublicKey::parse(
+                    "npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr",
+                )
+                .unwrap(),
+                kind: nostr_sdk::Kind::GitRepoAnnouncement,
+                relays: if relays {
+                    vec!["wss://nos.lol/".to_string()]
+                } else {
+                    vec![]
+                },
+            }
+        }
+
+        #[test]
+        fn from_naddr() -> Result<()> {
+            assert_eq!(
+                NostrUrlDecoded::from_str(
+                    "nostr://naddr1qqzxuemfwsqs6amnwvaz7tmwdaejumr0dspzpgqgmmc409hm4xsdd74sf68a2uyf9pwel4g9mfdg8l5244t6x4jdqvzqqqrhnym0k2qj"
+                )?,
+                NostrUrlDecoded {
+                    coordinates: HashSet::from([Coordinate {
+                        identifier: "ngit".to_string(),
+                        public_key: PublicKey::parse(
+                            "npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr",
+                        )
+                        .unwrap(),
+                        kind: nostr_sdk::Kind::GitRepoAnnouncement,
+                        relays: vec!["wss://nos.lol".to_string()], // wont add the slash
+                    }]),
+                    protocol: None,
+                    user: None,
+                },
+            );
+            Ok(())
+        }
+        mod from_npub_slash_identifier {
+            use super::*;
+
+            #[test]
+            fn without_relay() -> Result<()> {
+                assert_eq!(
+                    NostrUrlDecoded::from_str(
+                        "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit"
+                    )?,
+                    NostrUrlDecoded {
+                        coordinates: HashSet::from([get_model_coordinate(false)]),
+                        protocol: None,
+                        user: None,
+                    },
+                );
+                Ok(())
+            }
+
+            mod with_url_parameters {
+
+                use super::*;
+
+                #[test]
+                fn with_relay_without_scheme_defaults_to_wss() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit?relay=nos.lol"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(true)]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+
+                #[test]
+                fn with_encoded_relay() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(&format!(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit?relay={}",
+                            urlencoding::encode("wss://nos.lol")
+                        ))?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(true)]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+                #[test]
+                fn with_multiple_encoded_relays() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(&format!(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit?relay={}&relay1={}",
+                            urlencoding::encode("wss://nos.lol"),
+                            urlencoding::encode("wss://relay.damus.io"),
+                        ))?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([Coordinate {
+                                identifier: "ngit".to_string(),
+                                public_key: PublicKey::parse(
+                                    "npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr",
+                                )
+                                .unwrap(),
+                                kind: nostr_sdk::Kind::GitRepoAnnouncement,
+                                relays: vec![
+                                    "wss://nos.lol/".to_string(),
+                                    "wss://relay.damus.io/".to_string(),
+                                ],
+                            }]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+
+                #[test]
+                fn with_server_protocol() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit?protocol=ssh"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(false)]),
+                            protocol: Some(ServerProtocol::Ssh),
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+                #[test]
+                fn with_server_protocol_and_user() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit?protocol=ssh&user=fred"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(false)]),
+                            protocol: Some(ServerProtocol::Ssh),
+                            user: Some("fred".to_string()),
+                        },
+                    );
+                    Ok(())
+                }
+            }
+            mod with_parameters_embedded_with_slashes {
+                use super::*;
+
+                #[test]
+                fn with_relay_without_scheme_defaults_to_wss() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/nos.lol/ngit"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(true)]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+
+                #[test]
+                fn with_encoded_relay() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(&format!(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/{}/ngit",
+                            urlencoding::encode("wss://nos.lol")
+                        ))?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(true)]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+                #[test]
+                fn with_multiple_encoded_relays() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(&format!(
+                            "nostr://npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/{}/{}/ngit",
+                            urlencoding::encode("wss://nos.lol"),
+                            urlencoding::encode("wss://relay.damus.io"),
+                        ))?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([Coordinate {
+                                identifier: "ngit".to_string(),
+                                public_key: PublicKey::parse(
+                                    "npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr",
+                                )
+                                .unwrap(),
+                                kind: nostr_sdk::Kind::GitRepoAnnouncement,
+                                relays: vec![
+                                    "wss://nos.lol/".to_string(),
+                                    "wss://relay.damus.io/".to_string(),
+                                ],
+                            }]),
+                            protocol: None,
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+
+                #[test]
+                fn with_server_protocol() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://ssh/npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(false)]),
+                            protocol: Some(ServerProtocol::Ssh),
+                            user: None,
+                        },
+                    );
+                    Ok(())
+                }
+                #[test]
+                fn with_server_protocol_and_user() -> Result<()> {
+                    assert_eq!(
+                        NostrUrlDecoded::from_str(
+                            "nostr://fred@ssh/npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit"
+                        )?,
+                        NostrUrlDecoded {
+                            coordinates: HashSet::from([get_model_coordinate(false)]),
+                            protocol: Some(ServerProtocol::Ssh),
+                            user: Some("fred".to_string()),
+                        },
+                    );
+                    Ok(())
+                }
+            }
+        }
+    }
+}