5 files changed, 267 insertions, 35 deletions

diff --git a/src/lib/cli_interactor.rs b/src/lib/cli_interactor.rs
index 8fca81d..8bcda19 100644
--- a/src/lib/cli_interactor.rs
+++ b/src/lib/cli_interactor.rs
@@ -236,6 +236,93 @@ impl PromptMultiChoiceParms {
     }
 }
 
+pub fn multi_select_with_custom_value<F>(
+    prompt: &str,
+    custom_choice_prompt: &str,
+    mut choices: Vec<String>,
+    mut defaults: Vec<bool>,
+    validate_choice: F,
+) -> Result<Vec<String>>
+where
+    F: Fn(&str) -> Result<String>,
+{
+    let mut selected_choices = vec![];
+
+    // Loop to allow users to add more choices
+    loop {
+        // Add 'add another' option at the end of the choices
+        let mut current_choices = choices.clone();
+        current_choices.push(if current_choices.is_empty() {
+            "add".to_string()
+        } else {
+            "add another".to_string()
+        });
+
+        // Create default selections based on the provided defaults
+        let mut current_defaults = defaults.clone();
+        current_defaults.push(current_choices.len() == 1); // 'add another' should not be selected by default
+
+        // Prompt for selections
+        let selected_indices: Vec<usize> = Interactor::default().multi_choice(
+            PromptMultiChoiceParms::default()
+                .with_prompt(prompt)
+                .dont_report()
+                .with_choices(current_choices.clone())
+                .with_defaults(current_defaults),
+        )?;
+
+        // Collect selected choices
+        selected_choices.clear(); // Clear previous selections to update
+        for &index in &selected_indices {
+            if index < choices.len() {
+                // Exclude 'add another' option
+                selected_choices.push(choices[index].clone());
+            }
+        }
+
+        // Check if 'add another' was selected
+        if selected_indices.contains(&(choices.len())) {
+            // Last index is 'add another'
+            let mut new_choice: String;
+            loop {
+                new_choice = Interactor::default().input(
+                    PromptInputParms::default()
+                        .with_prompt(custom_choice_prompt)
+                        .dont_report()
+                        .optional(),
+                )?;
+
+                if new_choice.is_empty() {
+                    break;
+                }
+                // Validate the new choice
+                match validate_choice(&new_choice) {
+                    Ok(valid_choice) => {
+                        new_choice = valid_choice; // Use the fixed version of the input
+                        break; // Valid choice, exit the loop
+                    }
+                    Err(err) => {
+                        // Inform the user about the validation error
+                        println!("Error: {err}");
+                    }
+                }
+            }
+
+            // Add the new choice to the choices vector
+            if !new_choice.is_empty() {
+                choices.push(new_choice.clone()); // Add new choice to the end of the list
+                selected_choices.push(new_choice); // Automatically select the new choice
+                defaults.push(true); // Set the new choice as selected by default
+            }
+        } else {
+            // Exit the loop if 'add another' was not selected
+            break;
+        }
+    }
+
+    Ok(selected_choices)
+}
+
 #[derive(Debug, Default)]
 pub struct Printer {
     printed_lines: Vec<String>,
diff --git a/src/lib/client.rs b/src/lib/client.rs
index b27f9b1..9ce3e24 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -53,7 +53,7 @@ use crate::{
     get_dirs,
     git::{Repo, RepoActions, get_git_config_item},
     git_events::{
-        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_is_cover_letter,
+        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, KIND_USER_GRASP_LIST, event_is_cover_letter,
         event_is_patch_set_root, event_is_revision_root, event_is_valid_pr_or_pr_update,
         status_kinds,
     },
@@ -233,7 +233,7 @@ impl Connect for Client {
         if let Some(git_repo_path) = git_repo_path {
             save_event_in_local_cache(git_repo_path, &event).await?;
         }
-        if event.kind.eq(&Kind::GitRepoAnnouncement) {
+        if [Kind::GitRepoAnnouncement, KIND_USER_GRASP_LIST].contains(&event.kind) {
             save_event_in_global_cache(git_repo_path, &event).await?;
         }
         Ok(event.id)
@@ -1310,17 +1310,21 @@ async fn create_relays_request(
                 user_profiles.insert(current_user);
             }
         }
-        let mut map: HashMap<PublicKey, (Timestamp, Timestamp)> = HashMap::new();
+        let mut map: HashMap<PublicKey, (Timestamp, Timestamp, Timestamp)> = HashMap::new();
         for public_key in &user_profiles {
             if let Ok(user_ref) = get_user_ref_from_cache(git_repo_path, public_key).await {
                 map.insert(
                     public_key.to_owned(),
-                    (user_ref.metadata.created_at, user_ref.relays.created_at),
+                    (
+                        user_ref.metadata.created_at,
+                        user_ref.relays.created_at,
+                        user_ref.grasp_list.created_at,
+                    ),
                 );
             } else {
                 map.insert(
                     public_key.to_owned(),
-                    (Timestamp::from(0), Timestamp::from(0)),
+                    (Timestamp::from(0), Timestamp::from(0), Timestamp::from(0)),
                 );
             }
         }
@@ -1547,16 +1551,22 @@ async fn process_fetched_events(
                 {
                     fresh_profiles.insert(event.pubkey);
                 }
-            } else if [Kind::RelayList, Kind::Metadata].contains(&event.kind) {
+            } else if [Kind::RelayList, Kind::Metadata, KIND_USER_GRASP_LIST].contains(&event.kind)
+            {
                 if request.missing_contributor_profiles.contains(&event.pubkey) {
                     report.contributor_profiles.insert(event.pubkey);
-                } else if let Some((_, (metadata_timestamp, relay_list_timestamp))) = request
+                } else if let Some((
+                    _,
+                    (metadata_timestamp, relay_list_timestamp, grasp_list_timestamp),
+                )) = request
                     .profiles_to_fetch_from_user_relays
                     .get_key_value(&event.pubkey)
                 {
                     if (Kind::Metadata.eq(&event.kind) && event.created_at.gt(metadata_timestamp))
                         || (Kind::RelayList.eq(&event.kind)
                             && event.created_at.gt(relay_list_timestamp))
+                        || (KIND_USER_GRASP_LIST.eq(&event.kind)
+                            && event.created_at.gt(grasp_list_timestamp))
                     {
                         report.profile_updates.insert(event.pubkey);
                     }
@@ -1718,35 +1728,21 @@ pub fn get_filter_repo_events(repo_coordinates: &HashSet<Nip19Coordinate>) -> no
                 .map(|c| c.identifier.clone())
                 .collect::<Vec<String>>(),
         )
-        .authors(
-            repo_coordinates
-                .iter()
-                .map(|c| c.public_key)
-                .collect::<Vec<PublicKey>>(),
-        )
 }
 
 pub static STATE_KIND: nostr::Kind = Kind::Custom(30618);
 pub fn get_filter_state_events(repo_coordinates: &HashSet<Nip19Coordinate>) -> nostr::Filter {
-    nostr::Filter::default()
-        .kind(STATE_KIND)
-        .identifiers(
-            repo_coordinates
-                .iter()
-                .map(|c| c.identifier.clone())
-                .collect::<Vec<String>>(),
-        )
-        .authors(
-            repo_coordinates
-                .iter()
-                .map(|c| c.public_key)
-                .collect::<Vec<PublicKey>>(),
-        )
+    nostr::Filter::default().kind(STATE_KIND).identifiers(
+        repo_coordinates
+            .iter()
+            .map(|c| c.identifier.clone())
+            .collect::<Vec<String>>(),
+    )
 }
 
 pub fn get_filter_contributor_profiles(contributors: HashSet<PublicKey>) -> nostr::Filter {
     nostr::Filter::default()
-        .kinds(vec![Kind::Metadata, Kind::RelayList])
+        .kinds(vec![Kind::Metadata, Kind::RelayList, KIND_USER_GRASP_LIST])
         .authors(contributors)
 }
 
@@ -1850,7 +1846,7 @@ pub struct FetchRequest {
     contributors: HashSet<PublicKey>,
     missing_contributor_profiles: HashSet<PublicKey>,
     existing_events: HashSet<EventId>,
-    profiles_to_fetch_from_user_relays: HashMap<PublicKey, (Timestamp, Timestamp)>,
+    profiles_to_fetch_from_user_relays: HashMap<PublicKey, (Timestamp, Timestamp, Timestamp)>,
     user_relays_for_profiles: HashSet<RelayUrl>,
 }
 
diff --git a/src/lib/git_events.rs b/src/lib/git_events.rs
index bbfcbea..76c31de 100644
--- a/src/lib/git_events.rs
+++ b/src/lib/git_events.rs
@@ -63,6 +63,7 @@ pub fn status_kinds() -> Vec<Kind> {
 
 pub const KIND_PULL_REQUEST: Kind = Kind::Custom(1618);
 pub const KIND_PULL_REQUEST_UPDATE: Kind = Kind::Custom(1619);
+pub const KIND_USER_GRASP_LIST: Kind = Kind::Custom(10317);
 
 pub fn event_is_patch_set_root(event: &Event) -> bool {
     event.kind.eq(&Kind::GitPatch)
diff --git a/src/lib/login/user.rs b/src/lib/login/user.rs
index 071cb25..0b702ef 100644
--- a/src/lib/login/user.rs
+++ b/src/lib/login/user.rs
@@ -1,7 +1,7 @@
-use std::{collections::HashSet, path::Path};
+use std::{collections::HashSet, path::Path, sync::Arc};
 
 use anyhow::{Context, Result, bail};
-use nostr::PublicKey;
+use nostr::{PublicKey, Url, event::Tag, signer::NostrSigner};
 use nostr_sdk::{Alphabet, JsonUtil, Kind, SingleLetterTag, Timestamp, ToBech32};
 use serde::{self, Deserialize, Serialize};
 
@@ -9,13 +9,17 @@ use serde::{self, Deserialize, Serialize};
 use crate::client::Client;
 #[cfg(test)]
 use crate::client::MockConnect;
-use crate::client::{Connect, get_event_from_global_cache};
+use crate::{
+    client::{Connect, get_event_from_global_cache, sign_event},
+    git_events::KIND_USER_GRASP_LIST,
+};
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRef {
     pub public_key: PublicKey,
     pub metadata: UserMetadata,
     pub relays: UserRelays,
+    pub grasp_list: UserGraspList,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -49,6 +53,35 @@ impl UserRelays {
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct UserGraspList {
+    pub urls: Vec<Url>,
+    pub created_at: Timestamp,
+}
+
+impl UserGraspList {
+    pub async fn to_event(&mut self, signer: &Arc<dyn NostrSigner>) -> Result<nostr::Event> {
+        let event = sign_event(
+            nostr_sdk::EventBuilder::new(KIND_USER_GRASP_LIST, "").tags(
+                self.urls
+                    .iter()
+                    .map(|url| {
+                        Tag::custom(
+                            nostr::TagKind::Custom(std::borrow::Cow::Borrowed("g")),
+                            vec![url.to_string()],
+                        )
+                    })
+                    .collect::<Vec<_>>(),
+            ),
+            signer,
+            "user grasp list".to_string(),
+        )
+        .await?;
+        self.created_at = event.created_at;
+        Ok(event)
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct UserRelayRef {
     pub url: String,
     pub read: bool,
@@ -84,6 +117,7 @@ pub async fn get_user_details(
             public_key: public_key.to_owned(),
             metadata: extract_user_metadata(public_key, &[])?,
             relays: extract_user_relays(public_key, &[]),
+            grasp_list: extract_user_grasp_list(public_key, &[]),
         };
         if cache_only {
             Ok(empty)
@@ -117,6 +151,9 @@ pub async fn get_user_ref_from_cache(
         nostr::Filter::default()
             .author(*public_key)
             .kind(Kind::RelayList),
+        nostr::Filter::default()
+            .author(*public_key)
+            .kind(KIND_USER_GRASP_LIST),
     ];
 
     let events = get_event_from_global_cache(git_repo_path, filters.clone()).await?;
@@ -128,6 +165,7 @@ pub async fn get_user_ref_from_cache(
         public_key: public_key.to_owned(),
         metadata: extract_user_metadata(public_key, &events)?,
         relays: extract_user_relays(public_key, &events),
+        grasp_list: extract_user_grasp_list(public_key, &events),
     })
 }
 
@@ -215,3 +253,36 @@ pub fn extract_user_relays(public_key: &nostr::PublicKey, events: &[nostr::Event
         },
     }
 }
+
+pub fn extract_user_grasp_list(
+    public_key: &nostr::PublicKey,
+    events: &[nostr::Event],
+) -> UserGraspList {
+    let event = events
+        .iter()
+        .filter(|e| e.kind.eq(&KIND_USER_GRASP_LIST) && e.pubkey.eq(public_key))
+        .max_by_key(|e| e.created_at);
+
+    UserGraspList {
+        urls: if let Some(event) = event {
+            event
+                .tags
+                .iter()
+                .filter_map(|t| {
+                    if t.as_slice().len() > 1 && t.as_slice()[0] == "g" {
+                        Url::parse(&t.as_slice()[1]).ok()
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        } else {
+            vec![]
+        },
+        created_at: if let Some(event) = event {
+            event.created_at
+        } else {
+            Timestamp::from(0)
+        },
+    }
+}
diff --git a/src/lib/repo_ref.rs b/src/lib/repo_ref.rs
index a3e1317..e3f71a1 100644
--- a/src/lib/repo_ref.rs
+++ b/src/lib/repo_ref.rs
@@ -40,6 +40,7 @@ pub struct RepoRef {
     pub web: Vec<String>,
     pub relays: Vec<RelayUrl>,
     pub blossoms: Vec<Url>,
+    pub hashtags: Vec<String>,
     pub maintainers: Vec<PublicKey>,
     pub trusted_maintainer: PublicKey,
     // set to None if not known
@@ -71,6 +72,7 @@ impl TryFrom<(nostr::Event, Option<PublicKey>)> for RepoRef {
             web: Vec::new(),
             relays: Vec::new(),
             blossoms: Vec::new(),
+            hashtags: Vec::new(),
             maintainers: Vec::new(),
             trusted_maintainer: trusted_maintainer.unwrap_or(event.pubkey),
             maintainers_without_annoucnement: None,
@@ -118,6 +120,7 @@ impl TryFrom<(nostr::Event, Option<PublicKey>)> for RepoRef {
                         }
                     }
                 }
+                [t, hashtag, ..] if t == "t" => r.hashtags.push(hashtag.clone()),
                 [t, blossoms @ ..] if t == "blossoms" => {
                     for b in blossoms {
                         if let Ok(b) = Url::parse(b) {
@@ -217,6 +220,15 @@ impl RepoRef {
                             vec![format!("git repository: {}", self.name.clone())],
                         ),
                     ],
+                    self.hashtags
+                        .iter()
+                        .map(|h| {
+                            Tag::custom(
+                                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("t")),
+                                vec![h.clone()],
+                            )
+                        })
+                        .collect(),
                     if self.blossoms.is_empty() {
                         vec![]
                     } else {
@@ -311,6 +323,34 @@ impl RepoRef {
     pub fn grasp_servers(&self) -> Vec<String> {
         detect_existing_grasp_servers(Some(self), &[], &[], &self.identifier)
     }
+
+    // returns false if already present so didn't need adding
+    pub fn add_grasp_server(&mut self, clone_url: &str) -> Result<bool> {
+        if !clone_url.starts_with("http") {
+            bail!("invalid grasp server clone url");
+        }
+        extract_npub(clone_url)
+            .context("invalid grasp server clone url. does not contain valid npub")?;
+        if !(clone_url.ends_with(".git") || clone_url.ends_with(".git/")) {
+            bail!("invalid grasp server clone url. does not end with .git");
+        }
+
+        let relay_url = RelayUrl::parse(
+            &format_grasp_server_url_as_relay_url(clone_url)
+                .context("invalid grasp server clone url")?,
+        )
+        .context("invalid grasp server clone url")?;
+
+        if !self.relays.contains(&relay_url) {
+            self.relays.push(relay_url);
+        }
+        if !self.git_server.contains(&clone_url.to_string()) {
+            self.git_server.push(clone_url.to_string());
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
 }
 
 pub async fn get_repo_coordinates_when_remote_unknown(
@@ -699,13 +739,49 @@ pub fn extract_npub(s: &str) -> Result<&str> {
     }
 }
 
+// this should be called is_grasp_server_in_list
 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);
+        if let Ok(url) = normalize_grasp_server_url(url) {
+            grasp_servers.iter().any(|s| {
+                if let Ok(s) = normalize_grasp_server_url(s) {
+                    s == url
+                } else {
+                    false
+                }
+            })
+        } else {
+            false
         }
+    } else {
+        false
+    }
+}
+
+pub 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://"));
     }
-    false
+    Ok(format!("wss://{grasp_server_url}"))
+}
+
+pub fn format_grasp_server_url_as_clone_url(
+    grasp_server: &str,
+    public_key: &PublicKey,
+    identifier: &str,
+) -> Result<String> {
+    let grasp_server_url = normalize_grasp_server_url(grasp_server)?;
+
+    let prefix = if grasp_server_url.contains("http://") {
+        ""
+    } else {
+        "https://"
+    };
+    Ok(format!(
+        "{prefix}{grasp_server_url}/{}/{identifier}.git",
+        public_key.to_bech32()?
+    ))
 }
 
 #[cfg(test)]
@@ -730,6 +806,7 @@ mod tests {
                 RelayUrl::parse("ws://relay2.io").unwrap(),
             ],
             blossoms: vec![],
+            hashtags: vec![],
             trusted_maintainer: TEST_KEY_1_KEYS.public_key(),
             maintainers_without_annoucnement: None,
             maintainers: vec![TEST_KEY_1_KEYS.public_key(), TEST_KEY_2_KEYS.public_key()],