1 files changed, 202 insertions, 0 deletions

diff --git a/src/bin/ngit/sub_commands/set_cover_note.rs b/src/bin/ngit/sub_commands/set_cover_note.rs
new file mode 100644
index 0000000..49d4f34
--- /dev/null
+++ b/src/bin/ngit/sub_commands/set_cover_note.rs
@@ -0,0 +1,202 @@
+use anyhow::{Context, Result, bail};
+use ngit::{
+    client::{Params, get_issues_from_cache, get_proposals_and_revisions_from_cache, send_events},
+    content_tags::{dedup_tags, tags_from_content},
+    git_events::{KIND_COVER_NOTE, process_cover_note},
+};
+use nostr::{EventBuilder, Tag, TagStandard, nips::nip19::Nip19};
+use nostr_sdk::{EventId, FromBech32};
+
+use crate::{
+    client::{
+        Client, Connect, fetching_with_report, get_events_from_local_cache,
+        get_repo_ref_from_cache, save_event_in_local_cache,
+    },
+    git::{Repo, RepoActions},
+    login,
+    repo_ref::get_repo_coordinates_when_remote_unknown,
+};
+
+fn parse_event_id(id: &str) -> Result<EventId> {
+    if let Ok(nip19) = Nip19::from_bech32(id) {
+        match nip19 {
+            Nip19::Event(e) => return Ok(e.event_id),
+            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}")
+}
+
+/// Shared implementation: publish a kind-1624 cover note event for `target`.
+///
+/// A cover note is a markdown body that replaces the displayed description of a
+/// PR, patch or issue.  Only the author of the target event or a repository
+/// maintainer may set it.  The latest authorised event wins (replaceable
+/// semantics with hex-id tiebreak).
+///
+/// The `body` is processed for `nostr:` mentions (NIP-21), which are converted
+/// to `q` (event) and `p` (pubkey) tags — the same rules as `--body` in issue
+/// creation.
+#[allow(clippy::too_many_lines)]
+async fn publish_set_cover_note_event(
+    id: &str,
+    body: &str,
+    offline: bool,
+    target_kind: &str, // "issue" or "PR" — used in error messages
+) -> Result<()> {
+    let body = body.trim();
+    if body.is_empty() {
+        bail!("--body value must not be empty");
+    }
+
+    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?;
+
+    // Resolve the target event from cache.
+    let target = if target_kind == "issue" {
+        let issues = get_issues_from_cache(git_repo_path, repo_ref.coordinates()).await?;
+        issues
+            .into_iter()
+            .find(|e| e.id == event_id)
+            .context(format!(
+                "issue with id {} not found in cache",
+                event_id.to_hex()
+            ))?
+    } else {
+        let proposals =
+            get_proposals_and_revisions_from_cache(git_repo_path, repo_ref.coordinates()).await?;
+        proposals
+            .into_iter()
+            .find(|e| e.id == event_id)
+            .context(format!(
+                "PR with id {} not found in cache",
+                event_id.to_hex()
+            ))?
+    };
+
+    // Login — we need the 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?;
+
+    // Permission check: only the author or a maintainer may set a cover note.
+    if target.pubkey != user_pubkey && !repo_ref.maintainers.contains(&user_pubkey) {
+        bail!(
+            "only the {target_kind} author or a repository maintainer can set the cover note of a {target_kind}"
+        );
+    }
+
+    // Fetch existing cover note events so we can check whether the body is
+    // already set to the requested value.
+    let existing_cover_note_events = get_events_from_local_cache(
+        git_repo_path,
+        vec![
+            nostr::Filter::default()
+                .event(event_id)
+                .kind(KIND_COVER_NOTE),
+        ],
+    )
+    .await?;
+
+    if let Some((existing_cn, _)) =
+        process_cover_note(&target, &repo_ref, &existing_cover_note_events)
+    {
+        if existing_cn.content.trim() == body {
+            println!(
+                "{target_kind} {} already has this cover note",
+                &event_id.to_hex()[..8],
+            );
+            return Ok(());
+        }
+    }
+
+    // Build the kind-1624 cover note event.
+    //
+    // Shape:
+    //   content: "<markdown>"
+    //   tags:
+    //     ["e", "<pr-issue-or-patch-id>", "<relay-hint>"]  — reference to target
+    //     ["p", "<author-pubkey>"]                          — notify the author
+    //     ["q", "<referenced-event>", ...]                  — from body mentions
+    //     ["p", "<referenced-pubkey>", ...]                 — from body mentions
+    //     ["alt", "cover note for <target_kind>"]
+    let relay_hint = repo_ref.relays.first().cloned();
+
+    let mut tags: Vec<Tag> = vec![];
+
+    // Reference the target event (lowercase `e`).
+    tags.push(Tag::from_standardized(TagStandard::Event {
+        event_id: target.id,
+        relay_url: relay_hint.clone(),
+        marker: None,
+        public_key: None,
+        uppercase: false,
+    }));
+
+    // Notify the target event author.
+    tags.push(Tag::public_key(target.pubkey));
+
+    // Human-readable alt text.
+    tags.push(Tag::custom(
+        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+        vec![format!("cover note for {target_kind}")],
+    ));
+
+    // Process body for nostr: mentions → q and p tags (same as --body in issue
+    // creation).
+    let mention_tags = tags_from_content(body, Some(git_repo_path)).await?;
+    tags.extend(mention_tags);
+    let tags = dedup_tags(tags);
+
+    let cover_note_event = ngit::client::sign_event(
+        EventBuilder::new(KIND_COVER_NOTE, body).tags(tags),
+        &signer,
+        format!("set {target_kind} cover note"),
+    )
+    .await?;
+
+    // Save to local cache immediately so subsequent reads reflect the new cover
+    // note.
+    save_event_in_local_cache(git_repo_path, &cover_note_event).await?;
+
+    let mut client = client;
+    client.set_signer(signer).await;
+
+    send_events(
+        &client,
+        Some(git_repo_path),
+        vec![cover_note_event],
+        user_ref.relays.write(),
+        repo_ref.relays.clone(),
+        true,
+        false,
+    )
+    .await?;
+
+    println!("{} {} cover note set", target_kind, &event_id.to_hex()[..8],);
+    Ok(())
+}
+
+pub async fn launch_issue_set_cover_note(id: &str, body: &str, offline: bool) -> Result<()> {
+    publish_set_cover_note_event(id, body, offline, "issue").await
+}
+
+pub async fn launch_pr_set_cover_note(id: &str, body: &str, offline: bool) -> Result<()> {
+    publish_set_cover_note_event(id, body, offline, "PR").await
+}