From b3b1a949463d8e18622519866ecee3f1b65cc888 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Wed, 4 Mar 2026 14:28:38 +0000 Subject: restructure CLI around ngit pr/issue subcommand groups Introduce ngit pr subcommand group (list, view, checkout, apply, send, close, reopen, ready, comment, merge) replacing the former top-level ngit list/checkout/apply commands. ngit send is kept at the top level. Expand ngit issue with view, create, close, reopen, comment subcommands. Status changes (close/reopen/ready) are gated to the PR/issue author or a repository maintainer. ngit pr merge is maintainer-only and publishes a GitStatusApplied event immediately after the git merge. --- src/bin/ngit/sub_commands/comment.rs | 182 ++++++++++++++++++++++ src/bin/ngit/sub_commands/issue_create.rs | 122 +++++++++++++++ src/bin/ngit/sub_commands/issue_status.rs | 178 +++++++++++++++++++++ src/bin/ngit/sub_commands/mod.rs | 5 + src/bin/ngit/sub_commands/pr_merge.rs | 249 ++++++++++++++++++++++++++++++ src/bin/ngit/sub_commands/pr_status.rs | 199 ++++++++++++++++++++++++ 6 files changed, 935 insertions(+) create mode 100644 src/bin/ngit/sub_commands/comment.rs create mode 100644 src/bin/ngit/sub_commands/issue_create.rs create mode 100644 src/bin/ngit/sub_commands/issue_status.rs create mode 100644 src/bin/ngit/sub_commands/pr_merge.rs create mode 100644 src/bin/ngit/sub_commands/pr_status.rs (limited to 'src/bin/ngit/sub_commands') diff --git a/src/bin/ngit/sub_commands/comment.rs b/src/bin/ngit/sub_commands/comment.rs new file mode 100644 index 0000000..a9b0aa7 --- /dev/null +++ b/src/bin/ngit/sub_commands/comment.rs @@ -0,0 +1,182 @@ +use anyhow::{Context, Result, bail}; +use ngit::{ + client::{ + Params, get_issues_from_cache, get_proposals_and_revisions_from_cache, send_events, + sign_event, + }, + git_events::KIND_COMMENT, +}; +use nostr::{EventBuilder, Tag, nips::nip19::Nip19}; +use nostr_sdk::{EventId, FromBech32, Kind}; + +use crate::{ + client::{Client, Connect, fetching_with_report, get_repo_ref_from_cache}, + git::{Repo, RepoActions}, + login, + repo_ref::get_repo_coordinates_when_remote_unknown, +}; + +fn parse_event_id(id: &str) -> Result { + if let Ok(nip19) = Nip19::from_bech32(id) { + match nip19 { + nostr::nips::nip19::Nip19::Event(e) => return Ok(e.event_id), + nostr::nips::nip19::Nip19::EventId(event_id) => return Ok(event_id), + _ => {} + } + } + if let Ok(event_id) = EventId::from_hex(id) { + return Ok(event_id); + } + bail!("invalid event-id or nevent: {id}") +} + +/// Build and publish a NIP-22 kind-1111 comment on any event. +/// +/// NIP-22 threading tags: +/// - uppercase `E` — root event id +/// - uppercase `K` — root event kind (as string) +/// - lowercase `e` — parent event id (same as root for top-level comments) +/// - lowercase `k` — parent event kind +async fn publish_comment( + id: &str, + body: &str, + offline: bool, + root_kind: Kind, + entity_name: &str, +) -> Result<()> { + let event_id = parse_event_id(id)?; + + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + + // Login + let (signer, user_ref, _) = + login::login_or_signup(&Some(&git_repo), &None, &None, Some(&client), true).await?; + + let root_kind_str = root_kind.as_u16().to_string(); + + // NIP-22: uppercase E = root event, uppercase K = root kind, + // lowercase e = parent event (same as root for top-level), + // lowercase k = parent kind + let comment_event = sign_event( + EventBuilder::new(KIND_COMMENT, body).tags(vec![ + // Root event (uppercase E) + Tag::parse(vec![ + "E".to_string(), + event_id.to_hex(), + repo_ref + .relays + .first() + .map(ToString::to_string) + .unwrap_or_default(), + String::new(), // root marker + ])?, + // Root kind (uppercase K) + Tag::parse(vec!["K".to_string(), root_kind_str.clone()])?, + // Parent event (lowercase e, same as root for top-level comment) + Tag::parse(vec![ + "e".to_string(), + event_id.to_hex(), + repo_ref + .relays + .first() + .map(ToString::to_string) + .unwrap_or_default(), + "reply".to_string(), + ])?, + // Parent kind (lowercase k) + Tag::parse(vec!["k".to_string(), root_kind_str])?, + ]), + &signer, + format!("comment on {entity_name}"), + ) + .await?; + + let mut client = client; + client.set_signer(signer).await; + + send_events( + &client, + Some(git_repo_path), + vec![comment_event], + user_ref.relays.write(), + repo_ref.relays.clone(), + true, + false, + ) + .await?; + + println!( + "comment posted on {entity_name} {}", + &event_id.to_hex()[..8] + ); + Ok(()) +} + +pub async fn launch_pr_comment(id: &str, body: &str, offline: bool) -> Result<()> { + // Verify the PR exists in cache + let event_id = parse_event_id(id)?; + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + let proposals = + get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates()).await?; + + let proposal = proposals + .iter() + .find(|e| e.id == event_id) + .context(format!( + "PR with id {} not found in cache", + event_id.to_hex() + ))?; + + let root_kind = proposal.kind; + + publish_comment(id, body, true /* already fetched */, root_kind, "PR").await +} + +pub async fn launch_issue_comment(id: &str, body: &str, offline: bool) -> Result<()> { + // Verify the issue exists in cache + let event_id = parse_event_id(id)?; + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + let issues = get_issues_from_cache(git_repo_path, repo_ref.coordinates()).await?; + + issues.iter().find(|e| e.id == event_id).context(format!( + "issue with id {} not found in cache", + event_id.to_hex() + ))?; + + publish_comment( + id, + body, + true, /* already fetched */ + Kind::GitIssue, + "issue", + ) + .await +} diff --git a/src/bin/ngit/sub_commands/issue_create.rs b/src/bin/ngit/sub_commands/issue_create.rs new file mode 100644 index 0000000..0c4b677 --- /dev/null +++ b/src/bin/ngit/sub_commands/issue_create.rs @@ -0,0 +1,122 @@ +use anyhow::{Context, Result, bail}; +use ngit::client::{Params, send_events, sign_event}; +use nostr::{EventBuilder, Tag, TagStandard, ToBech32, nips::nip19::Nip19Event}; +use nostr_sdk::Kind; + +use crate::{ + client::{Client, Connect, fetching_with_report, get_repo_ref_from_cache}, + git::{Repo, RepoActions}, + login, + repo_ref::get_repo_coordinates_when_remote_unknown, +}; + +pub async fn launch( + title: Option, + body: Option, + labels: Vec, +) -> Result<()> { + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + + // Resolve title — required + let title = match title { + Some(t) if !t.trim().is_empty() => t, + _ => bail!("--title is required to create an issue"), + }; + + // Body defaults to empty string if not provided + let body = body.unwrap_or_default(); + + // Login + let (signer, user_ref, _) = + login::login_or_signup(&Some(&git_repo), &None, &None, Some(&client), true).await?; + + // Build NIP-34 GitIssue event (kind 1621) + // Tags: + // - `a` coordinate tags for each maintainer's repo announcement + // - `subject` — issue title + // - `t` — hashtag labels + // - `alt` — human-readable summary + let mut tags: Vec = vec![]; + + // Repo coordinate tags (one per maintainer) + for coord in repo_ref.coordinates() { + tags.push(Tag::from_standardized(TagStandard::Coordinate { + coordinate: coord.coordinate.clone(), + relay_url: coord.relays.first().cloned(), + uppercase: false, + })); + } + + // Subject (title) + tags.push(Tag::parse(vec!["subject".to_string(), title.clone()])?); + + // Hashtag labels + for label in &labels { + tags.push(Tag::hashtag(label)); + } + + // Alt text + tags.push(Tag::custom( + nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")), + vec![format!("git issue: {title}")], + )); + + // Maintainer p-tags (so they get notified) + for pk in &repo_ref.maintainers { + tags.push(Tag::public_key(*pk)); + } + + let issue_event = sign_event( + EventBuilder::new(Kind::GitIssue, body).tags(tags), + &signer, + "create issue".to_string(), + ) + .await?; + + let event_id = issue_event.id; + + let mut client = client; + client.set_signer(signer).await; + + send_events( + &client, + Some(git_repo_path), + vec![issue_event], + user_ref.relays.write(), + repo_ref.relays.clone(), + true, + false, + ) + .await?; + + let event_bech32 = if let Some(relay) = repo_ref.relays.first() { + Nip19Event { + event_id, + relays: vec![relay.clone()], + author: None, + kind: None, + } + .to_bech32()? + } else { + event_id.to_bech32()? + }; + + println!("issue created: {event_id}"); + let dim = console::Style::new().color256(247); + println!( + "{}", + dim.apply_to(format!( + "view in gitworkshop.dev: https://gitworkshop.dev/{}", + &event_bech32, + )) + ); + Ok(()) +} diff --git a/src/bin/ngit/sub_commands/issue_status.rs b/src/bin/ngit/sub_commands/issue_status.rs new file mode 100644 index 0000000..3facee3 --- /dev/null +++ b/src/bin/ngit/sub_commands/issue_status.rs @@ -0,0 +1,178 @@ +use anyhow::{Context, Result, bail}; +use ngit::{ + client::{Params, get_issues_from_cache, send_events, sign_event}, + git_events::{get_status, status_kinds}, +}; +use nostr::{EventBuilder, Tag, TagStandard, nips::nip19::Nip19}; +use nostr_sdk::{EventId, FromBech32, Kind, nips::nip10::Marker}; + +use crate::{ + client::{ + Client, Connect, fetching_with_report, get_events_from_local_cache, get_repo_ref_from_cache, + }, + git::{Repo, RepoActions}, + login, + repo_ref::get_repo_coordinates_when_remote_unknown, +}; + +fn parse_event_id(id: &str) -> Result { + if let Ok(nip19) = Nip19::from_bech32(id) { + match nip19 { + nostr::nips::nip19::Nip19::Event(e) => return Ok(e.event_id), + nostr::nips::nip19::Nip19::EventId(event_id) => return Ok(event_id), + _ => {} + } + } + if let Ok(event_id) = EventId::from_hex(id) { + return Ok(event_id); + } + bail!("invalid event-id or nevent: {id}") +} + +#[allow(clippy::too_many_lines)] +async fn launch_status(id: &str, offline: bool, new_kind: Kind, action: &str) -> Result<()> { + let event_id = parse_event_id(id)?; + + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + + let issues = get_issues_from_cache(git_repo_path, repo_ref.coordinates()).await?; + + let issue = issues + .iter() + .find(|e| e.id == event_id) + .context(format!( + "issue with id {} not found in cache", + event_id.to_hex() + ))? + .clone(); + + // Login to get signer and user pubkey + let (signer, user_ref, _) = + login::login_or_signup(&Some(&git_repo), &None, &None, Some(&client), true).await?; + + let user_pubkey = signer.get_public_key().await?; + + // Only author or maintainer may change status + if issue.pubkey != user_pubkey && !repo_ref.maintainers.contains(&user_pubkey) { + bail!("only the issue author or a repository maintainer can {action} an issue"); + } + + // Fetch existing statuses to check current state + let statuses = { + let mut s = get_events_from_local_cache( + git_repo_path, + vec![ + nostr::Filter::default() + .kinds(status_kinds().clone()) + .events(issues.iter().map(|e| e.id)), + nostr::Filter::default() + .custom_tags( + nostr::filter::SingleLetterTag::uppercase(nostr::filter::Alphabet::E), + issues.iter().map(|e| e.id), + ) + .kinds(status_kinds().clone()), + ], + ) + .await?; + s.sort_by_key(|e| e.created_at); + s.reverse(); + s + }; + + let empty_proposals: Vec = vec![]; + let current_status = get_status(&issue, &repo_ref, &statuses, &empty_proposals); + + if current_status == new_kind { + let status_str = match new_kind { + Kind::GitStatusOpen => "open", + Kind::GitStatusClosed => "closed", + _ => "unknown", + }; + println!("issue is already {status_str}"); + return Ok(()); + } + + let alt_text = match new_kind { + Kind::GitStatusOpen => "issue reopened", + Kind::GitStatusClosed => "issue closed", + _ => "issue status updated", + }; + + let mut public_keys: std::collections::HashSet = + repo_ref.maintainers.iter().copied().collect(); + public_keys.insert(issue.pubkey); + + let status_event = sign_event( + EventBuilder::new(new_kind, "").tags( + [ + vec![ + Tag::custom( + nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")), + vec![alt_text.to_string()], + ), + Tag::from_standardized(TagStandard::Event { + event_id: issue.id, + relay_url: repo_ref.relays.first().cloned(), + marker: Some(Marker::Root), + public_key: None, + uppercase: false, + }), + ], + public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(), + repo_ref + .coordinates() + .iter() + .map(|c| { + Tag::from_standardized(TagStandard::Coordinate { + coordinate: c.coordinate.clone(), + relay_url: c.relays.first().cloned(), + uppercase: false, + }) + }) + .collect::>(), + vec![Tag::from_standardized(nostr::TagStandard::Reference( + repo_ref.root_commit.to_string(), + ))], + ] + .concat(), + ), + &signer, + format!("{action} issue"), + ) + .await?; + + let mut client = client; + client.set_signer(signer).await; + + send_events( + &client, + Some(git_repo_path), + vec![status_event], + user_ref.relays.write(), + repo_ref.relays.clone(), + true, + false, + ) + .await?; + + println!("issue {} {}d", &event_id.to_hex()[..8], action,); + Ok(()) +} + +pub async fn launch_close(id: &str, offline: bool) -> Result<()> { + launch_status(id, offline, Kind::GitStatusClosed, "close").await +} + +pub async fn launch_reopen(id: &str, offline: bool) -> Result<()> { + launch_status(id, offline, Kind::GitStatusOpen, "reopen").await +} diff --git a/src/bin/ngit/sub_commands/mod.rs b/src/bin/ngit/sub_commands/mod.rs index d864391..60dc413 100644 --- a/src/bin/ngit/sub_commands/mod.rs +++ b/src/bin/ngit/sub_commands/mod.rs @@ -1,12 +1,17 @@ pub mod apply; pub mod checkout; +pub mod comment; pub mod create; pub mod export_keys; pub mod init; +pub mod issue_create; pub mod issue_list; +pub mod issue_status; pub mod list; pub mod login; pub mod logout; +pub mod pr_merge; +pub mod pr_status; pub mod repo; pub mod send; pub mod sync; diff --git a/src/bin/ngit/sub_commands/pr_merge.rs b/src/bin/ngit/sub_commands/pr_merge.rs new file mode 100644 index 0000000..df00e7e --- /dev/null +++ b/src/bin/ngit/sub_commands/pr_merge.rs @@ -0,0 +1,249 @@ +use anyhow::{Context, Result, bail}; +use ngit::{ + client::{ + Params, get_all_proposal_patch_pr_pr_update_events_from_cache, + get_proposals_and_revisions_from_cache, send_events, sign_event, + }, + git_events::{ + KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, + get_pr_tip_event_or_most_recent_patch_with_ancestors, get_status, status_kinds, tag_value, + }, +}; +use nostr::{EventBuilder, Tag, TagStandard, nips::nip19::Nip19}; +use nostr_sdk::{EventId, FromBech32, Kind, nips::nip10::Marker}; + +use crate::{ + client::{ + Client, Connect, fetching_with_report, get_events_from_local_cache, get_repo_ref_from_cache, + }, + git::{Repo, RepoActions, str_to_sha1}, + git_events::event_to_cover_letter, + login, + repo_ref::get_repo_coordinates_when_remote_unknown, +}; + +fn parse_event_id(id: &str) -> Result { + if let Ok(nip19) = Nip19::from_bech32(id) { + match nip19 { + nostr::nips::nip19::Nip19::Event(e) => return Ok(e.event_id), + nostr::nips::nip19::Nip19::EventId(event_id) => return Ok(event_id), + _ => {} + } + } + if let Ok(event_id) = EventId::from_hex(id) { + return Ok(event_id); + } + bail!("invalid event-id or nevent: {id}") +} + +#[allow(clippy::too_many_lines)] +pub async fn launch(id: &str, squash: bool, offline: bool) -> Result<()> { + let event_id = parse_event_id(id)?; + + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + + // Login to verify maintainer status + let (signer, user_ref, _) = + login::login_or_signup(&Some(&git_repo), &None, &None, Some(&client), true).await?; + + let user_pubkey = signer.get_public_key().await?; + + if !repo_ref.maintainers.contains(&user_pubkey) { + bail!("only a repository maintainer can merge a PR"); + } + + let proposals_and_revisions = + get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates()).await?; + + let proposal = proposals_and_revisions + .iter() + .find(|e| e.id == event_id) + .context(format!( + "PR with id {} not found in cache", + event_id.to_hex() + ))? + .clone(); + + // Check current status — only open/draft PRs can be merged + let statuses = { + let mut s = get_events_from_local_cache( + git_repo_path, + vec![ + nostr::Filter::default() + .kinds(status_kinds().clone()) + .events(proposals_and_revisions.iter().map(|e| e.id)), + nostr::Filter::default() + .custom_tags( + nostr::filter::SingleLetterTag::uppercase(nostr::filter::Alphabet::E), + proposals_and_revisions.iter().map(|e| e.id), + ) + .kinds(status_kinds().clone()), + ], + ) + .await?; + s.sort_by_key(|e| e.created_at); + s.reverse(); + s + }; + + let proposals_vec: Vec = proposals_and_revisions + .iter() + .filter(|e| !ngit::git_events::event_is_revision_root(e)) + .cloned() + .collect(); + + let current_status = get_status(&proposal, &repo_ref, &statuses, &proposals_vec); + + if current_status == Kind::GitStatusApplied { + bail!("PR is already applied/merged"); + } + if current_status == Kind::GitStatusClosed { + bail!("PR is closed; reopen it before merging"); + } + + let cover_letter = event_to_cover_letter(&proposal).context("failed to extract PR details")?; + + let branch_name = cover_letter.get_branch_name_with_pr_prefix_and_shorthand_id()?; + + // Get the PR tip commit + let commits_events = get_all_proposal_patch_pr_pr_update_events_from_cache( + git_repo_path, + &repo_ref, + &proposal.id, + ) + .await?; + + let tip_chain = get_pr_tip_event_or_most_recent_patch_with_ancestors(commits_events) + .context("failed to find any PR or patch events on this proposal")?; + + let tip_commit_str = if tip_chain + .iter() + .any(|e| [KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE].contains(&e.kind)) + { + let tip_event = tip_chain.first().context("tip chain is empty")?; + tag_value(tip_event, "c").context("PR event missing tip commit tag 'c'")? + } else { + ngit::git_events::get_commit_id_from_patch( + tip_chain.first().context("patch chain is empty")?, + ) + .context("failed to get commit id from patch")? + }; + + let _tip_commit = str_to_sha1(&tip_commit_str).context("invalid tip commit OID")?; + + // Ensure the branch exists locally + let local_branch_exists = git_repo + .get_local_branch_names() + .context("failed to get local branch names")? + .iter() + .any(|n| n.eq(&branch_name)); + + if !local_branch_exists { + // Try to create the branch at the tip commit + if !git_repo.does_commit_exist(&tip_commit_str)? { + bail!( + "PR tip commit {tip_commit_str} not found locally. Run `ngit pr checkout {id}` first." + ); + } + git_repo.create_branch_at_commit(&branch_name, &tip_commit_str)?; + println!("created local branch '{branch_name}' at PR tip"); + } + + // Perform the git merge + let merge_args = if squash { + vec!["merge", "--squash", &branch_name] + } else { + vec!["merge", "--no-ff", &branch_name] + }; + + let output = std::process::Command::new("git") + .args(&merge_args) + .output() + .context("failed to run git merge")?; + + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr); + bail!("git merge failed:\n{stderr}"); + } + + let stdout = String::from_utf8_lossy(&output.stdout); + if !stdout.trim().is_empty() { + print!("{stdout}"); + } + + // Publish GitStatusApplied event + let mut public_keys: std::collections::HashSet = + repo_ref.maintainers.iter().copied().collect(); + public_keys.insert(proposal.pubkey); + + let applied_event = sign_event( + EventBuilder::new(Kind::GitStatusApplied, "").tags( + [ + vec![ + Tag::custom( + nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")), + vec!["PR merged".to_string()], + ), + Tag::from_standardized(TagStandard::Event { + event_id: proposal.id, + relay_url: repo_ref.relays.first().cloned(), + marker: Some(Marker::Root), + public_key: None, + uppercase: false, + }), + ], + public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(), + repo_ref + .coordinates() + .iter() + .map(|c| { + Tag::from_standardized(TagStandard::Coordinate { + coordinate: c.coordinate.clone(), + relay_url: c.relays.first().cloned(), + uppercase: false, + }) + }) + .collect::>(), + vec![Tag::from_standardized(nostr::TagStandard::Reference( + repo_ref.root_commit.to_string(), + ))], + ] + .concat(), + ), + &signer, + "mark PR as applied".to_string(), + ) + .await?; + + let mut client = client; + client.set_signer(signer).await; + + send_events( + &client, + Some(git_repo_path), + vec![applied_event], + user_ref.relays.write(), + repo_ref.relays.clone(), + true, + false, + ) + .await?; + + println!("PR '{}' merged and marked as applied", cover_letter.title); + println!( + "{}", + console::style("Push to update the nostr state: git push").yellow() + ); + + Ok(()) +} diff --git a/src/bin/ngit/sub_commands/pr_status.rs b/src/bin/ngit/sub_commands/pr_status.rs new file mode 100644 index 0000000..e84117d --- /dev/null +++ b/src/bin/ngit/sub_commands/pr_status.rs @@ -0,0 +1,199 @@ +use anyhow::{Context, Result, bail}; +use ngit::{ + client::{Params, get_proposals_and_revisions_from_cache, send_events, sign_event}, + git_events::{get_status, status_kinds}, +}; +use nostr::{EventBuilder, Tag, TagStandard, ToBech32, nips::nip19::Nip19}; +use nostr_sdk::{EventId, FromBech32, Kind, nips::nip10::Marker}; + +use crate::{ + client::{ + Client, Connect, fetching_with_report, get_events_from_local_cache, get_repo_ref_from_cache, + }, + git::{Repo, RepoActions}, + login, + repo_ref::get_repo_coordinates_when_remote_unknown, +}; + +fn parse_event_id(id: &str) -> Result { + if let Ok(nip19) = Nip19::from_bech32(id) { + match nip19 { + nostr::nips::nip19::Nip19::Event(e) => return Ok(e.event_id), + nostr::nips::nip19::Nip19::EventId(event_id) => return Ok(event_id), + _ => {} + } + } + if let Ok(event_id) = EventId::from_hex(id) { + return Ok(event_id); + } + bail!("invalid event-id or nevent: {id}") +} + +#[allow(clippy::too_many_lines)] +async fn launch_status(id: &str, offline: bool, new_kind: Kind, action: &str) -> Result<()> { + let event_id = parse_event_id(id)?; + + let git_repo = Repo::discover().context("failed to find a git repository")?; + let git_repo_path = git_repo.get_path()?; + + let client = Client::new(Params::with_git_config_relay_defaults(&Some(&git_repo))); + let repo_coordinates = get_repo_coordinates_when_remote_unknown(&git_repo, &client).await?; + + if !offline { + fetching_with_report(git_repo_path, &client, &repo_coordinates).await?; + } + + let repo_ref = get_repo_ref_from_cache(Some(git_repo_path), &repo_coordinates).await?; + + let proposals_and_revisions = + get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates()).await?; + + let proposal = proposals_and_revisions + .iter() + .find(|e| e.id == event_id) + .context(format!( + "PR with id {} not found in cache", + event_id.to_hex() + ))? + .clone(); + + // Login to get signer and user pubkey + let (signer, user_ref, _) = + login::login_or_signup(&Some(&git_repo), &None, &None, Some(&client), true).await?; + + let user_pubkey = signer.get_public_key().await?; + + // Only author or maintainer may change status + if proposal.pubkey != user_pubkey && !repo_ref.maintainers.contains(&user_pubkey) { + bail!("only the PR author or a repository maintainer can {action} a PR"); + } + + // Fetch existing statuses to check current state + let statuses = { + let mut s = get_events_from_local_cache( + git_repo_path, + vec![ + nostr::Filter::default() + .kinds(status_kinds().clone()) + .events(proposals_and_revisions.iter().map(|e| e.id)), + nostr::Filter::default() + .custom_tags( + nostr::filter::SingleLetterTag::uppercase(nostr::filter::Alphabet::E), + proposals_and_revisions.iter().map(|e| e.id), + ) + .kinds(status_kinds().clone()), + ], + ) + .await?; + s.sort_by_key(|e| e.created_at); + s.reverse(); + s + }; + + let proposals_vec: Vec = proposals_and_revisions + .iter() + .filter(|e| !ngit::git_events::event_is_revision_root(e)) + .cloned() + .collect(); + + let current_status = get_status(&proposal, &repo_ref, &statuses, &proposals_vec); + + // Guard against no-op transitions + if current_status == new_kind { + let status_str = match new_kind { + Kind::GitStatusOpen => "open", + Kind::GitStatusClosed => "closed", + Kind::GitStatusDraft => "draft", + Kind::GitStatusApplied => "applied", + _ => "unknown", + }; + println!("PR is already {status_str}"); + return Ok(()); + } + + let alt_text = match new_kind { + Kind::GitStatusOpen => "PR reopened", + Kind::GitStatusClosed => "PR closed", + Kind::GitStatusDraft => "PR marked as draft", + Kind::GitStatusApplied => "PR applied/merged", + _ => "PR status updated", + }; + + // Build status event following the same pattern as push.rs + let mut public_keys: std::collections::HashSet = + repo_ref.maintainers.iter().copied().collect(); + public_keys.insert(proposal.pubkey); + + let status_event = sign_event( + EventBuilder::new(new_kind, "").tags( + [ + vec![ + Tag::custom( + nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")), + vec![alt_text.to_string()], + ), + Tag::from_standardized(TagStandard::Event { + event_id: proposal.id, + relay_url: repo_ref.relays.first().cloned(), + marker: Some(Marker::Root), + public_key: None, + uppercase: false, + }), + ], + public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(), + repo_ref + .coordinates() + .iter() + .map(|c| { + Tag::from_standardized(TagStandard::Coordinate { + coordinate: c.coordinate.clone(), + relay_url: c.relays.first().cloned(), + uppercase: false, + }) + }) + .collect::>(), + vec![Tag::from_standardized(nostr::TagStandard::Reference( + repo_ref.root_commit.to_string(), + ))], + ] + .concat(), + ), + &signer, + format!("{action} PR"), + ) + .await?; + + let mut client = client; + client.set_signer(signer).await; + + send_events( + &client, + Some(git_repo_path), + vec![status_event], + user_ref.relays.write(), + repo_ref.relays.clone(), + true, + false, + ) + .await?; + + println!( + "PR {} {}d: {}", + &event_id.to_hex()[..8], + action, + proposal.pubkey.to_bech32().unwrap_or_default() + ); + Ok(()) +} + +pub async fn launch_close(id: &str, offline: bool) -> Result<()> { + launch_status(id, offline, Kind::GitStatusClosed, "close").await +} + +pub async fn launch_reopen(id: &str, offline: bool) -> Result<()> { + launch_status(id, offline, Kind::GitStatusOpen, "reopen").await +} + +pub async fn launch_ready(id: &str, offline: bool) -> Result<()> { + launch_status(id, offline, Kind::GitStatusOpen, "mark as ready").await +} -- cgit v1.2.3