use crate::forge::{Forge, ForgeReview};
use crate::types::{
FilePatch, ForgeError, Involvement, PrNumber, PrState, PrSummary, RepoId, Result,
ReviewComment, Verdict,
};
pub const SEARCH_FIELDS: &str = "number,title,author,state,isDraft,updatedAt,url,repository";
#[must_use]
pub fn search_argv(lane: Involvement, limit: usize) -> Vec<String> {
vec![
"search".into(),
"prs".into(),
lane.qualifier().into(),
"--state=open".into(),
"--limit".into(),
limit.to_string(),
"--json".into(),
SEARCH_FIELDS.into(),
]
}
#[must_use]
pub fn files_argv(repo: &RepoId, number: PrNumber) -> Vec<String> {
let mut endpoint = String::from("repos/");
endpoint.push_str(&repo.owner);
endpoint.push('/');
endpoint.push_str(&repo.name);
endpoint.push_str("/pulls/");
endpoint.push_str(&number.0.to_string());
endpoint.push_str("/files");
vec![
"api".into(),
endpoint,
"--paginate".into(),
"--slurp".into(),
]
}
#[must_use]
pub fn comments_argv(repo: &RepoId, number: PrNumber) -> Vec<String> {
let mut endpoint = String::from("repos/");
endpoint.push_str(&repo.owner);
endpoint.push('/');
endpoint.push_str(&repo.name);
endpoint.push_str("/pulls/");
endpoint.push_str(&number.0.to_string());
endpoint.push_str("/comments");
vec![
"api".into(),
endpoint,
"--paginate".into(),
"--slurp".into(),
]
}
#[must_use]
pub fn review_argv(repo: &RepoId, number: PrNumber, verdict: &Verdict) -> Vec<String> {
let mut slug = String::from(&repo.owner);
slug.push('/');
slug.push_str(&repo.name);
vec![
"pr".into(),
"review".into(),
number.0.to_string(),
"--repo".into(),
slug,
verdict.flag().into(),
"--body".into(),
verdict.body().into(),
]
}
fn state_from(state: &str, merged_hint: bool) -> PrState {
match state.to_ascii_uppercase().as_str() {
"MERGED" => PrState::Merged,
"CLOSED" if merged_hint => PrState::Merged,
"CLOSED" => PrState::Closed,
_ => PrState::Open,
}
}
fn str_at(v: &serde_json::Value, key: &str) -> String {
v.get(key).and_then(|x| x.as_str()).unwrap_or("").to_owned()
}
pub fn parse_search(raw: &str) -> Result<Vec<PrSummary>> {
let v: serde_json::Value = serde_json::from_str(raw).map_err(|e| ForgeError::Unparseable {
operation: "search",
raw: e.to_string(),
})?;
let arr = v.as_array().ok_or_else(|| ForgeError::Unparseable {
operation: "search",
raw: raw.chars().take(200).collect(),
})?;
let mut out = Vec::with_capacity(arr.len());
for row in arr {
let Some(number) = row.get("number").and_then(serde_json::Value::as_u64) else {
continue;
};
let Some(repo) = row
.get("repository")
.and_then(|r| r.get("nameWithOwner").or_else(|| r.get("name")))
.and_then(|x| x.as_str())
.and_then(|s| RepoId::parse(s).ok())
else {
continue;
};
out.push(PrSummary {
repo,
number: PrNumber(number),
title: str_at(row, "title"),
author: row
.get("author")
.and_then(|a| a.get("login"))
.and_then(|x| x.as_str())
.unwrap_or("")
.to_owned(),
state: state_from(&str_at(row, "state"), false),
draft: row
.get("isDraft")
.and_then(serde_json::Value::as_bool)
.unwrap_or(false),
updated_at: str_at(row, "updatedAt"),
url: str_at(row, "url"),
});
}
Ok(out)
}
pub fn parse_files(raw: &str) -> Result<Vec<FilePatch>> {
let rows = flatten_pages(raw, "files")?;
Ok(rows
.iter()
.filter_map(|row| {
let path = row.get("filename").and_then(|x| x.as_str())?.to_owned();
Some(FilePatch {
path,
previous_path: row
.get("previous_filename")
.and_then(|x| x.as_str())
.map(ToOwned::to_owned),
additions: row
.get("additions")
.and_then(serde_json::Value::as_u64)
.unwrap_or(0) as u32,
deletions: row
.get("deletions")
.and_then(serde_json::Value::as_u64)
.unwrap_or(0) as u32,
patch: row
.get("patch")
.and_then(|x| x.as_str())
.map(ToOwned::to_owned),
})
})
.collect())
}
pub fn parse_comments(raw: &str) -> Result<Vec<ReviewComment>> {
let rows = flatten_pages(raw, "comments")?;
Ok(rows
.iter()
.map(|row| ReviewComment {
author: row
.get("user")
.and_then(|u| u.get("login"))
.and_then(|x| x.as_str())
.unwrap_or("")
.to_owned(),
body: str_at(row, "body"),
path: row
.get("path")
.and_then(|x| x.as_str())
.map(ToOwned::to_owned),
line: row
.get("line")
.and_then(serde_json::Value::as_u64)
.map(|n| n as u32),
created_at: str_at(row, "created_at"),
})
.collect())
}
fn flatten_pages(raw: &str, operation: &'static str) -> Result<Vec<serde_json::Value>> {
let v: serde_json::Value = serde_json::from_str(raw).map_err(|e| ForgeError::Unparseable {
operation,
raw: e.to_string(),
})?;
let arr = v.as_array().ok_or_else(|| ForgeError::Unparseable {
operation,
raw: raw.chars().take(200).collect(),
})?;
let mut out = Vec::new();
for item in arr {
match item.as_array() {
Some(page) => out.extend(page.iter().cloned()),
None => out.push(item.clone()),
}
}
Ok(out)
}
pub trait GhRunner {
fn run(&self, args: &[String]) -> Result<String>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RealGh;
impl GhRunner for RealGh {
fn run(&self, args: &[String]) -> Result<String> {
let out = std::process::Command::new("gh")
.args(args)
.output()
.map_err(|e| ForgeError::Unreachable {
detail: e.to_string(),
})?;
if out.status.success() {
return String::from_utf8(out.stdout).map_err(|e| ForgeError::Unparseable {
operation: "gh",
raw: e.to_string(),
});
}
let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
if stderr.contains("gh auth login") || stderr.contains("authentication") {
return Err(ForgeError::NotAuthenticated { detail: stderr });
}
Err(ForgeError::Backend {
operation: "gh",
detail: stderr,
})
}
}
#[derive(Debug, Clone, Default)]
pub struct GhForge<R: GhRunner> {
runner: R,
}
impl<R: GhRunner> GhForge<R> {
pub const fn new(runner: R) -> Self {
Self { runner }
}
}
impl<R: GhRunner> Forge for GhForge<R> {
fn search(&self, lane: Involvement, limit: usize) -> Result<Vec<PrSummary>> {
parse_search(&self.runner.run(&search_argv(lane, limit))?)
}
fn pull_request(&self, repo: &RepoId, number: PrNumber) -> Result<PrSummary> {
let mut slug = String::from(&repo.owner);
slug.push('/');
slug.push_str(&repo.name);
let args = vec![
"pr".into(),
"view".into(),
number.0.to_string(),
"--repo".into(),
slug,
"--json".into(),
SEARCH_FIELDS.into(),
];
let raw = self.runner.run(&args)?;
let mut wrapped = String::from("[");
wrapped.push_str(&raw);
wrapped.push(']');
parse_search(&wrapped)?
.into_iter()
.next()
.ok_or_else(|| ForgeError::Unparseable {
operation: "pull_request",
raw: raw.chars().take(200).collect(),
})
}
fn files(&self, repo: &RepoId, number: PrNumber) -> Result<Vec<FilePatch>> {
parse_files(&self.runner.run(&files_argv(repo, number))?)
}
fn comments(&self, repo: &RepoId, number: PrNumber) -> Result<Vec<ReviewComment>> {
parse_comments(&self.runner.run(&comments_argv(repo, number))?)
}
}
impl<R: GhRunner> ForgeReview for GhForge<R> {
fn submit_review(&self, repo: &RepoId, number: PrNumber, verdict: &Verdict) -> Result<()> {
self.runner.run(&review_argv(repo, number, verdict))?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
#[derive(Default)]
struct ScriptedGh {
calls: RefCell<Vec<Vec<String>>>,
reply: String,
}
impl GhRunner for ScriptedGh {
fn run(&self, args: &[String]) -> Result<String> {
self.calls.borrow_mut().push(args.to_vec());
Ok(self.reply.clone())
}
}
#[test]
fn every_lane_produces_its_own_qualifier_in_argv() {
for lane in Involvement::all() {
let argv = search_argv(*lane, 5);
assert!(
argv.contains(&lane.qualifier().to_owned()),
"{lane:?} argv must carry its qualifier: {argv:?}"
);
assert!(argv.contains(&"5".to_owned()), "limit must reach argv");
}
}
#[test]
fn a_review_body_is_a_separate_argv_element_never_interpolated() {
let repo = RepoId::parse("pleme-io/metsuke").unwrap();
let nasty = "it's \"wrong\"; `rm -rf /`\nsecond line";
let argv = review_argv(&repo, PrNumber(7), &Verdict::Comment(nasty.into()));
assert!(
argv.iter().any(|a| a == nasty),
"the body must survive verbatim as ONE argument: {argv:?}"
);
assert!(argv.contains(&"--comment".to_owned()));
}
#[test]
fn each_verdict_lowers_to_its_own_flag() {
let repo = RepoId::parse("pleme-io/metsuke").unwrap();
let flags: Vec<String> = [
Verdict::Comment(String::new()),
Verdict::Approve(String::new()),
Verdict::RequestChanges(String::new()),
]
.iter()
.map(|v| review_argv(&repo, PrNumber(1), v)[5].clone())
.collect();
assert_eq!(flags, vec!["--comment", "--approve", "--request-changes"]);
}
const SEARCH_JSON: &str = r#"[
{"number":12,"title":"add the thing","author":{"login":"drzzln"},
"state":"OPEN","isDraft":false,"updatedAt":"2026-08-03T01:00:00Z",
"url":"https://github.com/pleme-io/metsuke/pull/12",
"repository":{"nameWithOwner":"pleme-io/metsuke"}},
{"number":13,"title":"draft work","author":{"login":"other"},
"state":"OPEN","isDraft":true,"updatedAt":"2026-08-02T01:00:00Z",
"url":"u","repository":{"nameWithOwner":"pleme-io/banken"}}
]"#;
#[test]
fn search_parses_into_typed_rows() {
let got = parse_search(SEARCH_JSON).unwrap();
assert_eq!(got.len(), 2);
assert_eq!(got[0].number, PrNumber(12));
assert_eq!(got[0].repo.to_string(), "pleme-io/metsuke");
assert_eq!(got[0].author, "drzzln");
assert!(!got[0].draft);
assert!(got[1].draft, "isDraft must survive the parse");
}
#[test]
fn a_row_with_no_determinable_repo_is_dropped_not_defaulted() {
let raw = r#"[{"number":1,"title":"t","repository":{}},
{"number":2,"title":"u","repository":{"nameWithOwner":"a/b"}}]"#;
let got = parse_search(raw).unwrap();
assert_eq!(
got.len(),
1,
"a PR whose coordinate is unknown must not be shown — every action on it \
would target the wrong repo"
);
assert_eq!(got[0].number, PrNumber(2));
}
#[test]
fn search_rejects_a_non_array_payload_loudly() {
let e = parse_search("{\"message\":\"Bad credentials\"}").unwrap_err();
assert!(matches!(e, ForgeError::Unparseable { .. }), "got {e:?}");
}
#[test]
fn files_parse_and_a_binary_file_has_no_patch() {
let raw = r#"[[
{"filename":"src/lib.rs","additions":10,"deletions":2,"patch":"@@ -1 +1 @@\n-a\n+b"},
{"filename":"logo.png","additions":0,"deletions":0},
{"filename":"new.rs","previous_filename":"old.rs","additions":1,"deletions":1,"patch":"@@"}
]]"#;
let got = parse_files(raw).unwrap();
assert_eq!(got.len(), 3, "--slurp's page-of-pages must be flattened");
assert_eq!(got[0].additions, 10);
assert!(got[0].patch.is_some());
assert!(
got[1].patch.is_none(),
"a binary file has NO patch — not an empty one"
);
assert_eq!(got[2].previous_path.as_deref(), Some("old.rs"));
}
#[test]
fn an_unpaginated_flat_array_parses_the_same_as_a_slurped_one() {
let flat = r#"[{"filename":"a.rs","additions":1,"deletions":0,"patch":"@@"}]"#;
let slurped = r#"[[{"filename":"a.rs","additions":1,"deletions":0,"patch":"@@"}]]"#;
assert_eq!(parse_files(flat).unwrap(), parse_files(slurped).unwrap());
}
#[test]
fn an_outdated_comment_keeps_its_null_line() {
let raw = r#"[{"user":{"login":"a"},"body":"stale note","path":"src/x.rs",
"line":null,"created_at":"2026-08-01T00:00:00Z"},
{"user":{"login":"b"},"body":"live note","path":"src/x.rs",
"line":42,"created_at":"2026-08-02T00:00:00Z"}]"#;
let got = parse_comments(raw).unwrap();
assert_eq!(got.len(), 2);
assert!(
got[0].line.is_none(),
"a null line means the anchor is gone; defaulting it to 0 would point \
the reader at the wrong place with no hint"
);
assert_eq!(got[1].line, Some(42));
}
#[test]
fn the_forge_calls_gh_with_the_argv_it_built() {
let gh = ScriptedGh {
reply: SEARCH_JSON.to_owned(),
..Default::default()
};
let forge = GhForge::new(gh);
let got = forge.search(Involvement::ReviewRequested, 25).unwrap();
assert_eq!(got.len(), 2);
let calls = forge.runner.calls.borrow();
assert_eq!(calls.len(), 1);
assert_eq!(calls[0], search_argv(Involvement::ReviewRequested, 25));
}
}