Machine interface for editors (spec 0.8b): oxy root, cat, version, hunks, discard by path or hunk; --json on log (with --path), show, diff, resolve, op log, bookmark list, remote list, fetch, pull, push, submodule status, bisect status, verify, policy show; commit --hunks; integration test over every JSON command c6aa5bd9d1c8

//! Tiny JSON building for `--json` outputs: one document on stdout,

//! nothing else, with string escaping shared with the hooks payloads.

pub use oxy_core::repo::{json_array as arr, json_str as s};

pub fn obj<I: IntoIterator<Item = (&'static str, String)>>(pairs: I) -> String {

    let inner: Vec<String> = pairs.into_iter().map(|(k, v)| format!("{}:{v}", s(k))).collect();

    format!("{{{}}}", inner.join(","))

}

pub fn b(v: bool) -> String {

    v.to_string()

}

pub fn n<T: std::fmt::Display>(v: T) -> String {

    v.to_string()

}

pub fn opt<T>(v: Option<T>, f: impl Fn(T) -> String) -> String {

    match v {

        Some(x) => f(x),

        None => "null".into(),

    }

}

pub fn hashes(v: &[oxy_core::hash::ChangeHash]) -> String {

    arr(v.iter().map(|h| s(&h.to_hex())))

}

//! Every `--json` output of the CLI parses as JSON and carries the fields

//! the VS Code extension relies on (oxygen-vscode/docs/spec.md section 4).

use serde_json::Value;

use std::path::Path;

use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (i32, Vec<u8>, String) {

    let out = Command::new(env!("CARGO_BIN_EXE_oxy")).arg("--plain").args(args).current_dir(dir).env("OXY_HOME", home).env("NO_COLOR", "1").output().unwrap();

    (out.status.code().unwrap_or(-1), out.stdout, String::from_utf8_lossy(&out.stderr).to_string())

}

fn json(dir: &Path, home: &Path, args: &[&str]) -> Value {

    let (code, out, err) = oxy(dir, home, args);

    assert!(code == 0 || code == 2 || code == 1, "oxy {args:?} exited {code}: {err}");

    serde_json::from_slice(&out).unwrap_or_else(|e| panic!("oxy {args:?} is not JSON: {e}\n{}", String::from_utf8_lossy(&out)))

}

fn write(dir: &Path, rel: &str, content: &str) {

    let p = dir.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

#[test]

fn machine_interface_round_trips() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let origin = tmp.path().join("origin");

    assert_eq!(oxy(tmp.path(), &home, &["init", origin.to_str().unwrap()]).0, 0);

    let repo = tmp.path().join("repo");

    assert_eq!(oxy(tmp.path(), &home, &["clone", origin.to_str().unwrap(), repo.to_str().unwrap()]).0, 0);

    let r = repo.as_path();

    assert_eq!(oxy(r, &home, &["identity", "create", "--name", "Ada", "--email", "[email protected]"]).0, 0);

    assert_eq!(oxy(r, &home, &["config", "--user", "core.sign", "change"]).0, 0);

    let v = json(r, &home, &["version", "--json"]);

    assert_eq!(v["protocol"], 1);

    let root = json(r, &home, &["root", "--json"]);

    assert_eq!(root["bookmark"], "main");

    assert!(root["root"].as_str().unwrap().ends_with("repo"));

    write(r, "a.txt", "1\n2\n3\n");

    write(r, "b.txt", "b\n");

    let st = json(r, &home, &["status", "--json"]);

    assert_eq!(st["paths"].as_array().unwrap().len(), 2);

    assert_eq!(oxy(r, &home, &["commit", "-m", "base"]).0, 0);

    write(r, "a.txt", "0\n1\n2\n3\n");

    write(r, "b.txt", "b\nbb\n");

    write(r, "c.txt", "c\n");

    // diff and hunks agree on the working copy.

    let d = json(r, &home, &["diff", "--json"]);

    let files = d["files"].as_array().unwrap();

    assert_eq!(files.len(), 3, "{d}");

    let a = files.iter().find(|f| f["path"] == "a.txt").unwrap();

    assert_eq!(a["kind"], "modified");

    assert_eq!(a["hunks"][0]["base_line"], 0);

    assert_eq!(a["hunks"][0]["added"][0], "0\n");

    let c = files.iter().find(|f| f["path"] == "c.txt").unwrap();

    assert_eq!(c["kind"], "added");

    let hunks = json(r, &home, &["hunks", "--json"]);

    let hunks = hunks.as_array().unwrap();

    assert!(hunks.len() >= 3, "{hunks:?}");

    let b_hunk = hunks.iter().find(|h| h["path"] == "b.txt").unwrap()["index"].as_u64().unwrap();

    // Commit only b's hunk; discard c by path; then discard a's remaining hunk.

    assert_eq!(oxy(r, &home, &["commit", "-m", "b only", "--hunks", &b_hunk.to_string()]).0, 0);

    assert_eq!(oxy(r, &home, &["discard", "c.txt"]).0, 0);

    assert!(!r.join("c.txt").exists());

    let hunks = json(r, &home, &["hunks", "--json"]);

    let a_hunk = hunks.as_array().unwrap().iter().find(|h| h["path"] == "a.txt").unwrap()["index"].as_u64().unwrap();

    assert_eq!(oxy(r, &home, &["discard", "--hunks", &a_hunk.to_string()]).0, 0);

    assert_eq!(std::fs::read_to_string(r.join("a.txt")).unwrap(), "1\n2\n3\n");

    let st = json(r, &home, &["status", "--json"]);

    assert_eq!(st["clean"], true, "{st}");

    // cat serves file content at states.

    let (code, out, _) = oxy(r, &home, &["cat", "b.txt"]);

    assert_eq!((code, out.as_slice()), (0, b"b\nbb\n".as_slice()));

    let (code, out, _) = oxy(r, &home, &["cat", "b.txt", "-r", "main"]);

    assert_eq!((code, out.as_slice()), (0, b"b\nbb\n".as_slice()));

    // log, show, verify, op log, bookmarks, remotes, sync.

    let log = json(r, &home, &["log", "--json"]);

    let changes = log["changes"].as_array().unwrap();

    assert_eq!(changes.len(), 3, "working copy plus two changes: {log}");

    let head = changes.iter().find(|c| c["message"] == "b only").unwrap();

    assert_eq!(head["signature"]["status"], "signed");

    assert_eq!(head["author"], "Ada");

    let hash = head["hash"].as_str().unwrap().to_string();

    let by_path = json(r, &home, &["log", "--json", "--path", "b.txt"]);

    assert_eq!(by_path["changes"].as_array().unwrap().len(), 2, "{by_path}");

    let show = json(r, &home, &["show", "--json", &format!("#{}", &hash[..12])]);

    assert_eq!(show["files"][0]["path"], "b.txt");

    let verify = json(r, &home, &["verify", "--json"]);

    assert!(verify.as_array().unwrap().iter().all(|v| v["status"] == "signed"));

    let ops = json(r, &home, &["op", "log", "--json"]);

    assert!(ops[0]["current"] == true && ops.as_array().unwrap().len() > 3);

    assert_eq!(oxy(r, &home, &["bookmark", "create", "feature"]).0, 0);

    let bms = json(r, &home, &["bookmark", "list", "--json"]);

    assert_eq!(bms.as_array().unwrap().iter().map(|b| b["name"].as_str().unwrap()).collect::<Vec<_>>(), vec!["feature", "main"]);

    let remotes = json(r, &home, &["remote", "list", "--json"]);

    assert_eq!(remotes[0]["name"], "origin");

    let push = json(r, &home, &["push", "--json"]);

    assert_eq!(push[0]["ok"], true, "{push}");

    let fetch = json(r, &home, &["fetch", "--json"]);

    assert_eq!(fetch["remote"], "origin");

    let pull = json(r, &home, &["pull", "--json"]);

    assert_eq!(pull["changed"], false);

    assert_eq!(json(r, &home, &["resolve", "--json"])["conflicted"], false);

    assert!(json(r, &home, &["submodule", "status", "--json"]).as_array().unwrap().is_empty());

    assert!(json(r, &home, &["bisect", "status", "--json"]).is_null());

    assert!(json(r, &home, &["policy", "show", "--json"]).is_null());

    assert_eq!(oxy(r, &home, &["policy", "init"]).0, 0);

    let policy = json(r, &home, &["policy", "show", "--json"]);

    assert_eq!(policy["roots"][0]["name"], "Ada");

}

 "serde_json",

serde_json = "1"

    pub(crate) fn write_file(&self, rel: &str, bytes: &[u8], exec: bool) -> Result<()> {

    pub(crate) fn write_symlink(&self, rel: &str, target: &[u8]) -> Result<()> {

pub use snapshot::{added_node_paths, diff_files_of, has_conflict_markers, is_binary, referenced_changes, render_change, render_hunks, similarity, ChangeStatus, DiffHunk, FileDiff, Hunk, PathStatus, Selection, SnapshotResult};

/// One file's part of a diff, for `oxy diff --json`.

#[derive(Clone, Debug)]

pub struct FileDiff {

    pub path: String,

    /// `added`, `removed`, `modified`, `renamed`, `mode`, `replaced`.

    pub kind: String,

    pub hunks: Vec<DiffHunk>,

    /// For renames, the previous path.

    pub from: Option<String>,

}

/// Lines inserted after `base_line` (0 = before the first line) and lines

/// removed, with their base line numbers.

#[derive(Clone, Debug, Default)]

pub struct DiffHunk {

    pub base_line: u32,

    pub added: Vec<Vec<u8>>,

    pub removed: Vec<(u32, Vec<u8>)>,

}

impl Repo {

    /// The content of `path` in a state: `heads`, or the working copy's base.

    pub fn file_at(&self, path: &str, heads: Option<&[ChangeHash]>) -> Result<Vec<u8>> {

        let snapshot = match heads {

            Some(h) => self.load_state(h)?.materialize(),

            None => {

                let (_, wc) = self.working_copy()?;

                self.load_state(&wc.deps)?.materialize()

            }

        };

        let Some(f) = snapshot.files.get(path) else { return fail(format!("{path} is not in that state")) };

        match &f.content {

            FileContent::Dir => fail(format!("{path} is a directory")),

            FileContent::Text { bytes, .. } => Ok(bytes.clone()),

            FileContent::Opaque { blobs } => match blobs.first() {

                Some(b) => self.read_blob(b),

                None => Ok(vec![]),

            },

        }

    }

    /// Restore `paths` (files or directories) to the working copy's base:

    /// edits are undone, additions removed, removals put back. Returns the

    /// number of paths touched.

    pub fn discard(&self, paths: &[String]) -> Result<usize> {

        let snap = self.snapshot("oxy discard")?;

        let under = |p: &str| paths.iter().any(|x| p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/'))));

        let attrs = Repo::state_attributes(&snap.base_snapshot);

        let mut n = 0;

        for s in &snap.statuses {

            if !under(&s.path) {

                continue;

            }

            match snap.base_snapshot.files.get(&s.path) {

                None => {

                    // Added (or the new name of a rename): remove it.

                    let full = self.root.join(&s.path);

                    if full.is_dir() {

                        let _ = fs::remove_dir_all(&full);

                    } else {

                        let _ = fs::remove_file(&full);

                    }

                    n += 1;

                }

                Some(f) => {

                    match &f.content {

                        FileContent::Dir => fs::create_dir_all(self.root.join(&s.path))?,

                        FileContent::Text { bytes, .. } => {

                            let on_disk: std::borrow::Cow<[u8]> = if attrs.lookup(&s.path).eol == Some(crate::attributes::Eol::Crlf) { crate::attributes::to_crlf(bytes).into() } else { bytes.as_slice().into() };

                            self.write_file(&s.path, &on_disk, f.mode.exec)?;

                        }

                        FileContent::Opaque { blobs } => {

                            let bytes = match blobs.first() {

                                Some(b) => self.read_blob(b)?,

                                None => vec![],

                            };

                            if f.kind == NodeKind::Symlink {

                                self.write_symlink(&s.path, &bytes)?;

                            } else if f.kind == NodeKind::File {

                                self.write_file(&s.path, &bytes, f.mode.exec)?;

                            }

                        }

                    }

                    n += 1;

                }

            }

        }

        // A rename's old name is not in the statuses; put it back too.

        for (p, f) in &snap.base_snapshot.files {

            if under(p) && !self.root.join(p).exists() && f.kind != NodeKind::Dir && f.kind != NodeKind::Subrepo && !snap.statuses.iter().any(|s| s.path == *p) {

                let bytes = match &f.content {

                    FileContent::Text { bytes, .. } => bytes.clone(),

                    FileContent::Opaque { blobs } => blobs.first().map(|b| self.read_blob(b)).transpose()?.unwrap_or_default(),

                    FileContent::Dir => continue,

                };

                if f.kind == NodeKind::Symlink { self.write_symlink(p, &bytes)? } else { self.write_file(p, &bytes, f.mode.exec)? }

                n += 1;

            }

        }

        self.drop_manifest();

        Ok(n)

    }

    /// Undo the working-copy hunks `indices` (as `hunks` numbers them) on

    /// disk, keeping the others: the files are rewritten from the base plus

    /// the remaining hunks.

    pub fn discard_hunks(&self, indices: &[usize]) -> Result<usize> {

        let (snap, hunks) = self.hunks()?;

        let keep: Vec<usize> = hunks.iter().map(|h| h.index).filter(|i| !indices.contains(i)).collect();

        let (ops, edits) = select_hunks(&snap.wc, &keep);

        let dropped_nodes: BTreeSet<NodeId> = hunks

            .iter()

            .filter(|h| indices.contains(&h.index))

            .map(|h| if h.index < snap.wc.tree_ops.len() { snap.wc.tree_ops[h.index].node() } else { snap.wc.edits[h.index - snap.wc.tree_ops.len()].node() })

            .collect();

        let mut partial = snap.wc.clone();

        partial.tree_ops = ops;

        partial.edits = edits;

        partial.normalize();

        let mut st = snap.base.clone();

        st.add_unchecked(partial);

        let target = st.materialize();

        let by_node_target = target.tree.by_node();

        let by_node_base = snap.base_snapshot.tree.by_node();

        let attrs = Repo::state_attributes(&target);

        let mut n = 0;

        for node in dropped_nodes {

            match by_node_target.get(&node) {

                Some(e) => {

                    let f = &target.files[&e.path];

                    match &f.content {

                        FileContent::Dir => {}

                        FileContent::Text { bytes, .. } => {

                            let on_disk: std::borrow::Cow<[u8]> = if attrs.lookup(&e.path).eol == Some(crate::attributes::Eol::Crlf) { crate::attributes::to_crlf(bytes).into() } else { bytes.as_slice().into() };

                            self.write_file(&e.path, &on_disk, f.mode.exec)?;

                        }

                        FileContent::Opaque { blobs } => {

                            let bytes = blobs.first().map(|b| self.read_blob(b)).transpose()?.unwrap_or_default();

                            if f.kind == NodeKind::Symlink { self.write_symlink(&e.path, &bytes)? } else { self.write_file(&e.path, &bytes, f.mode.exec)? }

                        }

                    }

                    // A discarded rename: the new name goes.

                    if let Some(old_path) = snap.statuses.iter().find(|s| s.status == ChangeStatus::Renamed && !target.files.contains_key(&s.path)).map(|s| s.path.clone()) {

                        let _ = fs::remove_file(self.root.join(old_path));

                    }

                    n += 1;

                }

                None => {

                    // The node exists in neither target nor base with a live path: an addition to remove.

                    if let Some(added) = snap.statuses.iter().find(|s| s.status == ChangeStatus::Added && !target.files.contains_key(&s.path) && !by_node_base.contains_key(&node)) {

                        let full = self.root.join(&added.path);

                        if full.is_dir() { let _ = fs::remove_dir_all(&full); } else { let _ = fs::remove_file(&full); }

                        n += 1;

                    }

                }

            }

        }

        self.drop_manifest();

        Ok(n)

    }

    /// The diff of the working copy (`None`) or of a change, per file with

    /// line-numbered hunks (spec: `oxy diff --json`).

    pub fn diff_files(&self, change: Option<&ChangeHash>) -> Result<Vec<FileDiff>> {

        let (c, base) = match change {

            Some(h) => {

                let c = self.store.get_change(h)?;

                let base = self.load_state(&c.deps)?;

                (c, base)

            }

            None => {

                let snap = self.snapshot("oxy diff")?;

                (snap.wc, snap.base)

            }

        };

        let base_snapshot = base.materialize();

        Ok(diff_files_of(&c, &base, &base_snapshot))

    }

    /// The log restricted to changes touching `path` (its node, so renames

    /// are followed), on the current bookmark.

    pub fn log_for_path(&self, path: &str) -> Result<Vec<LogEntry>> {

        let entries = self.log()?;

        let (_, wc) = self.working_copy()?;

        let base_snapshot = self.load_state(&wc.deps)?.materialize();

        let heads = self.bookmark_heads()?;

        let state_snapshot = self.load_state(&heads)?.materialize();

        let node = base_snapshot.files.get(path).or_else(|| state_snapshot.files.get(path)).map(|f| f.node);

        let Some(node) = node else { return fail(format!("{path} is not tracked")) };

        let mut out = Vec::new();

        for e in entries {

            let Ok(c) = self.store.get_change(&e.hash) else { continue };

            if c.tree_ops.iter().any(|o| o.node() == node) || c.edits.iter().any(|x| x.node() == node) {

                out.push(e);

            }

        }

        Ok(out)

    }

}

/// Per-file hunks of `change` against `base`.

pub fn diff_files_of(change: &Change, base: &State, base_snapshot: &Snapshot) -> Vec<FileDiff> {

    let by_node = base_snapshot.tree.by_node();

    let mut new_names: HashMap<NodeId, (NodeId, String, NodeKind)> = HashMap::new();

    for op in &change.tree_ops {

        if let TreeOp::AddNode { node, parent, name, kind, .. } = op {

            new_names.insert(*node, (*parent, name.clone(), *kind));

        }

    }

    let path_of = |n: &NodeId| -> String { path_of_node(n, &by_node, &new_names).unwrap_or_else(|| format!("<node {}>", n.short(8))) };

    let mut files: BTreeMap<NodeId, FileDiff> = BTreeMap::new();

    let mut order: Vec<NodeId> = Vec::new();

    let mut entry = |files: &mut BTreeMap<NodeId, FileDiff>, n: NodeId, kind: &str| {

        if let std::collections::btree_map::Entry::Vacant(v) = files.entry(n) {

            order.push(n);

            v.insert(FileDiff { path: path_of(&n), kind: kind.to_string(), hunks: vec![], from: None });

        }

    };

    for op in &change.tree_ops {

        match op {

            TreeOp::AddNode { node, kind, .. } => {

                if *kind != NodeKind::Dir {

                    entry(&mut files, *node, "added");

                }

            }

            TreeOp::RemoveNode { node, .. } => {

                entry(&mut files, *node, "removed");

                if let Some(e) = by_node.get(node) {

                    files.get_mut(node).unwrap().path = e.path.clone();

                }

            }

            TreeOp::Move { node, parent, name, .. } => {

                entry(&mut files, *node, "renamed");

                let f = files.get_mut(node).unwrap();

                f.from = by_node.get(node).map(|e| e.path.clone());

                let dir = if parent.is_root() { String::new() } else { path_of_node(parent, &by_node, &new_names).unwrap_or_default() };

                f.path = if dir.is_empty() { name.clone() } else { format!("{dir}/{name}") };

            }

            TreeOp::SetMode { node, .. } => entry(&mut files, *node, "mode"),

        }

    }

    // Base line numbers per node, 1-based.

    let mut line_of: HashMap<NodeId, HashMap<(ChangeHash, u32), u32>> = HashMap::new();

    let mut lines_for = |n: &NodeId| -> HashMap<(ChangeHash, u32), u32> {

        line_of.entry(*n).or_insert_with(|| base.live_lines(n).into_iter().enumerate().map(|(i, (k, _))| (k, i as u32 + 1)).collect()).clone()

    };

    for e in &change.edits {

        let n = e.node();

        let is_new = new_names.contains_key(&n);

        entry(&mut files, n, if is_new { "added" } else { "modified" });

        let f = files.get_mut(&n).unwrap();

        match e {

            Edit::Insert { after, lines, .. } => {

                let map = lines_for(&n);

                let base_line = match after {

                    AtomRef::Start => 0,

                    AtomRef::End => map.len() as u32,

                    AtomRef::Atom { change, index } if change.is_zero() => f.hunks.last().map(|h| h.base_line).unwrap_or(0),

                    AtomRef::Atom { change, index } => map.get(&(*change, *index)).copied().unwrap_or(0),

                };

                f.hunks.push(DiffHunk { base_line, added: lines.clone(), removed: vec![] });

            }

            Edit::Delete { atoms, .. } => {

                let map = lines_for(&n);

                let mut removed = Vec::new();

                for r in atoms {

                    for i in r.from..r.to {

                        let line = map.get(&(r.change, i)).copied().unwrap_or(0);

                        let text = base.file(&n).and_then(|g| g.content(&(r.change, i))).unwrap_or(b"").to_vec();

                        removed.push((line, text));

                    }

                }

                let base_line = removed.first().map(|(l, _)| l.saturating_sub(1)).unwrap_or(0);

                f.hunks.push(DiffHunk { base_line, added: vec![], removed });

            }

            Edit::Replace { .. } => {

                if !is_new {

                    f.kind = "replaced".into();

                }

            }

        }

    }

    order.into_iter().filter_map(|n| files.remove(&n)).collect()

}

## 17a. Scripting and editors

Every reporting command takes `--json` (`status`, `log --path`, `show`,

`diff`, `hunks`, `blame`, `resolve`, `op log`, `bookmark list`, `remote list`,

`fetch`, `pull`, `push`, `submodule status`, `bisect status`, `verify`,

`policy show`, `root`, `version`). `oxy cat PATH -r CHANGE` prints a file as

it was, `oxy discard PATH..` restores files to the base, and `oxy hunks`

numbers the working copy's hunks for `commit --hunks` and `discard --hunks`.

## Phase 3 (2026-09-27): machine interface for the VS Code extension (oxygen-vscode/docs/spec.md section 4)

- [x] `oxy root`, `oxy cat PATH [-r CHANGE]`, `oxy version --json`, `oxy discard PATH.. | --hunks N,M`.

- [x] JSON outputs: `log --json [--path P] [--bookmark B]`, `show --json`, `diff --json [CHANGE]`, `hunks --json`, `commit --hunks`, `bookmark list --json`, `op log --json`, `resolve --json`, `submodule status --json`, `bisect status --json`, `verify --json`, `policy show --json`, `remote list --json`, `fetch|pull|push --json`.

- [x] An integration test that runs every JSON command against a scratch repository and parses each output.

- [x] Spec §24 and the guide mention the machine interface; `docs/protocol.md` gets a pointer.

## 4.4 Editors and tools on the same machine

A tool that drives a local repository does not speak this protocol; it runs

`oxy` with `--json` (spec §24) and reads one JSON document per command. The

VS Code extension in `oxygen-vscode/docs/spec.md` §4 lists the commands it

relies on.

| **Status** | Draft 0.8b |

oxy root                            oxy cat PATH [-r CHANGE]     oxy version

oxy hunks                           oxy discard PATH.. | --hunks N,M

**Machine interface.** `status`, `log` (with `--path`), `show`, `diff`, `hunks`, `blame`, `resolve`, `op log`, `bookmark list`, `remote list`, `fetch`, `pull`, `push`, `submodule status`, `bisect status`, `verify`, `policy show`, `root` and `version` take `--json` and then print exactly one JSON document on stdout, with ids as hex strings and times in milliseconds since the epoch; errors go to stderr with a non-zero status. `commit --hunks N,M` and `discard --hunks N,M` take hunk numbers as `hunks` prints them. Editors and other tools MUST use these rather than reading `.oxy/`.

*Changelog.* Draft 0.8b (2026-09-27): the machine interface for editors (§24): `root`, `cat`, `version`, `hunks`, `discard`, and `--json` on the reporting commands.

Draft 0.8a (2026-09-27): every Draft 0.8 addition is implemented in the reference implementation (§26.1). Clarifications from doing so: an unregistered nested repository is left alone and a tracked subrepo whose directory is absent keeps its pin (§7.8); Oxygen pins are omitted from Git export (§23).

use super::json;

use oxy_core::repo::{self, IdentityScope, PolicyUpdate, Repo, Rotation, SignatureStatus};

pub fn verify(change: Option<&str>, as_json: bool) -> Result<i32> {

    if as_json {

        let mut items = Vec::new();

        for h in &hashes {

            let Ok(c) = repo.store().get_change(h) else { continue };

            let (status, key, name, revoked, reason) = match repo.authenticate_change(h)? {

                SignatureStatus::Unsigned => ("unsigned", None, None, false, None),

                SignatureStatus::Valid { key, name, sealed, revoked, .. } => (if sealed { "sealed" } else { "signed" }, Some(key.to_hex()), Some(name), revoked, None),

                SignatureStatus::Invalid(why) => {

                    bad += 1;

                    ("invalid", None, None, false, Some(why))

                }

            };

            items.push(json::obj([

                ("hash", json::s(&h.to_hex())),

                ("change_id", json::s(&c.change_id.to_hex())),

                ("status", json::s(status)),

                ("key", json::opt(key.as_deref(), json::s)),

                ("name", json::opt(name.as_deref(), json::s)),

                ("revoked", json::b(revoked)),

                ("reason", json::opt(reason.as_deref(), json::s)),

            ]));

        }

        println!("{}", json::arr(items));

        return Ok(if bad > 0 { 1 } else { 0 });

    }

pub fn policy_show(as_json: bool) -> Result<i32> {

        if as_json {

            println!("null");

        } else {

            println!("No policy: this repository is unverified. Run `oxy policy init` to create one.");

        }

    if as_json {

        let ident = |k: &oxy_core::hash::KeyId| {

            let (name, email) = p.identity(k).map(|i| (i.name.clone(), i.email.clone())).unwrap_or_default();

            json::obj([("key", json::s(&k.to_hex())), ("name", json::s(&name)), ("email", json::s(&email))])

        };

        println!(

            "{}",

            json::obj([

                ("hash", json::s(&r.to_hex())),

                ("serial", json::n(p.serial)),

                ("expires_ms", json::n(p.expires)),

                ("expired", json::b(p.is_expired(oxy_core::objects::Hlc::now().wall_ms))),

                ("root_threshold", json::n(p.root_threshold)),

                ("roots", json::arr(p.roots.iter().map(ident))),

                (

                    "rules",

                    json::arr(p.rules.iter().map(|rule| {

                        json::obj([

                            ("pattern", json::s(&rule.pattern)),

                            ("keys", json::arr(rule.keys.iter().map(ident))),

                            ("threshold", json::n(rule.threshold)),

                            ("require", json::s(rule.require.name())),

                            ("allow_conflicts", json::b(rule.allow_conflicts)),

                        ])

                    })),

                ),

                ("revoked", json::arr(p.revoked.iter().map(ident))),

            ])

        );

        return Ok(0);

    }

mod json;

        /// Commit these hunks (as `oxy hunks` numbers them), comma separated

        #[arg(long, value_delimiter = ',')]

        hunks: Vec<usize>,

        /// Only changes touching this path (renames followed)

        #[arg(long)]

        path: Option<String>,

        #[arg(long)]

        json: bool,

    Diff {

        /// A change instead of the working copy

        change: Option<String>,

        #[arg(long)]

        json: bool,

    },

    /// Print a file as it is in a state (default: the working copy's base)

    Cat {

        path: String,

        /// A change, bookmark, or tag

        #[arg(short = 'r', long)]

        change: Option<String>,

    },

    /// Print the repository root, workspace, and bookmark

    Root {

        #[arg(long)]

        json: bool,

    },

    /// Print the version of oxy, its repository format, and protocol

    Version {

        #[arg(long)]

        json: bool,

    },

    /// Restore paths to the working copy's base, or undo chosen hunks

    Discard {

        paths: Vec<String>,

        /// Hunk indices as `oxy hunks` numbers them, comma separated

        #[arg(long, value_delimiter = ',')]

        hunks: Vec<usize>,

    },

    /// List the working copy's hunks, numbered as commit --hunks expects

    Hunks {

        #[arg(long)]

        json: bool,

    },

    Show {

        change: String,

        #[arg(long)]

        json: bool,

    },

    Resolve {

        #[arg(long)]

        json: bool,

    },

    Fetch {

        remote: Option<String>,

        #[arg(long)]

        json: bool,

    },

    Pull {

        remote: Option<String>,

        #[arg(long)]

        json: bool,

    },

        #[arg(long)]

        json: bool,

    Verify {

        change: Option<String>,

        #[arg(long)]

        json: bool,

    },

    Log {

        #[arg(long)]

        json: bool,

    },

    Status {

        #[arg(long)]

        json: bool,

    },

    List {

        #[arg(long)]

        json: bool,

    },

    Status {

        #[arg(long)]

        json: bool,

    },

    List {

        #[arg(long)]

        json: bool,

    },

    Show {

        #[arg(long)]

        json: bool,

    },

        Cmd::Commit { message, depends_on, paths, interactive, hunks } => workspace::commit(&message, &depends_on, &paths, interactive, &hunks),

        Cmd::Cat { path, change } => workspace::cat(&path, change.as_deref()),

        Cmd::Root { json } => workspace::root(json),

        Cmd::Version { json } => workspace::version(json),

        Cmd::Discard { paths, hunks } => workspace::discard(&paths, &hunks),

        Cmd::Hunks { json } => workspace::hunks(json),

            BisectCmd::Status { json } => workspace::bisect_status(json),

        Cmd::Log { limit, verbose, path, json } => workspace::log(limit, verbose, path.as_deref(), json),

        Cmd::Diff { change, json } => workspace::diff(change.as_deref(), json),

        Cmd::Show { change, json } => workspace::show(&change, json),

        Cmd::Resolve { json } => workspace::resolve(json),

        Cmd::Op { cmd: OpCmd::Log { json } } => workspace::op_log(json),

            BookmarkCmd::List { json } => workspace::bookmark_list(json),

            SubmoduleCmd::Status { json } => sync::submodule_status(json),

            RemoteCmd::List { json } => sync::remote_list(json),

        Cmd::Fetch { remote, json } => sync::fetch(remote.as_deref(), json),

        Cmd::Pull { remote, json } => sync::pull(remote.as_deref(), json),

        Cmd::Push { remote, force, bookmark, json } => sync::push(remote.as_deref(), force, bookmark.as_deref(), json),

            PolicyCmd::Show { json } => identity::policy_show(json),

        Cmd::Verify { change, json } => identity::verify(change.as_deref(), json),

use super::json;

pub fn remote_list(as_json: bool) -> Result<i32> {

    if as_json {

        let items = repo.config.remotes.iter().map(|(name, url)| {

            let bms = view.remotes.get(name).map(|b| {

                json::arr(b.iter().map(|(bm, st)| {

                    let heads = repo.store().get_state(st).map(|s| s.heads).unwrap_or_default();

                    json::obj([("name", json::s(bm)), ("heads", json::hashes(&heads))])

                }))

            });

            json::obj([("name", json::s(name)), ("url", json::s(url)), ("bookmarks", bms.unwrap_or_else(|| "[]".into()))])

        });

        println!("{}", json::arr(items));

        return Ok(0);

    }

pub fn fetch(remote: Option<&str>, as_json: bool) -> Result<i32> {

    if as_json {

        println!(

            "{}",

            json::obj([

                ("remote", json::s(&remote)),

                ("refs", json::arr(report.refs.iter().map(|(name, heads, n)| json::obj([("name", json::s(name)), ("heads", json::hashes(heads)), ("new", json::n(*n))])))),

                ("new_tags", json::n(report.new_tags)),

                ("unverified", json::b(report.unverified)),

            ])

        );

        return Ok(0);

    }

pub fn pull(remote: Option<&str>, as_json: bool) -> Result<i32> {

    if as_json {

        sp.clear();

        let conflicted = repo.snapshot("oxy pull")?.base_snapshot.is_conflicted();

        println!("{}", json::obj([("remote", json::s(&remote)), ("heads", json::hashes(&r.heads)), ("changed", json::b(r.changed)), ("checked_out", json::b(r.checked_out)), ("conflicted", json::b(conflicted))]));

        return Ok(0);

    }

pub fn push(remote: Option<&str>, force: bool, bookmark: Option<&str>, as_json: bool) -> Result<i32> {

    if as_json {

        println!("{}", json::arr(results.iter().map(|r| json::obj([("name", json::s(&r.name)), ("ok", json::b(r.ok)), ("reason", json::s(&r.reason))]))));

        return Ok(if results.iter().all(|r| r.ok) { 0 } else { 1 });

    }

fn pin_json(p: &oxy_core::subrepo::Pin) -> String {

    match p {

        oxy_core::subrepo::Pin::Oxy { repo, heads, bookmark } => json::obj([("kind", json::s("oxy")), ("repo", json::s(&repo.iter().map(|b| format!("{b:02x}")).collect::<String>())), ("heads", json::hashes(heads)), ("bookmark", json::s(bookmark))]),

        oxy_core::subrepo::Pin::Git { sha, branch } => json::obj([("kind", json::s("git")), ("sha", json::s(sha)), ("branch", json::s(branch))]),

    }

}

pub fn submodule_status(as_json: bool) -> Result<i32> {

    if as_json {

        println!(

            "{}",

            json::arr(subs.iter().map(|s| {

                json::obj([

                    ("path", json::s(&s.path)),

                    ("pin", pin_json(&s.pin)),

                    ("actual", json::opt(s.actual.as_ref(), pin_json)),

                    ("at_pin", json::b(s.actual.as_ref() == Some(&s.pin))),

                    ("dirty", json::b(s.dirty)),

                    ("url", json::opt(s.url.as_deref(), json::s)),

                ])

            }))

        );

        return Ok(0);

    }

use super::json;

use oxy_core::repo::SignatureStatus;

pub fn commit(message: &str, depends_on: &[String], paths: &[String], interactive: bool, hunks: &[usize]) -> Result<i32> {

    let selection = if !hunks.is_empty() {

        oxy_core::repo::Selection::Hunks(hunks.to_vec())

    } else if interactive {

pub fn bisect_status(as_json: bool) -> Result<i32> {

    if as_json {

        use oxy_core::repo::BisectStep::*;

        let v = match repo.bisect_status()? {

            None => "null".to_string(),

            Some(NeedMarks { good, bad }) => json::obj([("state", json::s("need-marks")), ("good", json::n(good)), ("bad", json::n(bad))]),

            Some(Testing { heads, remaining, steps_left }) => json::obj([("state", json::s("testing")), ("heads", json::hashes(&heads)), ("remaining", json::n(remaining)), ("steps_left", json::n(steps_left))]),

            Some(Found { culprit }) => json::obj([("state", json::s("found")), ("culprit", json::s(&culprit.to_hex()))]),

            Some(Inconclusive { candidates }) => json::obj([("state", json::s("inconclusive")), ("candidates", json::hashes(&candidates))]),

        };

        println!("{v}");

        return Ok(0);

    }

fn signature_json(repo: &Repo, h: &oxy_core::hash::ChangeHash) -> Result<String> {

    Ok(match repo.authenticate_change(h)? {

        SignatureStatus::Unsigned => json::obj([("status", json::s("unsigned"))]),

        SignatureStatus::Valid { key, name, email, sealed, revoked } => json::obj([

            ("status", json::s(if sealed { "sealed" } else { "signed" })),

            ("key", json::s(&key.to_hex())),

            ("name", json::s(&name)),

            ("email", json::s(&email)),

            ("revoked", json::b(revoked)),

        ]),

        SignatureStatus::Invalid(why) => json::obj([("status", json::s("invalid")), ("reason", json::s(&why))]),

    })

}

fn log_entry_json(repo: &Repo, e: &oxy_core::repo::LogEntry) -> Result<String> {

    let c = &e.change;

    Ok(json::obj([

        ("hash", json::s(&e.hash.to_hex())),

        ("change_id", json::s(&c.change_id.to_hex())),

        ("author", json::s(&author_name(repo, c))),

        ("author_key", json::s(&c.author.to_hex())),

        ("when_ms", json::n(c.hlc.wall_ms)),

        ("message", json::s(&c.message)),

        ("kind", json::s(&format!("{:?}", c.kind).to_lowercase())),

        ("deps", json::hashes(&c.deps)),

        ("head", json::b(e.is_head)),

        ("working_copy", json::b(e.is_working_copy)),

        ("signature", if e.is_working_copy { "null".into() } else { signature_json(repo, &e.hash)? }),

    ]))

}

pub fn log(limit: Option<usize>, verbose: bool, path: Option<&str>, as_json: bool) -> Result<i32> {

    let entries = match path {

        Some(p) => repo.log_for_path(p)?,

        None => repo.log()?,

    };

    if as_json {

        let shown = limit.unwrap_or(entries.len()).min(entries.len());

        let mut items = Vec::new();

        for e in entries.iter().take(shown) {

            items.push(log_entry_json(&repo, e)?);

        }

        println!("{}", json::obj([("bookmark", json::s(&repo.config.bookmark)), ("total", json::n(entries.len())), ("changes", json::arr(items))]));

        return Ok(0);

    }

pub fn diff(change: Option<&str>, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let hash = change.map(|c| repo.resolve_change(c)).transpose()?;

    if as_json {

        let files = repo.diff_files(hash.as_ref())?;

        let items = files.iter().map(|f| {

            json::obj([

                ("path", json::s(&f.path)),

                ("kind", json::s(&f.kind)),

                ("from", json::opt(f.from.as_deref(), json::s)),

                (

                    "hunks",

                    json::arr(f.hunks.iter().map(|h| {

                        json::obj([

                            ("base_line", json::n(h.base_line)),

                            ("added", json::arr(h.added.iter().map(|l| json::s(&String::from_utf8_lossy(l))))),

                            ("removed", json::arr(h.removed.iter().map(|(n, l)| json::obj([("line", json::n(*n)), ("text", json::s(&String::from_utf8_lossy(l)))])))),

                        ])

                    })),

                ),

            ])

        });

        println!("{}", json::obj([("change", json::opt(hash, |h| json::s(&h.to_hex()))), ("files", json::arr(items))]));

        return Ok(0);

    }

    match hash {

        Some(h) => {

            let c = repo.store().get_change(&h)?;

            let base = repo.load_state(&c.deps)?;

            let snapshot = base.materialize();

            print!("{}", render_change(&c, &base, &snapshot));

        }

        None => {

            let snap = repo.snapshot("oxy diff")?;

            print!("{}", render_change(&snap.wc, &snap.base, &snap.base_snapshot));

        }

    }

    Ok(0)

}

pub fn cat(path: &str, change: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let heads = change.map(|c| repo.resolve_heads(c)).transpose()?;

    let bytes = repo.file_at(path, heads.as_deref())?;

    use std::io::Write as _;

    std::io::stdout().write_all(&bytes)?;

    Ok(0)

}

pub fn root(as_json: bool) -> Result<i32> {

    let Ok(repo) = Repo::open(&std::env::current_dir()?) else {

        if as_json {