feat(prs-create)!: use nip34 patch kind and tags

- change kind number
- remove "r-" prefix from unique commit id r tag
- rename tag commit-sig to commit-pgp-sig
- a tag for repo identifer and pubkey. this serves as a vote for
  this pubkey being a maintainer
- add relay hints
- change format of committer tag
- remove r references to parent commit id
- tag parent patch event if its part of change request

author and commit-message tags still need to be removed but they are
required to apply patches with gitlib2. we will need to fallback to
running the git client to apply patches.

BREAKING CHANGE: change patch/commit event kind and tags to reflect
nip34 draft. events with the older kind will no longer be found and
will not be in a valid format

1 files changed, 99 insertions, 44 deletions

diff --git a/src/sub_commands/prs/create.rs b/src/sub_commands/prs/create.rs
index ad6a61a..0f7cbda 100644
--- a/src/sub_commands/prs/create.rs
+++ b/src/sub_commands/prs/create.rs
@@ -13,7 +13,9 @@ use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptConfirmParms, PromptInputParms},
     client::Connect,
     git::{Repo, RepoActions},
-    login, repo_ref, Cli,
+    login,
+    repo_ref::{self, RepoRef, REPO_REF_KIND},
+    Cli,
 };
 
 #[derive(Debug, clap::Args)]
@@ -96,9 +98,6 @@ pub async fn launch(
 
     client.set_keys(&keys).await;
 
-    let events =
-        generate_pr_and_patch_events(&title, &description, &to_branch, &git_repo, &ahead, &keys)?;
-
     let repo_ref = repo_ref::fetch(
         &git_repo,
         git_repo
@@ -110,6 +109,16 @@ pub async fn launch(
     )
     .await?;
 
+    let events = generate_pr_and_patch_events(
+        &title,
+        &description,
+        &to_branch,
+        &git_repo,
+        &ahead,
+        &keys,
+        &repo_ref,
+    )?;
+
     println!(
         "posting 1 pull request with {} commits...",
         events.len() - 1
@@ -299,7 +308,7 @@ mod tests_unique_and_duplicate {
 }
 
 pub static PR_KIND: u64 = 318;
-pub static PATCH_KIND: u64 = 317;
+pub static PATCH_KIND: u64 = 1617;
 
 pub fn generate_pr_and_patch_events(
     title: &str,
@@ -308,6 +317,7 @@ pub fn generate_pr_and_patch_events(
     git_repo: &Repo,
     commits: &Vec<Sha1Hash>,
     keys: &nostr::Keys,
+    repo_ref: &RepoRef,
 ) -> Result<Vec<nostr::Event>> {
     let root_commit = git_repo
         .get_root_commit(to_branch)
@@ -342,8 +352,16 @@ pub fn generate_pr_and_patch_events(
     let mut events = vec![pr_event];
     for commit in commits {
         events.push(
-            generate_patch_event(git_repo, &root_commit, commit, pr_event_id, keys)
-                .context("failed to generate patch event")?,
+            generate_patch_event(
+                git_repo,
+                &root_commit,
+                commit,
+                pr_event_id,
+                keys,
+                repo_ref,
+                events.last().map(nostr::Event::id),
+            )
+            .context("failed to generate patch event")?,
         );
     }
     Ok(events)
@@ -353,55 +371,92 @@ pub fn generate_patch_event(
     git_repo: &Repo,
     root_commit: &Sha1Hash,
     commit: &Sha1Hash,
-    pr_event_id: nostr::EventId,
+    thread_event_id: nostr::EventId,
     keys: &nostr::Keys,
+    repo_ref: &RepoRef,
+    parent_patch_event_id: Option<nostr::EventId>,
 ) -> Result<nostr::Event> {
     let commit_parent = git_repo
         .get_commit_parent(commit)
         .context("failed to get parent commit")?;
+    let relay_hint = repo_ref.relays.first().map(nostr::UncheckedUrl::from);
     EventBuilder::new(
         nostr::event::Kind::Custom(PATCH_KIND),
         git_repo
             .make_patch_from_commit(commit)
             .context(format!("cannot make patch for commit {commit}"))?,
         [
-            Tag::Reference(format!("r-{root_commit}")),
-            Tag::Reference(commit.to_string()),
-            Tag::Reference(commit_parent.to_string()),
-            Tag::Event {
-                event_id: pr_event_id,
-                relay_url: None, // TODO: add relay
-                marker: Some(Marker::Root),
+            vec![
+                Tag::A {
+                    kind: nostr::Kind::Custom(REPO_REF_KIND),
+                    public_key: *repo_ref.maintainers.first()
+                        .context("repo reference should always have at least one maintainer - the issuer of the repo event")
+                        ?,
+                    identifier: repo_ref.identifier.to_string(),
+                    relay_url: relay_hint.clone(),
+                },
+                Tag::Reference(format!("{root_commit}")),
+                // commit id reference is a trade-off. its now
+                // unclear which one is the root commit id but it
+                // enables easier location of code comments againt
+                // code that makes it into the main branch, assuming
+                // the commit id is correct
+                Tag::Reference(commit.to_string()),
+
+                Tag::Event {
+                    event_id: thread_event_id,
+                    relay_url: relay_hint.clone(),
+                    marker: Some(Marker::Root),
+                },
+            ],
+            if let Some(id) = parent_patch_event_id {
+                vec![Tag::Event {
+                    event_id: id,
+                    relay_url: relay_hint.clone(),
+                    marker: Some(Marker::Reply),
+                }]
+            } else {
+                vec![]
             },
-            Tag::Generic(
-                TagKind::Custom("commit".to_string()),
-                vec![commit.to_string()],
-            ),
-            Tag::Generic(
-                TagKind::Custom("parent-commit".to_string()),
-                vec![commit_parent.to_string()],
-            ),
-            Tag::Generic(
-                TagKind::Custom("commit-sig".to_string()),
-                vec![
-                    git_repo
-                        .extract_commit_pgp_signature(commit)
-                        .unwrap_or_default(),
-                ],
-            ),
-            Tag::Description(git_repo.get_commit_message(commit)?.to_string()),
-            Tag::Generic(
-                TagKind::Custom("author".to_string()),
-                git_repo.get_commit_author(commit)?,
-            ),
-            Tag::Generic(
-                TagKind::Custom("committer".to_string()),
-                git_repo.get_commit_comitter(commit)?,
-            ),
-            // TODO: add Repo event tags
-            // TODO: people tag maintainers
-            // TODO: add relay tags
-        ],
+            // whilst it is in nip34 draft to tag the maintainers
+            // I'm not sure it is a good idea because if they are
+            // interested in all patches then their specialised
+            // client should subscribe to patches tagged with the
+            // repo reference. maintainers of large repos will not
+            // be interested in every patch.
+            repo_ref.maintainers
+                    .iter()
+                    .map(|pk| Tag::public_key(*pk))
+                    .collect(),
+            vec![
+                Tag::Generic(
+                    TagKind::Custom("commit".to_string()),
+                    vec![commit.to_string()],
+                ),
+                Tag::Generic(
+                    TagKind::Custom("parent-commit".to_string()),
+                    vec![commit_parent.to_string()],
+                ),
+                Tag::Generic(
+                    TagKind::Custom("commit-pgp-sig".to_string()),
+                    vec![
+                        git_repo
+                            .extract_commit_pgp_signature(commit)
+                            .unwrap_or_default(),
+                    ],
+                ),
+                Tag::Description(git_repo.get_commit_message(commit)?.to_string()),
+                Tag::Generic(
+                    TagKind::Custom("author".to_string()),
+                    git_repo.get_commit_author(commit)?,
+                ),
+                Tag::Generic(
+                    TagKind::Custom("committer".to_string()),
+                    git_repo.get_commit_comitter(commit)?,
+                ),
+            ],
+        ]
+        .concat(),
     )
     .to_event(keys)
     .context("failed to sign event")