feat(pr): generate pr event > oversized patch

but only for new proposals

3 files changed, 247 insertions, 35 deletions

diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index 9ff8af0..b9e8571 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -12,12 +12,13 @@ use client::{get_events_from_local_cache, get_state_from_cache, send_events, sig
 use console::Term;
 use git::{RepoActions, sha1_to_oid};
 use git_events::{
-    generate_cover_letter_and_patch_events, generate_patch_event, get_commit_id_from_patch,
+    generate_cover_letter_and_patch_events, generate_patch_event, generate_unsigned_pr_event,
+    get_commit_id_from_patch,
 };
 use git2::{Oid, Repository};
 use ngit::{
     cli_interactor::count_lines_per_msg_vec,
-    client::{self, get_event_from_cache_by_id},
+    client::{self, get_event_from_cache_by_id, sign_draft_event},
     git::{
         self,
         nostr_url::{CloneUrl, NostrUrlDecoded},
@@ -25,10 +26,10 @@ 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_grasp_server},
+    repo_ref::{self, get_repo_config_from_yaml, is_grasp_server, normalize_grasp_server_url},
     repo_state,
 };
-use nostr::nips::nip10::Marker;
+use nostr::{event::UnsignedEvent, nips::nip10::Marker};
 use nostr_sdk::{
     Event, EventBuilder, EventId, Kind, NostrSigner, PublicKey, RelayUrl, Tag, TagStandard,
     hashes::sha1::Hash as Sha1Hash,
@@ -404,18 +405,11 @@ async fn process_proposal_refspecs(
             let (mut ahead, _) =
                 git_repo.get_commits_ahead_behind(&main_tip, &tip_of_pushed_branch)?;
             ahead.reverse();
-            for patch in generate_cover_letter_and_patch_events(
-                None,
-                git_repo,
-                &ahead,
-                signer,
-                repo_ref,
-                &None,
-                &[],
-            )
-            .await?
+            for event in
+                generate_patches_or_pr_event(git_repo, repo_ref, &ahead, user_ref, signer, term)
+                    .await?
             {
-                events.push(patch);
+                events.push(event);
             }
         }
     }
@@ -423,6 +417,108 @@ async fn process_proposal_refspecs(
     Ok((events, rejected_proposal_refspecs))
 }
 
+async fn generate_patches_or_pr_event(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    ahead: &[Sha1Hash],
+    user_ref: &UserRef,
+    signer: &Arc<dyn NostrSigner>,
+    term: &Term,
+) -> Result<Vec<Event>> {
+    let mut events: Vec<Event> = vec![];
+    let use_pr = ahead.iter().any(|commit| {
+        if let Ok(patch) = git_repo.make_patch_from_commit(commit, &None) {
+            patch.len()
+                > ((65 // max recomended patch event size specified in nip34 in kb
+                // allownace for nostr event wrapper (id, pubkey, tags, sig)
+                - 1) * 1024)
+        } else {
+            true
+        }
+    });
+
+    if use_pr {
+        let repo_grasps = repo_ref.grasp_servers();
+        let repo_grasp_clone_urls = repo_ref
+            .git_server
+            .iter()
+            .filter(|s| is_grasp_server(s, &repo_grasps));
+
+        let mut unsigned_pr_event: Option<UnsignedEvent> = None;
+        let mut failed_clone_urls = vec![];
+        for clone_url in repo_grasp_clone_urls {
+            let mut draft_pr_event = if let Some(ref unsigned_pr_event) = unsigned_pr_event {
+                unsigned_pr_event.clone()
+            } else {
+                generate_unsigned_pr_event(
+                    git_repo,
+                    repo_ref,
+                    &user_ref.public_key,
+                    ahead.first().context("no commits to push")?,
+                    &[clone_url],
+                    &[],
+                )?
+            };
+
+            let refspec = format!(
+                "{}:refs/nostr/{}",
+                ahead.first().unwrap(),
+                draft_pr_event.id()
+            );
+
+            if let Err(error) = push_to_remote_url(git_repo, clone_url, &[refspec], term) {
+                failed_clone_urls.push(clone_url);
+                term.write_line(
+                    format!(
+                        "push: error sending commit data to {}: {error}",
+                        normalize_grasp_server_url(clone_url)?
+                    )
+                    .as_str(),
+                )?;
+            } else {
+                term.write_line(
+                    format!(
+                        "push: commit data sent to {}",
+                        normalize_grasp_server_url(clone_url)?
+                    )
+                    .as_str(),
+                )?;
+                unsigned_pr_event = Some(draft_pr_event);
+            }
+        }
+        if unsigned_pr_event.is_none() {
+            // TODO get fallback grasp servers that aren't in repo_grasps cycle
+            // through until one succeeds TODO create personal-fork
+            // announcement with grasp servers and push, after a few seconds
+            // push ref/nostr/eventid. if one success break out of
+            // for loop and continue
+        }
+        if let Some(unsigned_pr_event) = unsigned_pr_event {
+            let pr_event =
+                sign_draft_event(unsigned_pr_event, signer, "Pull Request".to_string()).await?;
+            events.push(pr_event);
+        } else {
+            bail!("could not find a grasp server that accepts the Pull Request refs");
+        }
+    } else {
+        for patch in generate_cover_letter_and_patch_events(
+            None,
+            git_repo,
+            ahead,
+            signer,
+            repo_ref,
+            &None,
+            &[],
+        )
+        .await?
+        {
+            events.push(patch);
+        }
+    }
+
+    Ok(events)
+}
+
 fn push_to_remote(
     git_repo: &Repo,
     git_server_url: &str,
diff --git a/src/lib/client.rs b/src/lib/client.rs
index 091d68d..3fe2b57 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -31,7 +31,7 @@ use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressState, P
 use mockall::*;
 use nostr::{
     Event,
-    event::{TagKind, TagStandard},
+    event::{TagKind, TagStandard, UnsignedEvent},
     filter::Alphabet,
     nips::{nip01::Coordinate, nip19::Nip19Coordinate},
     signer::SignerBackend,
@@ -814,6 +814,30 @@ pub async fn sign_event(
     }
 }
 
+pub async fn sign_draft_event(
+    draft_event: UnsignedEvent,
+    signer: &Arc<dyn NostrSigner>,
+    description: String,
+) -> Result<nostr::Event> {
+    if signer.backend() == SignerBackend::NostrConnect {
+        let term = console::Term::stderr();
+        term.write_line(&format!(
+            "signing event ({description}) with remote signer..."
+        ))?;
+        let event = signer
+            .sign_event(draft_event)
+            .await
+            .context("failed to sign event")?;
+        term.clear_last_lines(1)?;
+        Ok(event)
+    } else {
+        signer
+            .sign_event(draft_event)
+            .await
+            .context("failed to sign event")
+    }
+}
+
 pub async fn fetch_public_key(signer: &Arc<dyn NostrSigner>) -> Result<nostr::PublicKey> {
     if signer.backend() == SignerBackend::NostrConnect {
         let term = console::Term::stderr();
diff --git a/src/lib/git_events.rs b/src/lib/git_events.rs
index 09ec040..86b9641 100644
--- a/src/lib/git_events.rs
+++ b/src/lib/git_events.rs
@@ -1,7 +1,10 @@
 use std::{str::FromStr, sync::Arc};
 
 use anyhow::{Context, Result, bail};
-use nostr::nips::{nip01::Coordinate, nip10::Marker, nip19::Nip19};
+use nostr::{
+    event::UnsignedEvent,
+    nips::{nip01::Coordinate, nip10::Marker, nip19::Nip19},
+};
 use nostr_sdk::{
     Event, EventBuilder, EventId, FromBech32, Kind, NostrSigner, PublicKey, Tag, TagKind,
     TagStandard, hashes::sha1::Hash as Sha1Hash,
@@ -347,6 +350,111 @@ pub fn event_tag_from_nip19_or_hex(
     }
 }
 
+pub fn generate_unsigned_pr_event(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    signing_public_key: &PublicKey,
+    commit: &Sha1Hash,
+    clone_url_hint: &[&str],
+    mentions: &[nostr::Tag],
+) -> Result<UnsignedEvent> {
+    let title = git_repo.get_commit_message_summary(commit)?;
+
+    let description = {
+        let mut description = git_repo.get_commit_message(commit)?.trim().to_string();
+        if let Some(remaining_description) = description.strip_prefix(&title) {
+            description = remaining_description.trim().to_string();
+        }
+        description
+    };
+
+    let root_commit = git_repo
+        .get_root_commit()
+        .context("failed to get root commit of the repository")?;
+
+    Ok(EventBuilder::new(KIND_PULL_REQUEST, description)
+        .tags(
+            [
+                repo_ref
+                    .maintainers
+                    .iter()
+                    .map(|m| {
+                        Tag::from_standardized(TagStandard::Coordinate {
+                            coordinate: Coordinate {
+                                kind: nostr::Kind::GitRepoAnnouncement,
+                                public_key: *m,
+                                identifier: repo_ref.identifier.to_string(),
+                            },
+                            relay_url: repo_ref.relays.first().cloned(),
+                            uppercase: false,
+                        })
+                    })
+                    .collect::<Vec<Tag>>(),
+                mentions.to_vec(),
+                vec![
+                    Tag::from_standardized(TagStandard::Subject(title.clone())),
+                    Tag::from_standardized(TagStandard::Reference(format!("{root_commit}"))),
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("c")),
+                        vec![format!("{commit}")],
+                    ),
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("clone")),
+                        clone_url_hint
+                            .iter()
+                            .map(|s| s.to_string())
+                            .collect::<Vec<String>>(),
+                    ),
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+                        vec![format!("git Pull Request: {}", title.clone())],
+                    ),
+                ],
+                if let Some(branch_name_tag) = make_branch_name_tag_from_check_out_branch(git_repo)
+                {
+                    vec![branch_name_tag]
+                } else {
+                    vec![]
+                },
+                repo_ref
+                    .maintainers
+                    .iter()
+                    .map(|pk| Tag::public_key(*pk))
+                    .collect(),
+            ]
+            .concat(),
+        )
+        .build(*signing_public_key))
+}
+
+fn make_branch_name_tag_from_check_out_branch(git_repo: &Repo) -> Option<Tag> {
+    if let Ok(branch_name) = git_repo.get_checked_out_branch_name() {
+        if !branch_name.eq("main")
+            && !branch_name.eq("master")
+            && !branch_name.eq("origin/main")
+            && !branch_name.eq("origin/master")
+        {
+            Some(Tag::custom(
+                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("branch-name")),
+                vec![
+                    if let Some(branch_name) = branch_name.strip_prefix("pr/") {
+                        branch_name.to_string()
+                    } else {
+                        branch_name
+                    }
+                    .chars()
+                    .take(60)
+                    .collect::<String>(),
+                ],
+            ))
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
 #[allow(clippy::too_many_lines)]
 pub async fn generate_cover_letter_and_patch_events(
     cover_letter_title_description: Option<(String, String)>,
@@ -409,24 +517,8 @@ pub async fn generate_cover_letter_and_patch_events(
             // eventually a prefix will be needed of the event id to stop 2 proposals with the same name colliding
             // a change like this, or the removal of this tag will require the actual branch name to be tracked
             // so pulling and pushing still work
-            if let Ok(branch_name) = git_repo.get_checked_out_branch_name() {
-                if !branch_name.eq("main")
-                    && !branch_name.eq("master")
-                    && !branch_name.eq("origin/main")
-                    && !branch_name.eq("origin/master")
-                {
-                    vec![
-                        Tag::custom(
-                            nostr::TagKind::Custom(std::borrow::Cow::Borrowed("branch-name")),
-                            vec![if let Some(branch_name) = branch_name.strip_prefix("pr/") {
-                                branch_name.to_string()
-                            } else {
-                                branch_name
-                            }.chars().take(60).collect::<String>()],
-                        ),
-                    ]
-                }
-                else { vec![] }
+            if let Some(branch_name_tag) = make_branch_name_tag_from_check_out_branch(git_repo) {
+                vec![branch_name_tag]
             } else {
                 vec![]
             },