2 files changed, 582 insertions, 52 deletions

diff --git a/src/sub_commands/list.rs b/src/sub_commands/list.rs
index b8c2919..9d02eb1 100644
--- a/src/sub_commands/list.rs
+++ b/src/sub_commands/list.rs
@@ -1,3 +1,5 @@
+use std::{io::Write, ops::Add};
+
 use anyhow::{bail, Context, Result};
 
 use super::send::event_is_patch_set_root;
@@ -8,9 +10,12 @@ use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptChoiceParms, PromptConfirmParms},
     client::Connect,
-    git::{Repo, RepoActions},
+    git::{str_to_sha1, Repo, RepoActions},
     repo_ref::{self, RepoRef, REPO_REF_KIND},
-    sub_commands::send::{event_is_cover_letter, event_to_cover_letter, PATCH_KIND},
+    sub_commands::send::{
+        commit_msg_from_patch_oneliner, event_is_cover_letter, event_to_cover_letter,
+        patch_supports_commit_ids, PATCH_KIND,
+    },
     Cli,
 };
 
@@ -56,64 +61,582 @@ pub async fn launch(_cli_args: &Cli, _args: &SubCommandArgs) -> Result<()> {
         return Ok(());
     }
 
-    let selected_index = Interactor::default().choice(
-        PromptChoiceParms::default()
-            .with_prompt("all proposals")
-            .with_choices(
-                proposal_events
-                    .iter()
-                    .map(|e| {
-                        if let Ok(cl) = event_to_cover_letter(e) {
-                            cl.title
-                        } else if let Ok(msg) = tag_value(e, "description") {
-                            msg.split('\n').collect::<Vec<&str>>()[0].to_string()
-                        } else {
-                            e.id.to_string()
-                        }
-                    })
-                    .collect(),
-            ),
-    )?;
-
-    println!("finding commits...");
-
-    let commits_events: Vec<nostr::Event> =
-        find_commits_for_proposal_root_event(&client, &proposal_events[selected_index], &repo_ref)
-            .await?;
-
-    confirm_checkout(&git_repo)?;
-
-    let most_recent_proposal_patch_chain = get_most_recent_patch_with_ancestors(commits_events)
-        .context("cannot get most recent patch for proposal")?;
-
-    let branch_name: String = event_to_cover_letter(&proposal_events[selected_index])
-        .context("cannot assign a branch name as event is not a patch set root")?
-        .branch_name;
-
-    let applied = git_repo
-        .apply_patch_chain(&branch_name, most_recent_proposal_patch_chain)
-        .context("cannot apply patch chain")?;
-
-    if applied.is_empty() {
-        println!("checked out proposal branch. no new commits to pull");
-    } else {
+    loop {
+        let selected_index = Interactor::default().choice(
+            PromptChoiceParms::default()
+                .with_prompt("all proposals")
+                .with_choices(
+                    proposal_events
+                        .iter()
+                        .map(|e| {
+                            if let Ok(cl) = event_to_cover_letter(e) {
+                                cl.title
+                            } else if let Ok(msg) = tag_value(e, "description") {
+                                msg.split('\n').collect::<Vec<&str>>()[0].to_string()
+                            } else {
+                                e.id.to_string()
+                            }
+                        })
+                        .collect(),
+                ),
+        )?;
+
+        let cover_letter = event_to_cover_letter(&proposal_events[selected_index])
+            .context("cannot extract proposal details from proposal root event")?;
+
+        println!("finding commits...");
+
+        let commits_events: Vec<nostr::Event> = find_commits_for_proposal_root_event(
+            &client,
+            &proposal_events[selected_index],
+            &repo_ref,
+        )
+        .await?;
+
+        let Ok(most_recent_proposal_patch_chain) =
+            get_most_recent_patch_with_ancestors(commits_events.clone())
+        else {
+            if Interactor::default().confirm(
+                PromptConfirmParms::default()
+                    .with_default(true)
+                    .with_prompt(
+                        "cannot find any patches on this proposal. choose another proposal?",
+                    ),
+            )? {
+                continue;
+            }
+            return Ok(());
+        };
+
+        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) {
+            binding_patch_text_ref.as_str()
+        } else {
+            "1 commit"
+        };
+
+        let no_support_for_patches_as_branch = most_recent_proposal_patch_chain
+            .iter()
+            .any(|event| !patch_supports_commit_ids(event));
+
+        if no_support_for_patches_as_branch {
+            println!("{patch_text_ref}");
+            return match Interactor::default().choice(PromptChoiceParms::default().with_choices(
+                vec![
+                    "learn why 'patch only' 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"
+                    );
+                    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"
+                    );
+                    println!(
+                        "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"
+                    );
+                    Interactor::default().choice(
+                        PromptChoiceParms::default().with_choices(vec!["back".to_string()]),
+                    )?;
+                    continue;
+                }
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                3 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
+
+        let branch_exists = git_repo
+            .get_local_branch_names()
+            .context("gitlib2 will not show a list of local branch names")?
+            .iter()
+            .any(|n| n.eq(&cover_letter.branch_name));
+
+        let checked_out_proposal_branch = git_repo
+            .get_checked_out_branch_name()?
+            .eq(&cover_letter.branch_name);
+
+        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",
+            )?,
+            "parent-commit",
+        )?)
+        .context("cannot get valid parent commit id from patch")?;
+
+        let (main_branch_name, master_tip) = git_repo.get_main_or_master_branch()?;
+
+        if !git_repo.does_commit_exist(&proposal_base_commit.to_string())? {
+            println!("your '{main_branch_name}' branch may not be up-to-date.");
+            println!("the proposal parent commit doesnt exist in your local repository.");
+            return match Interactor::default().choice(PromptChoiceParms::default().with_choices(
+                vec![
+                    format!(
+                        "manually run `git pull` on '{main_branch_name}' and select proposal again"
+                    ),
+                    format!("apply to current branch with `git am`"),
+                    format!("download to ./patches"),
+                    "back".to_string(),
+                ],
+            ))? {
+                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),
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
+
+        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",
+            )?)
+            .context("cannot get valid commit_id from patch")?,
+        )
+        .context("cannot get valid commit_id from patch")?;
+
+        let (_, proposal_behind_main) =
+            git_repo.get_commits_ahead_behind(&master_tip, &proposal_base_commit)?;
+
+        // branch doesnt exist
+        if !branch_exists {
+            return match Interactor::default()
+                .choice(PromptChoiceParms::default().with_choices(vec![
+                format!(
+                    "create and checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
+                    most_recent_proposal_patch_chain.len(),
+                    proposal_behind_main.len(),
+                ),
+                format!("apply to current branch with `git am`"),
+                format!("download to ./patches"),
+                "back".to_string(),
+            ]))? {
+                0 => {
+                    check_clean(&git_repo)?;
+                    let _ = git_repo
+                        .apply_patch_chain(
+                            &cover_letter.branch_name,
+                            most_recent_proposal_patch_chain,
+                        )
+                        .context("cannot apply patch chain")?;
+
+                    println!(
+                        "checked out proposal as '{}' branch",
+                        cover_letter.branch_name
+                    );
+                    Ok(())
+                }
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                3 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
+
+        let local_branch_tip = git_repo.get_tip_of_local_branch(&cover_letter.branch_name)?;
+
+        // up-to-date
+        if proposal_tip.eq(&local_branch_tip) {
+            if checked_out_proposal_branch {
+                println!("branch checked out and up-to-date");
+                return match Interactor::default().choice(
+                    PromptChoiceParms::default()
+                        .with_choices(vec!["exit".to_string(), "back".to_string()]),
+                )? {
+                    0 => Ok(()),
+                    1 => continue,
+                    _ => {
+                        bail!("unexpected choice")
+                    }
+                };
+            }
+
+            return match Interactor::default().choice(PromptChoiceParms::default().with_choices(
+                vec![
+                    format!(
+                        "checkout proposal branch ({} ahead {} behind '{main_branch_name}')",
+                        most_recent_proposal_patch_chain.len(),
+                        proposal_behind_main.len(),
+                    ),
+                    format!("apply to current branch with `git am`"),
+                    format!("download to ./patches"),
+                    "back".to_string(),
+                ],
+            ))? {
+                0 => {
+                    check_clean(&git_repo)?;
+                    git_repo.checkout(&cover_letter.branch_name)?;
+                    println!(
+                        "checked out proposal as '{}' branch",
+                        cover_letter.branch_name
+                    );
+                    Ok(())
+                }
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                3 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
+
+        let (local_ahead_of_main, local_beind_main) =
+            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())
+        }) {
+            return match Interactor::default().choice(PromptChoiceParms::default().with_choices(
+                vec![
+                    format!("checkout proposal branch and apply {} appendments", &index,),
+                    format!("apply to current branch with `git am`"),
+                    format!("download to ./patches"),
+                    "back".to_string(),
+                ],
+            ))? {
+                0 => {
+                    check_clean(&git_repo)?;
+                    git_repo.checkout(&cover_letter.branch_name)?;
+                    let _ = git_repo
+                        .apply_patch_chain(
+                            &cover_letter.branch_name,
+                            most_recent_proposal_patch_chain,
+                        )
+                        .context("cannot apply patch chain")?;
+                    println!(
+                        "checked out proposal branch and applied {} appendments ({} ahead {} behind '{main_branch_name}')",
+                        &index,
+                        local_ahead_of_main.len().add(&index),
+                        local_beind_main.len(),
+                    );
+                    Ok(())
+                }
+                1 => launch_git_am_with_patches(most_recent_proposal_patch_chain),
+                2 => save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo),
+                3 => continue,
+                _ => {
+                    bail!("unexpected choice")
+                }
+            };
+        }
+
+        // tip of local in proposal history (new, ammended or rebased version but no
+        // local changes)
+        if commits_events.iter().any(|patch| {
+            get_commit_id_from_patch(patch)
+                .unwrap_or_default()
+                .eq(&local_branch_tip.to_string())
+        }) {
+            return match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_choices(
+                        vec![
+                            format!(
+                                "checkout new version of proposal branch ({} ahead {} behind '{main_branch_name}'), replacing old version ({} ahead {} behind '{main_branch_name}')",
+                                most_recent_proposal_patch_chain.len(),
+                                proposal_behind_main.len(),
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!(
+                                "checkout existing outdated proposal branch ({} ahead {} behind '{main_branch_name}')",
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!("apply to current branch with `git am`"),
+                            format!("download to ./patches"),
+                            "back".to_string(),
+                        ],
+                    )
+            )? {
+                    0 => {
+                        check_clean(&git_repo)?;
+                        git_repo.create_branch_at_commit(&cover_letter.branch_name, &proposal_base_commit.to_string())?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        let chain_length = most_recent_proposal_patch_chain.len();
+                        let _ = git_repo
+                            .apply_patch_chain(&cover_letter.branch_name, most_recent_proposal_patch_chain)
+                            .context("cannot apply patch chain")?;
+                        format!(
+                            "checked out new version of proposal ({} ahead {} behind '{main_branch_name}'), replacing old version ({} ahead {} behind '{main_branch_name}')",
+                            chain_length,
+                            proposal_behind_main.len(),
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    1 => {
+                        check_clean(&git_repo)?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        format!(
+                            "checked out old proposal in existing branch ({} ahead {} behind '{main_branch_name}')",
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    2 => {launch_git_am_with_patches(most_recent_proposal_patch_chain)},
+                    3 => {save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo)},
+                    4 => { continue },
+                    _ => { bail!("unexpected choice")}
+            };
+        }
+
+        // tip of proposal in branch in history (local appendments made)
+        if let Ok((local_ahead_of_proposal, _)) =
+            git_repo.get_commits_ahead_behind(&proposal_tip, &local_branch_tip)
+        {
+            println!(
+                "local proposal branch exists with {} unpublished commits on top of the most up-to-date version of the proposal",
+                local_ahead_of_proposal.len()
+            );
+            return match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_choices(
+                        vec![
+                            format!(
+                                "checkout proposal branch with {} unpublished commits ({} ahead {} behind '{main_branch_name}')",
+                                local_ahead_of_proposal.len(),
+                                local_ahead_of_main.len(),
+                                proposal_behind_main.len(),
+                            ),
+                            "back".to_string(),
+                        ],
+                    )
+            )? {
+                    0 => {
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        format!(
+                            "checked out proposal branch with {} unpublished commits ({} ahead {} behind '{main_branch_name}')",
+                            local_ahead_of_proposal.len(),
+                            local_ahead_of_main.len(),
+                            proposal_behind_main.len(),
+                        );
+                        Ok(())
+
+                     },
+                    1 => { continue },
+                    _ => { bail!("unexpected choice")}
+            };
+        }
+
+        // if tip of proposal commits exist (were once part of branch but have been
+        // ammended and git clean up job hasn't removed them)
+        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 other unpublished changes ({} ahead {} behind '{main_branch_name}')",
+                most_recent_proposal_patch_chain.len(),
+                proposal_behind_main.len(),
+                local_ahead_of_main.len(),
+                local_beind_main.len(),
+            );
+            return match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_choices(
+                        vec![
+                            format!(
+                                "checkout local branch with unpublished changes ({} ahead {} behind '{main_branch_name}')",
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!(
+                                "discard local branch with old version ({} ahead {} behind '{main_branch_name}') and checkout latest published version ({} ahead {} behind '{main_branch_name}')",
+                                most_recent_proposal_patch_chain.len(),
+                                proposal_behind_main.len(),
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!("apply to current branch with `git am`"),
+                            format!("download to ./patches"),
+                            "back".to_string(),
+                        ],
+                    )
+            )? {
+                    0 => {
+                        check_clean(&git_repo)?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        format!(
+                            "checked out old proposal in existing branch ({} ahead {} behind '{main_branch_name}')",
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    1 => {
+                        check_clean(&git_repo)?;
+                        git_repo.create_branch_at_commit(&cover_letter.branch_name, &proposal_base_commit.to_string())?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        let chain_length = most_recent_proposal_patch_chain.len();
+                        let _ = git_repo
+                            .apply_patch_chain(&cover_letter.branch_name, most_recent_proposal_patch_chain)
+                            .context("cannot apply patch chain")?;
+                        format!(
+                            "checked out new version of proposal ({} ahead {} behind '{main_branch_name}'), replacing old version ({} ahead {} behind '{main_branch_name}')",
+                            chain_length,
+                            proposal_behind_main.len(),
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    2 => {launch_git_am_with_patches(most_recent_proposal_patch_chain)},
+                    3 => {save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo)},
+                    4 => { continue },
+                    _ => { bail!("unexpected choice")}
+            };
+        }
+
         println!(
-            "checked out proposal branch. pulled {} new commits",
-            applied.len(),
+            "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(),
+            proposal_behind_main.len(),
         );
+
+        return match Interactor::default().choice(
+                PromptChoiceParms::default()
+                    .with_choices(
+                        vec![
+                            format!(
+                                "checkout local branch with unpublished changes ({} ahead {} behind '{main_branch_name}')",
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!(
+                                "discard local branch with unpublished version ({} ahead {} behind '{main_branch_name}') and checkout latest published version ({} ahead {} behind '{main_branch_name}'). consider creating a temporary branch with your existing unchanges first.",
+                                most_recent_proposal_patch_chain.len(),
+                                proposal_behind_main.len(),
+                                local_ahead_of_main.len(),
+                                local_beind_main.len(),
+                            ),
+                            format!("apply to current branch with `git am`"),
+                            format!("download to ./patches"),
+                            "back".to_string(),
+                        ],
+                    )
+            )? {
+                    0 => {
+                        check_clean(&git_repo)?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        format!(
+                            "checked out old proposal in existing branch ({} ahead {} behind '{main_branch_name}')",
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    1 => {
+                        check_clean(&git_repo)?;
+                        git_repo.create_branch_at_commit(&cover_letter.branch_name, &proposal_base_commit.to_string())?;
+                        git_repo.checkout(&cover_letter.branch_name)?;
+                        let chain_length = most_recent_proposal_patch_chain.len();
+                        let _ = git_repo
+                            .apply_patch_chain(&cover_letter.branch_name, most_recent_proposal_patch_chain)
+                            .context("cannot apply patch chain")?;
+                        format!(
+                            "checked out new version of proposal ({} ahead {} behind '{main_branch_name}'), replacing old version ({} ahead {} behind '{main_branch_name}'). consider creating a temporary branch with your existing unchanges first.",
+                            chain_length,
+                            proposal_behind_main.len(),
+                            local_ahead_of_main.len(),
+                            local_beind_main.len(),
+                        );
+                        Ok(())
+                    },
+                    2 => {launch_git_am_with_patches(most_recent_proposal_patch_chain)},
+                    3 => {save_patches_to_dir(most_recent_proposal_patch_chain, &git_repo)},
+                    4 => { continue },
+                    _ => { bail!("unexpected choice")}
+            };
     }
+}
+
+fn launch_git_am_with_patches(mut patches: Vec<nostr::Event>) -> Result<()> {
+    println!("applying to current branch with `git am`");
+    // TODO: add PATCH x/n to appended patches
+    patches.reverse();
+
+    let mut am = std::process::Command::new("git")
+        .arg("am")
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::inherit())
+        .spawn()
+        .context("failed to spawn git am")?;
+
+    let stdin = am
+        .stdin
+        .as_mut()
+        .context("git am process failed to take stdin")?;
+
+    for patch in patches {
+        stdin
+            .write(format!("{}\n\n", patch.content).as_bytes())
+            .context("failed to write patch content into git am stdin buffer")?;
+    }
+    stdin.flush()?;
+    let output = am
+        .wait_with_output()
+        .context("failed to read git am stdout")?;
+    print!("{:?}", output.stdout);
     Ok(())
 }
 
-fn confirm_checkout(git_repo: &Repo) -> Result<()> {
-    if !Interactor::default().confirm(
-        PromptConfirmParms::default()
-            .with_prompt("check out branch?")
-            .with_default(true),
-    )? {
-        bail!("Exiting...");
+fn event_id_extra_shorthand(event: &nostr::Event) -> String {
+    event.id.to_string()[..5].to_string()
+}
+
+fn save_patches_to_dir(mut patches: Vec<nostr::Event>, git_repo: &Repo) -> Result<()> {
+    // TODO: add PATCH x/n to appended patches
+    patches.reverse();
+    let path = git_repo.get_path()?.join("patches");
+    std::fs::create_dir_all(&path)?;
+    let id = event_id_extra_shorthand(
+        patches
+            .first()
+            .context("there must be at least one patch to save")?,
+    );
+    for (i, patch) in patches.iter().enumerate() {
+        let path = path.join(format!(
+            "{}-{:0>4}-{}.patch",
+            &id,
+            i.add(&1),
+            commit_msg_from_patch_oneliner(patch)?
+        ));
+        let mut file = std::fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(path)
+            .context("open new patch file with write and truncate options")?;
+        file.write_all(patch.content().as_bytes())?;
+        file.write_all("\n\n".as_bytes())?;
+        file.flush()?;
     }
+    println!("created {} patch files in ./patches/{id}-*", patches.len());
+    Ok(())
+}
 
+fn check_clean(git_repo: &Repo) -> Result<()> {
     if git_repo.has_outstanding_changes()? {
         bail!(
             "cannot pull proposal branch when repository is not clean. discard or stash (un)staged changes and try again."
diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index c3b3fda..004d263 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -532,6 +532,13 @@ pub fn event_is_patch_set_root(event: &nostr::Event) -> bool {
     event.kind.as_u64().eq(&PATCH_KIND) && event.iter_tags().any(|t| t.as_vec()[1].eq("root"))
 }
 
+pub fn patch_supports_commit_ids(event: &nostr::Event) -> bool {
+    event.kind.as_u64().eq(&PATCH_KIND)
+        && event
+            .iter_tags()
+            .any(|t| t.as_vec()[0].eq("commit-pgp-sig"))
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn generate_patch_event(
     git_repo: &Repo,