gn-cli 0.1.10

git-notes CLI — add, list, show, sync, resolve notes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use anyhow::{Context, Result};
use clap::Args;
use gn_core::namespace::Namespace;
use gn_core::note::{Note, NoteStatus};
use gn_core::NotesEngine;
use std::env;
use std::process::Command;

#[derive(Args, Debug)]
pub struct ImportPrArgs {
    /// Pull Request number
    #[arg(short, long)]
    pub pr: u64,

    /// GitHub Personal Access Token (defaults to GITHUB_TOKEN env var)
    #[arg(short, long)]
    pub token: Option<String>,

    /// Namespace to store imported comments (default: review)
    #[arg(short, long, default_value = "review")]
    pub namespace: String,
}

pub fn run(args: &ImportPrArgs) -> Result<()> {
    let token = args
        .token
        .clone()
        .or_else(|| env::var("GITHUB_TOKEN").ok())
        .context("GitHub token required. Provide via --token or GITHUB_TOKEN env var.")?;

    // Detect owner/repo from git remote
    let remote_out = Command::new("git")
        .args(["remote", "get-url", "origin"])
        .output()
        .context("Failed to get origin remote URL")?;

    let remote_str = String::from_utf8_lossy(&remote_out.stdout).trim().to_string();
    let (owner, repo) = parse_github_owner_repo(&remote_str)
        .context("Could not determine GitHub owner/repo from remote URL")?;

    println!("Importing review comments from {}/{} PR #{}...", owner, repo, args.pr);

    let url = format!(
        "https://api.github.com/repos/{}/{}/pulls/{}/comments",
        owner, repo, args.pr
    );

    let curl_output = Command::new("curl")
        .args([
            "-fsSL",
            "-H",
            &format!("Authorization: token {}", token),
            "-H",
            "Accept: application/vnd.github+json",
            "-H",
            "User-Agent: git-notes-cli",
            &url,
        ])
        .output()
        .context("Failed to run curl to fetch PR comments")?;

    if !curl_output.status.success() {
        let err = String::from_utf8_lossy(&curl_output.stderr);
        anyhow::bail!("GitHub API request failed: {}", err);
    }

    let comments: Vec<serde_json::Value> = serde_json::from_slice(&curl_output.stdout)
        .context("Failed to parse GitHub comments JSON")?;

    let engine = NotesEngine::new(".");
    let target_commit = match Command::new("git").args(["rev-parse", "HEAD"]).output() {
        Ok(out) => String::from_utf8_lossy(&out.stdout).trim().to_string(),
        Err(_) => "HEAD".to_string(),
    };

    let mut imported = 0;
    let ns = Namespace::from_str(&args.namespace);

    for c in &comments {
        let body = match c.get("body").and_then(|b| b.as_str()) {
            Some(b) => b.to_string(),
            None => continue,
        };

        let file = c.get("path").and_then(|p| p.as_str()).map(|s| s.to_string());
        let line = c.get("line").and_then(|l| l.as_u64()).map(|l| l as u32);
        let author = c
            .get("user")
            .and_then(|u| u.get("login"))
            .and_then(|l| l.as_str())
            .unwrap_or("unknown")
            .to_string();

        let mut note = Note::new(
            target_commit.clone(),
            file,
            line,
            line,
            body,
            author,
            ns.clone(),
        );
        note.status = NoteStatus::Open;

        if let Ok(_) = engine.write_note(&note) {
            imported += 1;
        }
    }

    println!(
        "\x1b[32m✔\x1b[0m Successfully imported {} review comment(s) into refs/notes/{}",
        imported, args.namespace
    );

    Ok(())
}

fn parse_github_owner_repo(remote: &str) -> Option<(String, String)> {
    let clean = remote
        .trim_end_matches(".git")
        .replace("git@github.com:", "")
        .replace("https://github.com/", "")
        .replace("http://github.com/", "");

    let parts: Vec<&str> = clean.split('/').collect();
    if parts.len() >= 2 {
        Some((parts[0].to_string(), parts[1].to_string()))
    } else {
        None
    }
}