6 files changed, 100 insertions, 96 deletions

diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index adc68b3..b191850 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -18,7 +18,7 @@ use ngit::{
     },
     git_events::tag_value,
     login::get_curent_user,
-    repo_ref::{RepoRef, is_ngit_relay},
+    repo_ref::{RepoRef, is_grasp_server},
 };
 use nostr::nips::nip19;
 use nostr_sdk::{Event, ToBech32};
@@ -54,7 +54,7 @@ pub async fn run_fetch(
             git_server_url,
             &repo_ref.to_nostr_git_url(&None),
             &term,
-            is_ngit_relay(git_server_url, &repo_ref.ngit_relays()),
+            is_grasp_server(git_server_url, &repo_ref.grasp_servers()),
         ) {
             errors.push(error);
         } else {
@@ -164,7 +164,7 @@ pub fn fetch_from_git_server(
     git_server_url: &str,
     decoded_nostr_url: &NostrUrlDecoded,
     term: &console::Term,
-    is_ngit_relay: bool,
+    is_grasp_server: bool,
 ) -> Result<()> {
     let already_have_oids = oids
         .iter()
@@ -176,7 +176,7 @@ pub fn fetch_from_git_server(
     let server_url = git_server_url.parse::<CloneUrl>()?;
 
     let protocols_to_attempt =
-        get_read_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_ngit_relay);
+        get_read_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_grasp_server);
 
     let mut failed_protocols = vec![];
     let mut success = false;
diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs
index c27e4d2..b9fb0c0 100644
--- a/src/bin/git_remote_nostr/list.rs
+++ b/src/bin/git_remote_nostr/list.rs
@@ -13,7 +13,7 @@ use ngit::{
     },
     git_events::event_to_cover_letter,
     login::get_curent_user,
-    repo_ref::{self, is_ngit_relay},
+    repo_ref::{self, is_grasp_server},
 };
 use nostr_sdk::hashes::sha1::Hash as Sha1Hash;
 use repo_ref::RepoRef;
@@ -41,12 +41,12 @@ pub async fn run_list(
         git_repo,
         &repo_ref.git_server,
         &repo_ref.to_nostr_git_url(&None),
-        &repo_ref.ngit_relays(),
+        &repo_ref.grasp_servers(),
     );
 
     let mut state = if let Some(nostr_state) = nostr_state {
         for (name, value) in &nostr_state.state {
-            for (url, (remote_state, _is_ngit_relay)) in &remote_states {
+            for (url, (remote_state, _is_grasp_server)) in &remote_states {
                 let remote_name = get_short_git_server_name(git_repo, url);
                 if let Some(remote_value) = remote_state.get(name) {
                     if value.ne(remote_value) {
@@ -74,7 +74,7 @@ pub async fn run_list(
         }
         nostr_state.state
     } else {
-        let (state, _is_ngit_relay) = repo_ref
+        let (state, _is_grasp_server) = repo_ref
             .git_server
             .iter()
             .filter_map(|server| remote_states.get(server))
@@ -122,7 +122,7 @@ async fn get_open_and_draft_proposals_state(
 
     // without trusting commit_id we must apply each patch which requires the oid of
     // the parent so we much do a fetch
-    for (git_server_url, (oids_from_git_servers, is_ngit_relay)) in remote_states {
+    for (git_server_url, (oids_from_git_servers, is_grasp_server)) in remote_states {
         if fetch_from_git_server(
             git_repo,
             &oids_from_git_servers
@@ -133,7 +133,7 @@ async fn get_open_and_draft_proposals_state(
             git_server_url,
             &repo_ref.to_nostr_git_url(&None),
             term,
-            *is_ngit_relay,
+            *is_grasp_server,
         )
         .is_ok()
         {
@@ -178,18 +178,18 @@ pub fn list_from_remotes(
     git_repo: &Repo,
     git_servers: &Vec<String>,
     decoded_nostr_url: &NostrUrlDecoded,
-    ngit_relays: &[String],
+    grasp_servers: &[String],
 ) -> HashMap<String, (HashMap<String, String>, bool)> {
     let mut remote_states = HashMap::new();
     let mut errors = HashMap::new();
     for url in git_servers {
-        let is_ngit_relay = is_ngit_relay(url, ngit_relays);
-        match list_from_remote(term, git_repo, url, decoded_nostr_url, is_ngit_relay) {
+        let is_grasp_server = is_grasp_server(url, grasp_servers);
+        match list_from_remote(term, git_repo, url, decoded_nostr_url, is_grasp_server) {
             Err(error) => {
                 errors.insert(url, error);
             }
             Ok(state) => {
-                remote_states.insert(url.to_string(), (state, is_ngit_relay));
+                remote_states.insert(url.to_string(), (state, is_grasp_server));
             }
         }
     }
@@ -201,11 +201,11 @@ pub fn list_from_remote(
     git_repo: &Repo,
     git_server_url: &str,
     decoded_nostr_url: &NostrUrlDecoded,
-    is_ngit_relay: bool,
+    is_grasp_server: bool,
 ) -> Result<HashMap<String, String>> {
     let server_url = git_server_url.parse::<CloneUrl>()?;
     let protocols_to_attempt =
-        get_read_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_ngit_relay);
+        get_read_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_grasp_server);
 
     let mut failed_protocols = vec![];
     let mut remote_state: Option<HashMap<String, String>> = None;
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index 9e54ca7..04fc4d8 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -25,7 +25,7 @@ use ngit::{
     },
     git_events::{self, event_to_cover_letter, get_event_root},
     login::{self, user::UserRef},
-    repo_ref::{self, get_repo_config_from_yaml, is_ngit_relay},
+    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server},
     repo_state,
 };
 use nostr::nips::nip10::Marker;
@@ -79,7 +79,7 @@ pub async fn run_push(
             git_repo,
             &repo_ref.git_server,
             &repo_ref.to_nostr_git_url(&None),
-            &repo_ref.ngit_relays(),
+            &repo_ref.grasp_servers(),
         )
     });
 
@@ -92,7 +92,7 @@ pub async fn run_push(
             .iter()
             .find(|&url| list_outputs.contains_key(url))
         {
-            let (state, _is_ngit_relay) = list_outputs.get(url).unwrap().to_owned();
+            let (state, _is_grasp_server) = list_outputs.get(url).unwrap().to_owned();
             state
         } else {
             bail!(
@@ -163,7 +163,7 @@ pub async fn run_push(
                         &repo_ref.to_nostr_git_url(&None),
                         &remote_refspecs,
                         &term,
-                        is_ngit_relay(&git_server_url, &repo_ref.ngit_relays()),
+                        is_grasp_server(&git_server_url, &repo_ref.grasp_servers()),
                     );
                 }
             }
@@ -429,11 +429,11 @@ fn push_to_remote(
     decoded_nostr_url: &NostrUrlDecoded,
     remote_refspecs: &[String],
     term: &Term,
-    is_ngit_relay: bool,
+    is_grasp_server: bool,
 ) -> Result<()> {
     let server_url = git_server_url.parse::<CloneUrl>()?;
     let protocols_to_attempt =
-        get_write_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_ngit_relay);
+        get_write_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_grasp_server);
 
     let mut failed_protocols = vec![];
     let mut success = false;
@@ -726,8 +726,8 @@ fn create_rejected_refspecs_and_remotes_refspecs(
 
     let mut rejected_refspecs: HashMapUrlRefspecs = HashMap::new();
 
-    for (url, (remote_state, is_ngit_relay)) in list_outputs {
-        let is_ngit_relay = is_ngit_relay.to_owned();
+    for (url, (remote_state, is_grasp_server)) in list_outputs {
+        let is_grasp_server = is_grasp_server.to_owned();
         let short_name = get_short_git_server_name(git_repo, url);
         let mut refspecs_for_remote = vec![];
         for refspec in refspecs {
@@ -788,7 +788,7 @@ fn create_rejected_refspecs_and_remotes_refspecs(
                             if ahead_of_nostr.is_empty() {
                                 // ancestor of nostr and we are force pushing anyway...
                                 refspecs_for_remote.push(refspec.clone());
-                            } else if is_ngit_relay {
+                            } else if is_grasp_server {
                                 // a grasp server can only be pushed to via nostr so can force push
                                 refspecs_for_remote.push(ensure_force_push_refspec(refspec));
                             } else {
@@ -807,7 +807,7 @@ fn create_rejected_refspecs_and_remotes_refspecs(
                                 )?;
                             }
                         }
-                    } else if is_ngit_relay {
+                    } else if is_grasp_server {
                         refspecs_for_remote.push(ensure_force_push_refspec(refspec));
                     } else {
                         // remote_value oid is not present locally
@@ -842,7 +842,7 @@ fn create_rejected_refspecs_and_remotes_refspecs(
                     if ahead.is_empty() {
                         // can soft push
                         refspecs_for_remote.push(refspec.clone());
-                    } else if is_ngit_relay {
+                    } else if is_grasp_server {
                         refspecs_for_remote.push(ensure_force_push_refspec(refspec));
                     } else {
                         // cant soft push
@@ -858,7 +858,7 @@ fn create_rejected_refspecs_and_remotes_refspecs(
                                     ).as_str(),
                                 )?;
                     }
-                } else if is_ngit_relay {
+                } else if is_grasp_server {
                     refspecs_for_remote.push(ensure_force_push_refspec(refspec));
                 } else {
                     // havn't fetched oid from remote
diff --git a/src/bin/git_remote_nostr/utils.rs b/src/bin/git_remote_nostr/utils.rs
index ec6412b..f7e688e 100644
--- a/src/bin/git_remote_nostr/utils.rs
+++ b/src/bin/git_remote_nostr/utils.rs
@@ -216,9 +216,9 @@ pub fn get_read_protocols_to_try(
     git_repo: &Repo,
     server_url: &CloneUrl,
     decoded_nostr_url: &NostrUrlDecoded,
-    is_ngit_relay: bool,
+    is_grasp_server: bool,
 ) -> Vec<ServerProtocol> {
-    if is_ngit_relay {
+    if is_grasp_server {
         if server_url.protocol() == ServerProtocol::Http {
             vec![(ServerProtocol::UnauthHttp)]
         } else {
@@ -269,9 +269,9 @@ pub fn get_write_protocols_to_try(
     git_repo: &Repo,
     server_url: &CloneUrl,
     decoded_nostr_url: &NostrUrlDecoded,
-    is_ngit_relay: bool,
+    is_grasp_server: bool,
 ) -> Vec<ServerProtocol> {
-    if is_ngit_relay {
+    if is_grasp_server {
         if server_url.protocol() == ServerProtocol::Http {
             vec![(ServerProtocol::UnauthHttp)]
         } else {
diff --git a/src/bin/ngit/sub_commands/init.rs b/src/bin/ngit/sub_commands/init.rs
index 7e095a3..1242e45 100644
--- a/src/bin/ngit/sub_commands/init.rs
+++ b/src/bin/ngit/sub_commands/init.rs
@@ -16,7 +16,7 @@ use ngit::{
     client::{Params, send_events},
     git::nostr_url::{CloneUrl, NostrUrlDecoded},
     repo_ref::{
-        detect_existing_ngit_relays, extract_npub, extract_pks, normalize_ngit_relay_url,
+        detect_existing_grasp_servers, extract_npub, extract_pks, normalize_grasp_server_url,
         save_repo_config_to_yaml,
     },
 };
@@ -252,20 +252,20 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         args.blossoms.clone()
     };
 
-    let fallback_ngit_relays =
+    let fallback_grasp_servers =
         if let Ok(Some(s)) = git_repo.get_git_config_item("nostr.grasp-default-set", None) {
             s.split(';')
-                .filter_map(|url| normalize_ngit_relay_url(url).ok()) // Attempt to parse and filter out errors
+                .filter_map(|url| normalize_grasp_server_url(url).ok()) // Attempt to parse and filter out errors
                 .collect()
         } else {
             vec!["relay.ngit.dev".to_string(), "gitnostr.com".to_string()]
         };
 
-    let selected_ngit_relays = if has_server_and_relay_flags {
+    let selected_grasp_servers = if has_server_and_relay_flags {
         // ignore so a script running `ngit init` can contiue without prompts
         vec![]
     } else {
-        let mut options: Vec<String> = detect_existing_ngit_relays(
+        let mut options: Vec<String> = detect_existing_grasp_servers(
             repo_ref.as_ref(),
             &args.relays,
             &args.clone_url,
@@ -274,7 +274,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         );
         let mut selections: Vec<bool> = vec![true; options.len()]; // Initialize selections based on existing options
         let empty = options.is_empty();
-        for fallback in fallback_ngit_relays {
+        for fallback in fallback_grasp_servers {
             // Check if any option contains the fallback as a substring
             if !options.iter().any(|option| option.contains(&fallback)) {
                 options.push(fallback.clone()); // Add fallback if not found
@@ -286,22 +286,25 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             "grasp server",
             options,
             selections,
-            normalize_ngit_relay_url,
+            normalize_grasp_server_url,
         )?;
         show_multi_input_prompt_success("grasp servers", &selected);
         selected
     };
 
     // ensure ngit relays are added as git server, relay and blossom entries
-    for ngit_relay in &selected_ngit_relays {
+    for grasp_server in &selected_grasp_servers {
         if args.clone_url.is_empty() {
-            let clone_url =
-                format_ngit_relay_url_as_clone_url(ngit_relay, &user_ref.public_key, &identifier)?;
+            let clone_url = format_grasp_server_url_as_clone_url(
+                grasp_server,
+                &user_ref.public_key,
+                &identifier,
+            )?;
 
-            let ngit_relay_clone_root = if clone_url.contains("https://") {
-                format!("https://{ngit_relay}")
+            let grasp_server_clone_root = if clone_url.contains("https://") {
+                format!("https://{grasp_server}")
             } else {
-                ngit_relay.to_string()
+                grasp_server.to_string()
             };
 
             // Find all positions of entries containing the relay root
@@ -309,7 +312,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 .iter()
                 .enumerate()
                 .filter_map(|(idx, url)| {
-                    if url.contains(&ngit_relay_clone_root) {
+                    if url.contains(&grasp_server_clone_root) {
                         Some(idx)
                     } else {
                         None
@@ -332,13 +335,13 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             }
         }
         if args.relays.is_empty() {
-            let relay_url = format_ngit_relay_url_as_relay_url(ngit_relay)?;
+            let relay_url = format_grasp_server_url_as_relay_url(grasp_server)?;
             if !relay_defaults.contains(&relay_url) {
                 relay_defaults.push(relay_url);
             }
         }
         if args.blossoms.is_empty() {
-            let blossom = format_ngit_relay_url_as_blossom_url(ngit_relay)?;
+            let blossom = format_grasp_server_url_as_blossom_url(grasp_server)?;
             if !blossoms_defaults.contains(&blossom) {
                 blossoms_defaults.push(blossom);
             }
@@ -370,18 +373,18 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     }
 
     let git_server = if args.clone_url.is_empty() {
-        let ngit_relay_git_servers: Vec<String> = git_server_defaults
+        let grasp_server_git_servers: Vec<String> = git_server_defaults
             .iter()
-            .filter(|s| selected_ngit_relays.iter().any(|r| s.contains(r)))
+            .filter(|s| selected_grasp_servers.iter().any(|r| s.contains(r)))
             .cloned()
             .collect();
         let mut additional_server_options: Vec<String> = git_server_defaults
             .iter()
-            .filter(|s| ngit_relay_git_servers.iter().any(|r| s.eq(&r)))
+            .filter(|s| grasp_server_git_servers.iter().any(|r| s.eq(&r)))
             .cloned()
             .collect();
 
-        if simple_mode && !selected_ngit_relays.is_empty() {
+        if simple_mode && !selected_grasp_servers.is_empty() {
             if additional_server_options.is_empty() {
                 // additional git servers were listed
                 let selected = loop {
@@ -414,7 +417,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                     break selected;
                 };
                 show_multi_input_prompt_success("git servers", &selected);
-                let mut combined = ngit_relay_git_servers;
+                let mut combined = grasp_server_git_servers;
                 combined.extend(selected);
                 combined
             } else {
@@ -444,14 +447,14 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
 
     let relays: Vec<RelayUrl> = {
         if simple_mode {
-            let formatted_selected_ngit_relays: Vec<String> = selected_ngit_relays
+            let formatted_selected_grasp_servers: Vec<String> = selected_grasp_servers
                 .iter()
-                .filter_map(|r| format_ngit_relay_url_as_relay_url(r).ok())
+                .filter_map(|r| format_grasp_server_url_as_relay_url(r).ok())
                 .collect();
             let mut options: Vec<String> = relay_defaults
                 .iter()
                 .filter(|s| {
-                    !formatted_selected_ngit_relays
+                    !formatted_selected_grasp_servers
                         .iter()
                         .any(|r| s.as_str() == r)
                 })
@@ -463,7 +466,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             // add fallback relays as options
             for relay in client.get_fallback_relays().clone() {
                 if !options.iter().any(|r| r.contains(&relay))
-                    && !formatted_selected_ngit_relays
+                    && !formatted_selected_grasp_servers
                         .iter()
                         .any(|r| relay.contains(r))
                 {
@@ -485,7 +488,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             )?;
             show_multi_input_prompt_success("additional nostr relays", &selected);
             [
-                formatted_selected_ngit_relays
+                formatted_selected_grasp_servers
                     .iter()
                     .filter_map(|r| parse_relay_url(r).ok())
                     .collect::<Vec<RelayUrl>>(),
@@ -538,7 +541,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                     blossoms_defaults,
                     selections,
                     |s| {
-                        format_ngit_relay_url_as_blossom_url(s)
+                        format_grasp_server_url_as_blossom_url(s)
                             .context(format!("Invalid blossom URL format: {s}"))
                     },
                 )?;
@@ -616,7 +619,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         default_maintainers
     };
 
-    if selected_ngit_relays.is_empty() && git_server.iter().any(|s| s.contains("github.com") || s.contains("codeberg.org")) && Interactor::default().confirm(
+    if selected_grasp_servers.is_empty() && git_server.iter().any(|s| s.contains("github.com") || s.contains("codeberg.org")) && Interactor::default().confirm(
             PromptConfirmParms::default()
                 .with_prompt("you have listed github / codeberg. Are you or other maintainers planning on pushing directly to github / codeberg rather than using your shiny new nostr clone url which will do this for you?")
                 .with_default(false),
@@ -782,7 +785,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         // ignore during tests as git-remote-nostr isn't installed during ngit binary
         // tests
 
-        if selected_ngit_relays.is_empty() {
+        if selected_grasp_servers.is_empty() {
             println!("running `git push` to publish your repository data");
         } else {
             let countdown_start = 5;
@@ -940,38 +943,38 @@ where
     Ok(selected_choices)
 }
 
-fn format_ngit_relay_url_as_clone_url(
+fn format_grasp_server_url_as_clone_url(
     url: &str,
     public_key: &PublicKey,
     identifier: &str,
 ) -> Result<String> {
-    let ngit_relay_url = normalize_ngit_relay_url(url)?;
-    if ngit_relay_url.contains("http://") {
+    let grasp_server_url = normalize_grasp_server_url(url)?;
+    if grasp_server_url.contains("http://") {
         return Ok(format!(
-            "{ngit_relay_url}/{}/{identifier}.git",
+            "{grasp_server_url}/{}/{identifier}.git",
             public_key.to_bech32()?
         ));
     }
     Ok(format!(
-        "https://{ngit_relay_url}/{}/{identifier}.git",
+        "https://{grasp_server_url}/{}/{identifier}.git",
         public_key.to_bech32()?
     ))
 }
 
-fn format_ngit_relay_url_as_relay_url(url: &str) -> Result<String> {
-    let ngit_relay_url = normalize_ngit_relay_url(url)?;
-    if ngit_relay_url.contains("http://") {
-        return Ok(ngit_relay_url.replace("http://", "ws://"));
+fn format_grasp_server_url_as_relay_url(url: &str) -> Result<String> {
+    let grasp_server_url = normalize_grasp_server_url(url)?;
+    if grasp_server_url.contains("http://") {
+        return Ok(grasp_server_url.replace("http://", "ws://"));
     }
-    Ok(format!("wss://{ngit_relay_url}"))
+    Ok(format!("wss://{grasp_server_url}"))
 }
 
-fn format_ngit_relay_url_as_blossom_url(url: &str) -> Result<String> {
-    let ngit_relay_url = normalize_ngit_relay_url(url)?;
-    if ngit_relay_url.contains("http://") {
-        return Ok(ngit_relay_url);
+fn format_grasp_server_url_as_blossom_url(url: &str) -> Result<String> {
+    let grasp_server_url = normalize_grasp_server_url(url)?;
+    if grasp_server_url.contains("http://") {
+        return Ok(grasp_server_url);
     }
-    Ok(format!("https://{ngit_relay_url}"))
+    Ok(format!("https://{grasp_server_url}"))
 }
 
 fn parse_relay_url(s: &str) -> Result<RelayUrl> {
diff --git a/src/lib/repo_ref.rs b/src/lib/repo_ref.rs
index 78968b4..c1fc288 100644
--- a/src/lib/repo_ref.rs
+++ b/src/lib/repo_ref.rs
@@ -308,8 +308,8 @@ impl RepoRef {
         }
     }
 
-    pub fn ngit_relays(&self) -> Vec<String> {
-        detect_existing_ngit_relays(Some(self), &[], &[], &[], &self.identifier)
+    pub fn grasp_servers(&self) -> Vec<String> {
+        detect_existing_grasp_servers(Some(self), &[], &[], &[], &self.identifier)
     }
 }
 
@@ -586,7 +586,7 @@ pub fn save_repo_config_to_yaml(
     .context("failed to write maintainers to maintainers.yaml file serde_yaml")
 }
 
-pub fn detect_existing_ngit_relays(
+pub fn detect_existing_grasp_servers(
     repo_ref: Option<&RepoRef>,
     args_relays: &[String],
     args_clone_url: &[String],
@@ -626,45 +626,46 @@ pub fn detect_existing_ngit_relays(
         Vec::new()
     };
 
-    let mut existing_ngit_relays = Vec::new();
+    let mut existing_grasp_servers = Vec::new();
     for url in &clone_urls {
-        let Ok(formatted_as_ngit_relay_url) = normalize_ngit_relay_url(url) else {
+        let Ok(formatted_as_grasp_server_url) = normalize_grasp_server_url(url) else {
             continue;
         };
-        if existing_ngit_relays.contains(&formatted_as_ngit_relay_url) {
+        if existing_grasp_servers.contains(&formatted_as_grasp_server_url) {
             continue;
         }
 
-        let clone_url_is_ngit_relay_format = if let Ok(npub) = extract_npub(url) {
+        let clone_url_is_grasp_server_format = if let Ok(npub) = extract_npub(url) {
             url.contains(&format!("/{npub}/{identifier}.git"))
         } else {
             false
         };
-        if !clone_url_is_ngit_relay_format {
+        if !clone_url_is_grasp_server_format {
             continue;
         }
 
         let matches_relay = relays.iter().any(|r| {
-            normalize_ngit_relay_url(&r.to_string())
-                .is_ok_and(|r| r.eq(&formatted_as_ngit_relay_url))
+            normalize_grasp_server_url(&r.to_string())
+                .is_ok_and(|r| r.eq(&formatted_as_grasp_server_url))
         });
         if !matches_relay {
             continue;
         }
 
         let matches_blossoms = blossoms.iter().any(|r| {
-            normalize_ngit_relay_url(r.as_str()).is_ok_and(|r| r.eq(&formatted_as_ngit_relay_url))
+            normalize_grasp_server_url(r.as_str())
+                .is_ok_and(|r| r.eq(&formatted_as_grasp_server_url))
         });
         if !matches_blossoms {
             continue;
         }
 
-        existing_ngit_relays.push(formatted_as_ngit_relay_url);
+        existing_grasp_servers.push(formatted_as_grasp_server_url);
     }
-    existing_ngit_relays
+    existing_grasp_servers
 }
 
-pub fn normalize_ngit_relay_url(url: &str) -> Result<String> {
+pub fn normalize_grasp_server_url(url: &str) -> Result<String> {
     // Parse the URL and handle errors
     let mut parsed = Url::parse(url)
         .or_else(|_| Url::parse(&format!("https://{url}")))
@@ -716,10 +717,10 @@ pub fn extract_npub(s: &str) -> Result<&str> {
     }
 }
 
-pub fn is_ngit_relay(url: &str, ngit_relays: &[String]) -> bool {
-    if !ngit_relays.is_empty() {
-        if let Ok(n) = normalize_ngit_relay_url(url) {
-            return ngit_relays.contains(&n);
+pub fn is_grasp_server(url: &str, grasp_servers: &[String]) -> bool {
+    if !grasp_servers.is_empty() {
+        if let Ok(n) = normalize_grasp_server_url(url) {
+            return grasp_servers.contains(&n);
         }
     }
     false
@@ -1005,7 +1006,7 @@ mod tests {
     }
 
     #[test]
-    fn normalize_ngit_relay_url_all_checks() -> Result<()> {
+    fn normalize_grasp_server_url_all_checks() -> Result<()> {
         let test_cases = vec![
             ("https://sub.domain.org", "sub.domain.org"),
             ("wss://sub.domain.org", "sub.domain.org"),
@@ -1035,7 +1036,7 @@ mod tests {
         ];
 
         for (input, expected) in test_cases {
-            let normalized = normalize_ngit_relay_url(input)?;
+            let normalized = normalize_grasp_server_url(input)?;
             assert_eq!(normalized, expected);
         }
         Ok(())