1 files changed, 284 insertions, 37 deletions

diff --git a/src/lib/git_events.rs b/src/lib/git_events.rs
index 69406c1..2e1f215 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,
@@ -58,6 +61,9 @@ 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 fn event_is_patch_set_root(event: &Event) -> bool {
     event.kind.eq(&Kind::GitPatch)
         && event
@@ -67,11 +73,16 @@ pub fn event_is_patch_set_root(event: &Event) -> bool {
 }
 
 pub fn event_is_revision_root(event: &Event) -> bool {
-    event.kind.eq(&Kind::GitPatch)
+    (event.kind.eq(&Kind::GitPatch)
         && event
             .tags
             .iter()
-            .any(|t| t.as_slice().len() > 1 && t.as_slice()[1].eq("revision-root"))
+            .any(|t| t.as_slice().len() > 1 && t.as_slice()[1].eq("revision-root")))
+        || (event.kind.eq(&KIND_PULL_REQUEST)
+            && event
+                .tags
+                .iter()
+                .any(|t| t.as_slice().len() > 1 && t.as_slice()[0].eq("e")))
 }
 
 pub fn patch_supports_commit_ids(event: &Event) -> bool {
@@ -82,6 +93,19 @@ pub fn patch_supports_commit_ids(event: &Event) -> bool {
             .any(|t| !t.as_slice().is_empty() && t.as_slice()[0].eq("commit-pgp-sig"))
 }
 
+pub fn event_is_valid_pr_or_pr_update(event: &Event) -> bool {
+    [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&event.kind)
+        && event.tags.iter().any(|t| {
+            t.as_slice().len().gt(&1)
+                && t.as_slice()[0].eq("c")
+                && git2::Oid::from_str(&t.as_slice()[1]).is_ok()
+        })
+        && event
+            .tags
+            .iter()
+            .any(|t| t.as_slice().len().gt(&1) && t.as_slice()[0].eq("clone"))
+}
+
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::too_many_lines)]
 pub async fn generate_patch_event(
@@ -326,6 +350,180 @@ pub fn event_tag_from_nip19_or_hex(
     }
 }
 
+pub fn generate_unsigned_pr_or_update_event(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    signing_public_key: &PublicKey,
+    root_proposal: Option<&Event>,
+    commit: &Sha1Hash,
+    clone_url_hint: &[&str],
+    mentions: &[nostr::Tag],
+) -> Result<UnsignedEvent> {
+    let root_patch_cover_letter = if let Some(root_proposal) = root_proposal {
+        if root_proposal.kind.eq(&Kind::GitPatch) {
+            Some(event_to_cover_letter(root_proposal)?)
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let title = if let Some(cl) = &root_patch_cover_letter {
+        cl.title.clone()
+    } else {
+        git_repo.get_commit_message_summary(commit)?
+    };
+
+    let description = if let Some(cl) = &root_patch_cover_letter {
+        cl.description.clone()
+    } else {
+        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")?;
+
+    let pr_update_specific_tags = |root_proposal: &Event| {
+        vec![
+            Tag::custom(
+                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+                vec![format!("git Pull Request Update")],
+            ),
+            Tag::custom(
+                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("E")),
+                vec![root_proposal.id],
+            ),
+            Tag::custom(
+                nostr::TagKind::Custom(std::borrow::Cow::Borrowed("P")),
+                vec![root_proposal.pubkey],
+            ),
+        ]
+    };
+    let pr_specific_tags = || {
+        [
+            vec![
+                Tag::from_standardized(TagStandard::Subject(title.clone())),
+                Tag::custom(
+                    nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+                    vec![format!("git Pull Request: {}", title.clone())],
+                ),
+            ],
+            if let Some(cl) = &root_patch_cover_letter {
+                vec![
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("e")),
+                        vec![root_proposal.unwrap().id],
+                    ),
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("branch-name")),
+                        vec![cl.branch_name_without_id_or_prefix.clone()],
+                    ),
+                    Tag::public_key(root_proposal.unwrap().pubkey),
+                ]
+            } else if let Some(branch_name_tag) =
+                make_branch_name_tag_from_check_out_branch(git_repo)
+            {
+                vec![branch_name_tag]
+            } else {
+                vec![]
+            },
+        ]
+        .concat()
+    };
+
+    Ok(
+        if root_proposal.is_some() && root_patch_cover_letter.is_none() {
+            EventBuilder::new(KIND_PULL_REQUEST_UPDATE, "")
+        } else {
+            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(),
+                if let Some(root_proposal) = root_proposal {
+                    if root_patch_cover_letter.is_none() {
+                        pr_update_specific_tags(root_proposal)
+                    } else {
+                        pr_specific_tags()
+                    }
+                } else {
+                    pr_specific_tags()
+                },
+                vec![
+                    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>>(),
+                    ),
+                ],
+                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)>,
@@ -388,24 +586,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![]
             },
@@ -531,13 +713,22 @@ pub fn commit_msg_from_patch_oneliner(patch: &nostr::Event) -> Result<String> {
 }
 
 pub fn event_to_cover_letter(event: &nostr::Event) -> Result<CoverLetter> {
-    if !event_is_patch_set_root(event) {
+    if !event.kind.eq(&KIND_PULL_REQUEST) && !event_is_patch_set_root(event) {
         bail!("event is not a patch set root event (root patch or cover letter)")
     }
 
-    let title = commit_msg_from_patch_oneliner(event)?;
-    let full = commit_msg_from_patch(event)?;
-    let description = full[title.len()..].trim().to_string();
+    let title = if event.kind.eq(&KIND_PULL_REQUEST) {
+        tag_value(event, "subject").unwrap_or("untitled".to_owned())
+    } else {
+        commit_msg_from_patch_oneliner(event)?
+    };
+    let description = if event.kind.eq(&KIND_PULL_REQUEST) {
+        event.content.clone()
+    } else {
+        commit_msg_from_patch(event)?[title.len()..]
+            .trim()
+            .to_string()
+    };
 
     Ok(CoverLetter {
         title: title.clone(),
@@ -569,25 +760,25 @@ fn safe_branch_name_for_pr(s: &str) -> String {
         .collect()
 }
 
-pub fn get_most_recent_patch_with_ancestors(
-    mut patches: Vec<nostr::Event>,
+pub fn get_pr_tip_event_or_most_recent_patch_with_ancestors(
+    mut proposal_events: Vec<nostr::Event>,
 ) -> Result<Vec<nostr::Event>> {
-    patches.sort_by_key(|e| e.created_at);
+    proposal_events.sort_by_key(|e| e.created_at);
 
-    let youngest_patch = patches.last().context("no patches found")?;
+    let youngest = proposal_events.last().context("no proposal events found")?;
 
-    let patches_with_youngest_created_at: Vec<&nostr::Event> = patches
+    let events_with_youngest_created_at: Vec<&nostr::Event> = proposal_events
         .iter()
-        .filter(|p| p.created_at.eq(&youngest_patch.created_at))
+        .filter(|p| p.created_at.eq(&youngest.created_at))
         .collect();
 
     let mut res = vec![];
 
-    let mut event_id_to_search = patches_with_youngest_created_at
+    let mut event_id_to_search = events_with_youngest_created_at
         .clone()
         .iter()
         .find(|p| {
-            !patches_with_youngest_created_at.iter().any(|p2| {
+            !events_with_youngest_created_at.iter().any(|p2| {
                 if let Ok(reply_to) = get_event_parent_id(p2) {
                     reply_to.eq(&p.id.to_string())
                 } else {
@@ -595,16 +786,18 @@ pub fn get_most_recent_patch_with_ancestors(
                 }
             })
         })
-        .context("failed to find patches_with_youngest_created_at")?
+        .context("failed to find events_with_youngest_created_at")?
         .id
         .to_string();
 
-    while let Some(event) = patches
+    while let Some(event) = proposal_events
         .iter()
         .find(|e| e.id.to_string().eq(&event_id_to_search))
     {
         res.push(event.clone());
-        if event_is_patch_set_root(event) {
+        if [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&event.kind)
+            || event_is_patch_set_root(event)
+        {
             break;
         }
         event_id_to_search = get_event_parent_id(event).unwrap_or_default();
@@ -642,7 +835,61 @@ pub fn is_event_proposal_root_for_branch(
             || cl
                 .get_branch_name_with_pr_prefix_and_shorthand_id()
                 .is_ok_and(|s| s.eq(&branch_name))
-    }) && !event_is_revision_root(e))
+    }) && (
+        // If we wanted to treat to list Pull Requests that revise a Patch we would do this:
+        // Note: whilst this the the case elsewhere event_is_revision_root is used, there is more to
+        //       think about here?
+        // e.kind.eq(&KIND_PULL_REQUEST) ||
+        !event_is_revision_root(e)
+    ))
+}
+
+pub fn get_status(
+    proposal: &Event,
+    repo_ref: &RepoRef,
+    all_status_in_repo: &[Event],
+    all_pr_roots_in_repo: &[Event],
+) -> Kind {
+    let get_direct_status = |proposal: &Event| {
+        if let Some(e) = all_status_in_repo
+            .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())
+                    })
+                    && (proposal.pubkey.eq(&e.pubkey) || repo_ref.maintainers.contains(&e.pubkey))
+            })
+            .collect::<Vec<&nostr::Event>>()
+            .first()
+        {
+            e.kind
+        } else {
+            Kind::GitStatusOpen
+        }
+    };
+    let is_proposal_pr_revision_of_patch = |proposal: &Event, patch: &Event| {
+        proposal.kind.eq(&KIND_PULL_REQUEST)
+            && proposal.tags.clone().into_iter().any(|t| {
+                t.as_slice().len() > 1
+                    && t.as_slice()[0].eq("e")
+                    && t.as_slice()[1].eq(&patch.id.to_string())
+            })
+    };
+
+    let direct_status = get_direct_status(proposal);
+    if direct_status.eq(&Kind::GitStatusClosed) && proposal.kind.eq(&Kind::GitPatch) {
+        if let Some(pr_revision) = all_pr_roots_in_repo
+            .iter()
+            .find(|p| is_proposal_pr_revision_of_patch(p, proposal))
+        {
+            get_direct_status(pr_revision)
+        } else {
+            direct_status
+        }
+    } else {
+        direct_status
+    }
 }
 
 #[cfg(test)]