Merge branch 'add-PR-feature-to-remote'

2 files changed, 145 insertions, 82 deletions

diff --git a/src/bin/ngit/sub_commands/init.rs b/src/bin/ngit/sub_commands/init.rs
index 1242e45..eaaf83d 100644
--- a/src/bin/ngit/sub_commands/init.rs
+++ b/src/bin/ngit/sub_commands/init.rs
@@ -229,7 +229,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 .map(std::string::ToString::to_string)
                 .collect::<Vec<String>>()
         } else {
-            client.get_fallback_relays().clone()
+            client.get_relay_default_set().clone()
         }
     } else {
         args.relays.clone()
@@ -252,14 +252,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         args.blossoms.clone()
     };
 
-    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_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 fallback_grasp_servers = client.get_grasp_default_set();
 
     let selected_grasp_servers = if has_server_and_relay_flags {
         // ignore so a script running `ngit init` can contiue without prompts
@@ -269,14 +262,13 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             repo_ref.as_ref(),
             &args.relays,
             &args.clone_url,
-            &args.blossoms,
             &identifier,
         );
         let mut selections: Vec<bool> = vec![true; options.len()]; // Initialize selections based on existing options
         let empty = options.is_empty();
         for fallback in fallback_grasp_servers {
             // Check if any option contains the fallback as a substring
-            if !options.iter().any(|option| option.contains(&fallback)) {
+            if !options.iter().any(|option| option.contains(fallback)) {
                 options.push(fallback.clone()); // Add fallback if not found
                 selections.push(empty); // mark as selected if no existing ngit relay otherwise not
             }
@@ -464,7 +456,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             let mut selections: Vec<bool> = vec![true; options.len()];
 
             // add fallback relays as options
-            for relay in client.get_fallback_relays().clone() {
+            for relay in client.get_relay_default_set().clone() {
                 if !options.iter().any(|r| r.contains(&relay))
                     && !formatted_selected_grasp_servers
                         .iter()
diff --git a/src/bin/ngit/sub_commands/list.rs b/src/bin/ngit/sub_commands/list.rs
index 0330be1..0083c91 100644
--- a/src/bin/ngit/sub_commands/list.rs
+++ b/src/bin/ngit/sub_commands/list.rs
@@ -3,10 +3,12 @@ use std::{io::Write, ops::Add};
 use anyhow::{Context, Result, bail};
 use ngit::{
     client::{
-        Params, get_all_proposal_patch_events_from_cache, get_proposals_and_revisions_from_cache,
+        Params, get_all_proposal_patch_pr_pr_update_events_from_cache,
+        get_proposals_and_revisions_from_cache,
     },
     git_events::{
-        get_commit_id_from_patch, get_most_recent_patch_with_ancestors, status_kinds, tag_value,
+        KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, get_commit_id_from_patch,
+        get_pr_tip_event_or_most_recent_patch_with_ancestors, get_status, status_kinds, tag_value,
     },
 };
 use nostr_sdk::Kind;
@@ -70,26 +72,15 @@ pub async fn launch() -> Result<()> {
 
     let proposals: Vec<nostr::Event> = proposals_and_revisions
         .iter()
-        .filter(|e| !event_is_revision_root(e))
+        .filter(|e|
+            // If we wanted to treat to list Pull Requests that revise a Patch we would do this:
+            // e.kind.eq(&KIND_PULL_REQUEST) ||
+            !event_is_revision_root(e))
         .cloned()
         .collect();
 
     for proposal in &proposals {
-        let status = if let Some(e) = statuses
-            .iter()
-            .filter(|e| {
-                status_kinds().contains(&e.kind)
-                    && e.tags.iter().any(|t| {
-                        t.as_slice().len() > 1 && t.as_slice()[1].eq(&proposal.id.to_string())
-                    })
-            })
-            .collect::<Vec<&nostr::Event>>()
-            .first()
-        {
-            e.kind
-        } else {
-            Kind::GitStatusOpen
-        };
+        let status = get_status(proposal, &repo_ref, &statuses, &proposals);
         if status.eq(&Kind::GitStatusOpen) {
             open_proposals.push(proposal);
         } else if status.eq(&Kind::GitStatusClosed) {
@@ -184,21 +175,22 @@ pub async fn launch() -> Result<()> {
         let cover_letter = event_to_cover_letter(proposals_for_status[selected_index])
             .context("failed to extract proposal details from proposal root event")?;
 
-        let commits_events: Vec<nostr::Event> = get_all_proposal_patch_events_from_cache(
-            git_repo_path,
-            &repo_ref,
-            &proposals_for_status[selected_index].id,
-        )
-        .await?;
+        let commits_events: Vec<nostr::Event> =
+            get_all_proposal_patch_pr_pr_update_events_from_cache(
+                git_repo_path,
+                &repo_ref,
+                &proposals_for_status[selected_index].id,
+            )
+            .await?;
 
-        let Ok(most_recent_proposal_patch_chain) =
-            get_most_recent_patch_with_ancestors(commits_events.clone())
+        let Ok(most_recent_proposal_patch_chain_or_pr_or_pr_update) =
+            get_pr_tip_event_or_most_recent_patch_with_ancestors(commits_events.clone())
         else {
             if Interactor::default().confirm(
                 PromptConfirmParms::default()
                     .with_default(true)
                     .with_prompt(
-                        "failed to find any patches on this proposal. choose another proposal?",
+                        "failed to find any PR or patch events on this proposal. choose another proposal?",
                     ),
             )? {
                 continue;
@@ -208,15 +200,60 @@ pub async fn launch() -> Result<()> {
         // for commit in &most_recent_proposal_patch_chain {
         //     println!("recent_event: {:?}", commit.as_json());
         // }
+        if most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .iter()
+            .any(|e| [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&e.kind))
+        {
+            match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_prompt(
+                        "this is new PR event kind which isn't supported in `ngit list` yet",
+                    )
+                    .with_default(0)
+                    .with_choices(
+                        if [Kind::GitStatusOpen, Kind::GitStatusDraft].contains(&selected_status)
+                            && git_repo
+                                .get_first_nostr_remote_when_in_ngit_binary()
+                                .await
+                                .is_ok_and(|r| r.is_some())
+                        {
+                            vec![
+                                format!(
+                                    "I'll manually checkout the proposal at remote branch '{}'",
+                                    cover_letter
+                                        .get_branch_name_with_pr_prefix_and_shorthand_id()
+                                        .unwrap()
+                                ),
+                                // TODO fetch oids and follow similar logic for dealing with
+                                // conflcts as with patches below
+                                "back to proposals".to_string(),
+                            ]
+                        } else {
+                            vec!["back to proposals".to_string()]
+                        },
+                    ),
+            )? {
+                0 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
 
-        let binding_patch_text_ref = format!("{} commits", most_recent_proposal_patch_chain.len());
-        let patch_text_ref = if most_recent_proposal_patch_chain.len().gt(&1) {
+        let binding_patch_text_ref = format!(
+            "{} commits",
+            most_recent_proposal_patch_chain_or_pr_or_pr_update.len()
+        );
+        let patch_text_ref = if most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .len()
+            .gt(&1)
+        {
             binding_patch_text_ref.as_str()
         } else {
             "1 commit"
         };
 
-        let no_support_for_patches_as_branch = most_recent_proposal_patch_chain
+        let no_support_for_patches_as_branch = most_recent_proposal_patch_chain_or_pr_or_pr_update
             .iter()
             .any(|event| !patch_supports_commit_ids(event));
 
@@ -226,16 +263,18 @@ pub async fn launch() -> Result<()> {
                 PromptChoiceParms::default()
                     .with_default(0)
                     .with_choices(vec![
-                        "learn why 'patch only' proposals can't be checked out".to_string(),
+                        "learn why this proposals can't be checked out".to_string(),
                         format!("apply to current branch with `git am`"),
                         format!("download to ./patches"),
                         "back".to_string(),
                     ]),
             )? {
                 0 => {
-                    println!("Some proposals are posted as 'patch only'\n");
                     println!(
-                        "they are not anchored against a particular state of the code base like a standard proposal or a GitHub Pull Request can be\n"
+                        "Some proposals are posted as patch without listing a parent commit\n"
+                    );
+                    println!(
+                        "they are not anchored against a particular state of the code base like a standard patch or a pull request can be\n"
                     );
                     println!(
                         "they are designed to reviewed by studying the diff (in a tool like gitworkshop.dev) and if acceptable by a maintainer, applied to the latest version of master with any conflicts resolved as the do so\n"
@@ -244,7 +283,7 @@ pub async fn launch() -> Result<()> {
                         "this has proven to be a smoother workflow for large scale projects with a high frequency of changes, even when patches are exchanged via email\n"
                     );
                     println!(
-                        "by default ngit posts proposals that support both the branch and patch model so either workflow can be used"
+                        "by default ngit posts proposals with a parent commit so either workflow can be used"
                     );
                     Interactor::default().choice(
                         PromptChoiceParms::default()
@@ -253,8 +292,13 @@ pub async fn launch() -> Result<()> {
                     )?;
                     continue;
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -277,9 +321,11 @@ pub async fn launch() -> Result<()> {
             .eq(&cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?);
 
         let proposal_base_commit = str_to_sha1(&tag_value(
-            most_recent_proposal_patch_chain.last().context(
-                "there should be at least one patch as we have already checked for this",
-            )?,
+            most_recent_proposal_patch_chain_or_pr_or_pr_update
+                .last()
+                .context(
+                    "there should be at least one patch as we have already checked for this",
+                )?,
             "parent-commit",
         )?)
         .context("failed to get valid parent commit id from patch")?;
@@ -300,8 +346,8 @@ pub async fn launch() -> Result<()> {
                 ],
             ))? {
                 0 | 3 => continue,
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain_or_pr_or_pr_update, &git_repo),
                 _ => {
                     bail!("unexpected choice")
                 }
@@ -309,9 +355,13 @@ pub async fn launch() -> Result<()> {
         }
 
         let proposal_tip = str_to_sha1(
-            &get_commit_id_from_patch(most_recent_proposal_patch_chain.first().context(
-                "there should be at least one patch as we have already checked for this",
-            )?)
+            &get_commit_id_from_patch(
+                most_recent_proposal_patch_chain_or_pr_or_pr_update
+                    .first()
+                    .context(
+                        "there should be at least one patch as we have already checked for this",
+                    )?,
+            )
             .context("failed to get valid commit_id from patch")?,
         )
         .context("failed to get valid commit_id from patch")?;
@@ -325,7 +375,7 @@ pub async fn launch() -> Result<()> {
                 .choice(PromptChoiceParms::default().with_default(0).with_choices(vec![
                 format!(
                     "create and checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
-                    most_recent_proposal_patch_chain.len(),
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                     proposal_behind_main.len(),
                 ),
                 format!("apply to current branch with `git am`"),
@@ -337,7 +387,7 @@ pub async fn launch() -> Result<()> {
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
 
@@ -347,8 +397,8 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain_or_pr_or_pr_update, &git_repo),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -382,7 +432,7 @@ pub async fn launch() -> Result<()> {
                     .with_choices(vec![
                         format!(
                             "checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
-                            most_recent_proposal_patch_chain.len(),
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                             proposal_behind_main.len(),
                         ),
                         format!("apply to current branch with `git am`"),
@@ -401,8 +451,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -414,11 +469,14 @@ pub async fn launch() -> Result<()> {
             git_repo.get_commits_ahead_behind(&master_tip, &local_branch_tip)?;
 
         // new appendments to proposal
-        if let Some(index) = most_recent_proposal_patch_chain.iter().position(|patch| {
-            get_commit_id_from_patch(patch)
-                .unwrap_or_default()
-                .eq(&local_branch_tip.to_string())
-        }) {
+        if let Some(index) = most_recent_proposal_patch_chain_or_pr_or_pr_update
+            .iter()
+            .position(|patch| {
+                get_commit_id_from_patch(patch)
+                    .unwrap_or_default()
+                    .eq(&local_branch_tip.to_string())
+            })
+        {
             return match Interactor::default().choice(
                 PromptChoiceParms::default()
                     .with_default(0)
@@ -437,7 +495,7 @@ pub async fn launch() -> Result<()> {
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
                     println!(
@@ -448,8 +506,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                1 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                2 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 3 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -467,7 +530,7 @@ pub async fn launch() -> Result<()> {
         }) {
             println!(
                 "updated proposal available ({} ahead {} behind '{main_branch_name}'). existing version is {} ahead {} behind '{main_branch_name}'",
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
@@ -492,11 +555,11 @@ pub async fn launch() -> Result<()> {
                     git_repo.checkout(
                         &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
                     )?;
-                    let chain_length = most_recent_proposal_patch_chain.len();
+                    let chain_length = most_recent_proposal_patch_chain_or_pr_or_pr_update.len();
                     let _ = git_repo
                         .apply_patch_chain(
                             &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                            most_recent_proposal_patch_chain,
+                            most_recent_proposal_patch_chain_or_pr_or_pr_update,
                         )
                         .context("failed to apply patch chain")?;
                     println!(
@@ -520,8 +583,13 @@ pub async fn launch() -> Result<()> {
                     );
                     Ok(())
                 }
-                2 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-                3 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                2 => {
+                    launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update)
+                }
+                3 => save_patches_to_dir(
+                    most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                    &git_repo,
+                ),
                 4 => continue,
                 _ => {
                     bail!("unexpected choice")
@@ -581,7 +649,7 @@ pub async fn launch() -> Result<()> {
         if git_repo.does_commit_exist(&proposal_tip.to_string())? {
             println!(
                 "you have previously applied the latest version of the proposal ({} ahead {} behind '{main_branch_name}') but your local proposal branch has amended or rebased it ({} ahead {} behind '{main_branch_name}')",
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
@@ -594,7 +662,7 @@ pub async fn launch() -> Result<()> {
                 "your local proposal branch ({} ahead {} behind '{main_branch_name}') has conflicting changes with the latest published proposal ({} ahead {} behind '{main_branch_name}')",
                 local_ahead_of_main.len(),
                 local_beind_main.len(),
-                most_recent_proposal_patch_chain.len(),
+                most_recent_proposal_patch_chain_or_pr_or_pr_update.len(),
                 proposal_behind_main.len(),
             );
 
@@ -639,11 +707,11 @@ pub async fn launch() -> Result<()> {
                     &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
                     &proposal_base_commit.to_string(),
                 )?;
-                let chain_length = most_recent_proposal_patch_chain.len();
+                let chain_length = most_recent_proposal_patch_chain_or_pr_or_pr_update.len();
                 let _ = git_repo
                     .apply_patch_chain(
                         &cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?,
-                        most_recent_proposal_patch_chain,
+                        most_recent_proposal_patch_chain_or_pr_or_pr_update,
                     )
                     .context("failed to apply patch chain")?;
 
@@ -658,8 +726,11 @@ pub async fn launch() -> Result<()> {
                 );
                 Ok(())
             }
-            2 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
-            3 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+            2 => launch_git_am_with_patches(most_recent_proposal_patch_chain_or_pr_or_pr_update),
+            3 => save_patches_to_dir(
+                most_recent_proposal_patch_chain_or_pr_or_pr_update,
+                &git_repo,
+            ),
             4 => continue,
             _ => {
                 bail!("unexpected choice")