Partial and interactive commits (commit PATH.., commit -i with hunk closure), oxy blame from atom keys, oxy bisect over dependency-closed prefixes with run and skip (spec 0.8 sections 12.3 and 27) 957fee30826e

//! Inspection (spec §27): blame from atom keys, and bisect over

//! dependency-closed prefixes of the candidates between a good and a bad

//! state.

use super::*;

/// One line of `oxy blame`.

#[derive(Clone, Debug)]

pub struct BlameLine {

    pub line: usize,

    pub hash: ChangeHash,

    pub index: u32,

    pub change_id: ChangeId,

    pub author: String,

    pub when_ms: u64,

    pub text: Vec<u8>,

}

/// Where a bisect stands.

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum BisectStep {

    /// More `good`/`bad` marks are needed before the search can start.

    NeedMarks { good: usize, bad: usize },

    /// A state is checked out for testing.

    Testing { heads: Vec<ChangeHash>, remaining: usize, steps_left: u32 },

    /// The first change whose inclusion makes the state bad.

    Found { culprit: ChangeHash },

    /// Every remaining candidate was skipped.

    Inconclusive { candidates: Vec<ChangeHash> },

}

#[derive(Clone, Debug, Default)]

struct BisectState {

    start: Vec<ChangeHash>,

    good: Vec<ChangeHash>,

    bad: Vec<ChangeHash>,

    candidates: Vec<ChangeHash>,

    lo: usize,

    hi: usize,

    /// The prefix length currently checked out for testing.

    testing: Option<usize>,

    skipped: Vec<usize>,

}

fn hashes_line(v: &[ChangeHash]) -> String {

    v.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(" ")

}

fn hashes_from(s: &str) -> Vec<ChangeHash> {

    s.split_whitespace().filter_map(ObjectRef::from_hex).collect()

}

impl Repo {

    /// The introducing change, author, and date of every line of `path` in

    /// the working copy's base state (spec §27).

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

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

        let Some(f) = snap.base_snapshot.files.get(path) else { return fail(format!("{path} is not in the working copy's base state")) };

        if !matches!(f.content, FileContent::Text { .. }) {

            return fail(format!("{path} is not a text file"));

        }

        let mut out = Vec::new();

        for (i, ((hash, index), text)) in snap.base.live_lines(&f.node).into_iter().enumerate() {

            let meta = snap.base.get(&hash);

            let author = match meta {

                Some(m) if !m.author.is_zero() => self.store.get_identity(&m.author).map(|id| id.name).unwrap_or_else(|_| m.author.short(12)),

                Some(m) => m.message.lines().rev().find_map(|l| l.strip_prefix("Git-Author: ")).map(|a| a.split('<').next().unwrap_or(a).trim().to_string()).unwrap_or_else(|| "unknown".into()),

                None => "unknown".into(),

            };

            out.push(BlameLine {

                line: i + 1,

                hash,

                index,

                change_id: meta.map(|m| m.change_id).unwrap_or(ChangeId([0; 16])),

                author,

                when_ms: meta.map(|m| m.hlc.wall_ms).unwrap_or(0),

                text,

            });

        }

        Ok(out)

    }

    // ------------------------------------------------------------ bisect

    fn bisect_dir(&self) -> PathBuf {

        self.oxy.join("bisect")

    }

    fn bisect_load(&self) -> Result<Option<BisectState>> {

        let dir = self.bisect_dir();

        if !dir.join("start").exists() {

            return Ok(None);

        }

        let read = |name: &str| fs::read_to_string(dir.join(name)).unwrap_or_default();

        let nums: Vec<usize> = read("range").split_whitespace().filter_map(|n| n.parse().ok()).collect();

        Ok(Some(BisectState {

            start: hashes_from(&read("start")),

            good: hashes_from(&read("good")),

            bad: hashes_from(&read("bad")),

            candidates: hashes_from(&read("candidates")),

            lo: nums.first().copied().unwrap_or(0),

            hi: nums.get(1).copied().unwrap_or(0),

            testing: nums.get(2).copied().filter(|_| nums.len() > 2),

            skipped: read("skipped").split_whitespace().filter_map(|n| n.parse().ok()).collect(),

        }))

    }

    fn bisect_save(&self, st: &BisectState) -> Result<()> {

        let dir = self.bisect_dir();

        fs::create_dir_all(&dir)?;

        write_atomic(&dir.join("start"), hashes_line(&st.start).as_bytes())?;

        write_atomic(&dir.join("good"), hashes_line(&st.good).as_bytes())?;

        write_atomic(&dir.join("bad"), hashes_line(&st.bad).as_bytes())?;

        write_atomic(&dir.join("candidates"), hashes_line(&st.candidates).as_bytes())?;

        let mut range = format!("{} {}", st.lo, st.hi);

        if let Some(t) = st.testing {

            range.push_str(&format!(" {t}"));

        }

        write_atomic(&dir.join("range"), range.as_bytes())?;

        write_atomic(&dir.join("skipped"), st.skipped.iter().map(|n| n.to_string()).collect::<Vec<_>>().join(" ").as_bytes())?;

        Ok(())

    }

    /// Begin a bisect: remembers the working copy's base to restore later.

    pub fn bisect_start(&self) -> Result<()> {

        if self.bisect_load()?.is_some() {

            return fail("a bisect is in progress; finish it or run `oxy bisect reset`");

        }

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

        let start = self.load_state(&wc.deps)?.maximal(&wc.deps);

        self.bisect_save(&BisectState { start, ..Default::default() })

    }

    pub fn bisect_reset(&self) -> Result<()> {

        let Some(st) = self.bisect_load()? else { return fail("no bisect in progress") };

        self.checkout(&st.start, false, "oxy bisect reset")?;

        fs::remove_dir_all(self.bisect_dir())?;

        Ok(())

    }

    pub fn bisect_status(&self) -> Result<Option<BisectStep>> {

        let Some(st) = self.bisect_load()? else { return Ok(None) };

        Ok(Some(self.bisect_step(&st)))

    }

    fn bisect_step(&self, st: &BisectState) -> BisectStep {

        if st.candidates.is_empty() {

            return BisectStep::NeedMarks { good: st.good.len(), bad: st.bad.len() };

        }

        if st.hi <= st.lo + 1 {

            return BisectStep::Found { culprit: st.candidates[st.lo] };

        }

        match st.testing {

            Some(_) => {

                let remaining = st.hi - st.lo;

                BisectStep::Testing { heads: self.bisect_heads(st, st.testing.unwrap()), remaining, steps_left: (remaining as f64).log2().ceil() as u32 }

            }

            None => BisectStep::Inconclusive { candidates: st.candidates[st.lo..st.hi].to_vec() },

        }

    }

    /// `good ∪ candidates[..k]`, as heads.

    fn bisect_heads(&self, st: &BisectState, k: usize) -> Vec<ChangeHash> {

        let mut all = st.good.clone();

        all.extend(st.candidates[..k].iter().copied());

        self.load_state(&all).map(|s| s.maximal(&all)).unwrap_or(all)

    }

    /// Check out the midpoint of the open range, skipping indices marked

    /// untestable, and record it as the state under test.

    fn bisect_advance(&self, st: &mut BisectState) -> Result<BisectStep> {

        if st.hi <= st.lo + 1 {

            st.testing = None;

            self.bisect_save(st)?;

            return Ok(BisectStep::Found { culprit: st.candidates[st.lo] });

        }

        let mid = st.lo + (st.hi - st.lo) / 2;

        // Try mid, then the nearest untried indices on either side.

        let mut order = vec![mid];

        for d in 1..(st.hi - st.lo) {

            if mid + d < st.hi {

                order.push(mid + d);

            }

            if mid > st.lo + d {

                order.push(mid - d);

            }

        }

        let Some(k) = order.into_iter().find(|k| !st.skipped.contains(k)) else {

            st.testing = None;

            self.bisect_save(st)?;

            return Ok(BisectStep::Inconclusive { candidates: st.candidates[st.lo..st.hi].to_vec() });

        };

        let heads = self.bisect_heads(st, k);

        self.checkout(&heads, false, &format!("oxy bisect (testing {k} of {})", st.candidates.len()))?;

        st.testing = Some(k);

        self.bisect_save(st)?;

        let remaining = st.hi - st.lo;

        Ok(BisectStep::Testing { heads, remaining, steps_left: (remaining as f64).log2().ceil() as u32 })

    }

    /// Mark states good or bad. With `changes`, before the search starts,

    /// they name known-good or known-bad states; without, the state under

    /// test gets the verdict. `None` for `good` means skip (untestable).

    pub fn bisect_mark(&self, good: Option<bool>, changes: &[ChangeHash]) -> Result<BisectStep> {

        let Some(mut st) = self.bisect_load()? else { return fail("no bisect in progress; run `oxy bisect start`") };

        if !changes.is_empty() {

            if !st.candidates.is_empty() {

                return fail("the search has started; mark the state under test with plain `oxy bisect good|bad`");

            }

            match good {

                Some(true) => st.good.extend(changes.iter().copied()),

                Some(false) => st.bad.extend(changes.iter().copied()),

                None => return fail("skip applies to the state under test"),

            }

            if st.good.is_empty() || st.bad.is_empty() {

                self.bisect_save(&st)?;

                return Ok(BisectStep::NeedMarks { good: st.good.len(), bad: st.bad.len() });

            }

            let good_heads = self.load_state(&st.good)?.maximal(&st.good);

            let bad_heads = self.load_state(&st.bad)?.maximal(&st.bad);

            st.good = good_heads.clone();

            st.bad = bad_heads.clone();

            st.candidates = self.negotiate(&good_heads, &bad_heads)?;

            if st.candidates.is_empty() {

                return fail("the bad state adds nothing to the good state; nothing to bisect");

            }

            st.lo = 0;

            st.hi = st.candidates.len();

            return self.bisect_advance(&mut st);

        }

        let Some(k) = st.testing else {

            return fail("no state is under test; give `oxy bisect good|bad` a change or bookmark to start with");

        };

        match good {

            Some(true) => st.lo = k,

            Some(false) => st.hi = k,

            None => st.skipped.push(k),

        }

        self.bisect_advance(&mut st)

    }

    /// Automate with a command run in the working copy: exit 0 is good, 125

    /// skips, anything else is bad.

    pub fn bisect_run(&self, command: &[String]) -> Result<BisectStep> {

        let Some(st) = self.bisect_load()? else { return fail("no bisect in progress; run `oxy bisect start`") };

        if st.testing.is_none() {

            return Ok(self.bisect_step(&st));

        }

        loop {

            let status = std::process::Command::new(&command[0]).args(&command[1..]).current_dir(&self.root).status().map_err(|e| RepoError::Msg(format!("running {}: {e}", command[0])))?;

            let verdict = match status.code() {

                Some(0) => Some(true),

                Some(125) => None,

                _ => Some(false),

            };

            match self.bisect_mark(verdict, &[])? {

                BisectStep::Testing { .. } => continue,

                done => return Ok(done),

            }

        }

    }

}

mod inspect;

pub use inspect::{BisectStep, BlameLine};

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

use crate::objects::AtomRef;

        self.commit_selection(message, extra_deps, &Selection::All)

    }

    /// The hunks of the working copy, for `oxy commit --interactive`: each

    /// tree operation and each edit, in the order `select_hunks` numbers them.

    pub fn hunks(&self) -> Result<(SnapshotResult, Vec<Hunk>)> {

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

        let hunks = render_hunks(&snap.wc, &snap.base, &snap.base_snapshot);

        Ok((snap, hunks))

    }

    /// Commit part of the working copy (spec §12.3). What is not selected

    /// stays on disk as uncommitted work: the next snapshot rebuilds it

    /// against the new base, so the working copy always describes the

    /// directory.

    pub fn commit_selection(&self, message: &str, extra_deps: &[ChangeHash], selection: &Selection) -> Result<ChangeHash> {

        let (tree_ops, edits, partial) = match selection {

            Selection::All => (snap.wc.tree_ops.clone(), snap.wc.edits.clone(), false),

            Selection::Paths(paths) => {

                let (o, e) = select_paths(&snap.wc, &snap.base_snapshot, paths);

                let partial = o.len() != snap.wc.tree_ops.len() || e.len() != snap.wc.edits.len();

                (o, e, partial)

            }

            Selection::Hunks(indices) => {

                let (o, e) = select_hunks(&snap.wc, indices);

                let partial = o.len() != snap.wc.tree_ops.len() || e.len() != snap.wc.edits.len();

                (o, e, partial)

            }

        };

        if tree_ops.is_empty() && edits.is_empty() {

            return fail("nothing selected to commit");

        }

        if partial && snap.resolves {

            return fail("a conflict resolution must be committed whole");

        }

            change_id: if partial { ChangeId::random() } else { snap.wc.change_id },

            deps: vec![],

            tree_ops,

            edits,

        if partial {

            // Dependencies come from what the selected part references, not

            // from the whole working copy.

            deps = referenced_changes(&change, &snap.base);

            for d in extra_deps {

                deps.insert(*d);

            }

        }

        change.deps = deps.into_iter().collect();

        if partial {

            // The rest is rebuilt from disk by the next snapshot.

            self.drop_manifest();

        } else {

            self.rewrite_manifest_flags(snap.base_snapshot.is_conflicted() && !snap.resolves, false)?;

        }

/// What part of the working copy a commit takes (spec §12.3).

#[derive(Clone, Debug)]

pub enum Selection {

    All,

    /// Every operation and edit on nodes under these paths.

    Paths(Vec<String>),

    /// Hunk indices as `Repo::hunks` numbers them; dependent hunks are added.

    Hunks(Vec<usize>),

}

/// One selectable piece of the working copy: a tree operation or an edit.

#[derive(Clone, Debug)]

pub struct Hunk {

    pub index: usize,

    pub path: String,

    /// Rendered like `oxy diff`.

    pub text: String,

}

/// The tree operations and edits on nodes under `paths`, plus the

/// additions of any new parent directories they need.

fn select_paths(wc: &Change, base_snapshot: &Snapshot, paths: &[String]) -> (Vec<TreeOp>, Vec<Edit>) {

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

    let by_node = base_snapshot.tree.by_node();

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

    for op in &wc.tree_ops {

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

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

        }

    }

    let mut nodes: BTreeSet<NodeId> = BTreeSet::new();

    for n in wc.tree_ops.iter().map(|o| o.node()).chain(wc.edits.iter().map(|e| e.node())) {

        if path_of_node(&n, &by_node, &new_names).is_some_and(|p| selected(&p)) {

            nodes.insert(n);

        }

    }

    // New parents of selected new nodes come along.

    let mut changed = true;

    while changed {

        changed = false;

        for (n, (parent, _, _)) in &new_names {

            if nodes.contains(n) && new_names.contains_key(parent) && nodes.insert(*parent) {

                changed = true;

            }

        }

    }

    let ops = wc.tree_ops.iter().filter(|o| nodes.contains(&o.node())).cloned().collect();

    let edits = wc.edits.iter().filter(|e| nodes.contains(&e.node())).cloned().collect();

    (ops, edits)

}

/// The hunks `indices` name plus whatever they refer to within the working

/// copy (the parent directory of an added node, the insert that introduced

/// an anchor line), renumbered so the result is a well-formed change.

fn select_hunks(wc: &Change, indices: &[usize]) -> (Vec<TreeOp>, Vec<Edit>) {

    let n_ops = wc.tree_ops.len();

    let mut ops_sel = vec![false; n_ops];

    let mut edits_sel = vec![false; wc.edits.len()];

    for &i in indices {

        if i < n_ops {

            ops_sel[i] = true;

        } else if i - n_ops < wc.edits.len() {

            edits_sel[i - n_ops] = true;

        }

    }

    // Atom ranges each insert introduces, per node, in the working copy's numbering.

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

    let mut insert_ranges: Vec<Option<(NodeId, u32, u32)>> = Vec::new();

    for e in &wc.edits {

        insert_ranges.push(match e {

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

                let start = per_node.entry(*node).or_default();

                let r = (*node, *start, *start + lines.len() as u32);

                *start += lines.len() as u32;

                Some(r)

            }

            _ => None,

        });

    }

    let add_index: HashMap<NodeId, usize> = wc.tree_ops.iter().enumerate().filter_map(|(i, o)| if let TreeOp::AddNode { node, .. } = o { Some((*node, i)) } else { None }).collect();

    let insert_for = |node: &NodeId, index: u32| -> Option<usize> { insert_ranges.iter().position(|r| matches!(r, Some((n, a, b)) if n == node && *a <= index && index < *b)) };

    // Closure.

    let mut changed = true;

    while changed {

        changed = false;

        for i in 0..n_ops {

            if !ops_sel[i] {

                continue;

            }

            if let TreeOp::AddNode { parent, .. } = &wc.tree_ops[i] {

                if let Some(&p) = add_index.get(parent) {

                    if !ops_sel[p] {

                        ops_sel[p] = true;

                        changed = true;

                    }

                }

            }

        }

        for j in 0..wc.edits.len() {

            if !edits_sel[j] {

                continue;

            }

            let e = &wc.edits[j];

            if let Some(&a) = add_index.get(&e.node()) {

                if !ops_sel[a] {

                    ops_sel[a] = true;

                    changed = true;

                }

            }

            if let Edit::Insert { node, after, before, .. } = e {

                for r in [after, before] {

                    if let AtomRef::Atom { change, index } = r {

                        if change.is_zero() {

                            if let Some(k) = insert_for(node, *index) {

                                if !edits_sel[k] {

                                    edits_sel[k] = true;

                                    changed = true;

                                }

                            }

                        }

                    }

                }

            }

        }

    }

    // Renumber self-references: old atom index → new index among selected inserts.

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

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

    for (j, r) in insert_ranges.iter().enumerate() {

        if let (true, Some((node, a, b))) = (edits_sel[j], r) {

            let next = new_counts.entry(*node).or_default();

            for old in *a..*b {

                remap.insert((*node, old), *next);

                *next += 1;

            }

        }

    }

    let map_ref = |r: AtomRef, node: &NodeId| -> AtomRef {

        match r {

            AtomRef::Atom { change, index } if change.is_zero() => AtomRef::Atom { change, index: remap.get(&(*node, index)).copied().unwrap_or(index) },

            other => other,

        }

    };

    let ops = wc.tree_ops.iter().enumerate().filter(|(i, _)| ops_sel[*i]).map(|(_, o)| o.clone()).collect();

    let edits = wc

        .edits

        .iter()

        .enumerate()

        .filter(|(j, _)| edits_sel[*j])

        .map(|(_, e)| match e {

            Edit::Insert { node, after, before, lines } => Edit::Insert { node: *node, after: map_ref(*after, node), before: map_ref(*before, node), lines: lines.clone() },

            other => other.clone(),

        })

        .collect();

    (ops, edits)

}

/// Render each tree operation and edit of `change` on its own, numbered.

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

    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 mut out = Vec::new();

    for (i, op) in change.tree_ops.iter().enumerate() {

        let one = Change { tree_ops: vec![op.clone()], edits: vec![], ..change.clone() };

        let path = path_of_node(&op.node(), &by_node, &new_names).unwrap_or_default();

        out.push(Hunk { index: i, path, text: render_change(&one, base, base_snapshot) });

    }

    for (j, e) in change.edits.iter().enumerate() {

        let one = Change { tree_ops: vec![], edits: vec![e.clone()], ..change.clone() };

        let path = path_of_node(&e.node(), &by_node, &new_names).unwrap_or_default();

        out.push(Hunk { index: change.tree_ops.len() + j, path, text: render_change(&one, base, base_snapshot) });

    }

    out

}

use crate::repo::{BisectStep, Selection};

#[test]

fn partial_commits_by_path_and_by_hunk() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

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

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

    let h0 = repo.commit("base", &[]).unwrap();

    write(root, "a.txt", b"0\n1\n2\n3\n4\n");

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

    write(root, "c.txt", b"c\n");

    // By path: only a.txt goes in; the rest stays on disk as uncommitted work.

    let h1 = repo.commit_selection("a only", &[], &Selection::Paths(vec!["a.txt".into()])).unwrap();

    let c1 = repo.store().get_change(&h1).unwrap();

    assert!(c1.tree_ops.is_empty() && c1.edits.iter().all(|e| e.node() == c1.edits[0].node()), "{:?}", c1.tree_ops);

    assert_eq!(c1.deps, vec![h0]);

    let files = repo.load_state(&[h1]).unwrap().materialize().files;

    assert!(matches!(&files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"0\n1\n2\n3\n4\n"));

    assert!(matches!(&files["b.txt"].content, FileContent::Text { bytes, .. } if bytes == b"b\n"));

    assert!(!files.contains_key("c.txt"));

    let snap = repo.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| (s.path.as_str(), s.status)).collect::<Vec<_>>(), vec![("b.txt", ChangeStatus::Modified), ("c.txt", ChangeStatus::Added)]);

    assert_eq!(fs::read(root.join("b.txt")).unwrap(), b"b\nbb\n", "disk untouched");

    // By hunk: pick the b.txt insert; c.txt's addition is left.

    let (_, hunks) = repo.hunks().unwrap();

    let b_hunk = hunks.iter().find(|h| h.path == "b.txt" && h.text.contains("+bb")).unwrap().index;

    let h2 = repo.commit_selection("b only", &[], &Selection::Hunks(vec![b_hunk])).unwrap();

    let files = repo.load_state(&[h2]).unwrap().materialize().files;

    assert!(matches!(&files["b.txt"].content, FileContent::Text { bytes, .. } if bytes == b"b\nbb\n"));

    assert!(!files.contains_key("c.txt"));

    let snap = repo.snapshot("status").unwrap();

    assert_eq!(snap.statuses.iter().map(|s| s.path.as_str()).collect::<Vec<_>>(), vec!["c.txt"]);

    // Choosing only the content hunk of a file in a new directory pulls in

    // the directory and file additions it needs.

    write(root, "d/e.txt", b"e\n");

    let (_, hunks) = repo.hunks().unwrap();

    let e_insert = hunks.iter().find(|h| h.path == "d/e.txt" && h.text.contains("+e")).unwrap().index;

    let h3 = repo.commit_selection("e only", &[], &Selection::Hunks(vec![e_insert])).unwrap();

    let c3 = repo.store().get_change(&h3).unwrap();

    assert_eq!(c3.tree_ops.len(), 2, "{:?}", c3.tree_ops);

    let files = repo.load_state(&[h3]).unwrap().materialize().files;

    assert!(files.contains_key("d/e.txt") && !files.contains_key("c.txt"));

    // Everything left commits normally; the working copy is then clean.

    repo.commit("the rest", &[]).unwrap();

    assert!(!repo.snapshot("status").unwrap().changed);

    let files = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap().materialize().files;

    assert!(files.contains_key("c.txt"));

}

#[test]

fn blame_attributes_lines_to_introducing_changes_across_renames() {

    hermetic();

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

    let root = dir.path();

    let mut repo = Repo::init(root).unwrap().with_home(root.join("home"));

    repo.create_identity("Ada", "[email protected]", IdentityScope::User).unwrap();

    write(root, "a.txt", b"one\n");

    let h1 = repo.commit("first", &[]).unwrap();

    write(root, "a.txt", b"one\ntwo\n");

    let h2 = repo.commit("second", &[]).unwrap();

    let b = repo.blame("a.txt").unwrap();

    assert_eq!(b.iter().map(|l| (l.line, l.hash, l.text.as_slice())).collect::<Vec<_>>(), vec![(1, h1, b"one\n".as_slice()), (2, h2, b"two\n".as_slice())]);

    assert!(b.iter().all(|l| l.author == "Ada"));

    assert_eq!(b[0].change_id, repo.store().get_change(&h1).unwrap().change_id);

    fs::rename(root.join("a.txt"), root.join("b.txt")).unwrap();

    repo.commit("rename", &[]).unwrap();

    let b = repo.blame("b.txt").unwrap();

    assert_eq!(b.iter().map(|l| l.hash).collect::<Vec<_>>(), vec![h1, h2], "the node survives the rename");

    assert!(repo.blame("a.txt").is_err());

}

#[test]

fn bisect_finds_the_first_bad_change() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    let mut content = String::new();

    let mut hashes = Vec::new();

    for i in 1..=8 {

        content.push_str(&format!("line {i}{}\n", if i == 5 { " bug" } else { "" }));

        write(root, "f.txt", content.as_bytes());

        hashes.push(repo.commit(&format!("step {i}"), &[]).unwrap());

    }

    // Each step appends after the previous line, so the chain is linear.

    assert_eq!(repo.bookmark_heads().unwrap(), vec![hashes[7]]);

    repo.bisect_start().unwrap();

    assert!(matches!(repo.bisect_mark(Some(true), &[hashes[0]]).unwrap(), BisectStep::NeedMarks { good: 1, bad: 0 }));

    let step = repo.bisect_mark(Some(false), &[hashes[7]]).unwrap();

    assert!(matches!(step, BisectStep::Testing { remaining: 7, .. }), "{step:?}");

    // Automated: bad when the bug line is present.

    let step = repo.bisect_run(&["sh".into(), "-c".into(), "! grep -q bug f.txt".into()]).unwrap();

    assert_eq!(step, BisectStep::Found { culprit: hashes[4] });

    assert_eq!(repo.bisect_status().unwrap(), Some(BisectStep::Found { culprit: hashes[4] }));

    repo.bisect_reset().unwrap();

    assert_eq!(fs::read_to_string(root.join("f.txt")).unwrap(), content);

    assert!(repo.bisect_status().unwrap().is_none());

    assert!(!repo.snapshot("status").unwrap().changed);

    // Manual marks and a skip.

    repo.bisect_start().unwrap();

    repo.bisect_mark(Some(true), &[hashes[0]]).unwrap();

    let mut step = repo.bisect_mark(Some(false), &[hashes[7]]).unwrap();

    let mut skipped_once = false;

    let mut guard = 0;

    while let BisectStep::Testing { .. } = step {

        guard += 1;

        assert!(guard < 20);

        let text = fs::read_to_string(root.join("f.txt")).unwrap();

        if !skipped_once && text.contains("line 6") {

            // An untestable state away from the boundary: the search routes around it.

            skipped_once = true;

            step = repo.bisect_mark(None, &[]).unwrap();

            continue;

        }

        step = repo.bisect_mark(Some(!text.contains("bug")), &[]).unwrap();

    }

    assert!(skipped_once);

    assert_eq!(step, BisectStep::Found { culprit: hashes[4] });

    repo.bisect_reset().unwrap();

    // Skipping the culprit itself leaves it among the candidates reported.

    repo.bisect_start().unwrap();

    repo.bisect_mark(Some(true), &[hashes[0]]).unwrap();

    let mut step = repo.bisect_mark(Some(false), &[hashes[7]]).unwrap();

    let mut guard = 0;

    while let BisectStep::Testing { heads, .. } = &step {

        guard += 1;

        assert!(guard < 20);

        let text = fs::read_to_string(root.join("f.txt")).unwrap();

        let is_culprit_state = heads.contains(&hashes[4]) && !heads.iter().any(|h| hashes[5..].contains(h));

        step = if is_culprit_state { repo.bisect_mark(None, &[]).unwrap() } else { repo.bisect_mark(Some(!text.contains("bug")), &[]).unwrap() };

    }

    match step {

        BisectStep::Inconclusive { candidates } => assert!(candidates.contains(&hashes[4]) && candidates.len() <= 2, "{candidates:?}"),

        other => panic!("{other:?}"),

    }

    repo.bisect_reset().unwrap();

}

Commit part of what changed with `oxy commit PATH.. -m "..."` (only those

paths; the rest stays as uncommitted work) or `oxy commit -i -m "..."`, which

offers each hunk in turn like `git add -p`; a hunk that another chosen hunk

needs, such as the directory a new file lives in, comes along by itself.

## 4a. Who wrote this, and what broke it

```

oxy blame src/parser.rs          # every line: the change that introduced it, author, age

oxy blame src/parser.rs --json

```

Blame is exact: each line is an atom that remembers the change that

introduced it, so renames cost nothing and there is no heuristic.

```

oxy bisect start

oxy bisect good v1.2             # a change, bookmark or tag known to be fine

oxy bisect bad main              # and one known to be broken

oxy bisect run make test         # exit 0 good, 125 skip, anything else bad

oxy bisect reset                 # back to where you were

```

Without `run`, each step checks out a state to test and you answer with

`oxy bisect good`, `bad`, or `skip`. The candidates are the changes the bad

state has that the good one lacks, ordered so every tested state is

well-formed; the answer is the first change whose inclusion breaks things.

- [x] Partial commits (spec §12.3): `oxy commit PATH..` and `oxy commit --interactive` (hunk = one edit or tree operation, dependent hunks pulled in), sharing the split machinery.

- [x] Blame (spec §27): `oxy blame PATH [--json]` from atom keys, with author and date; renames followed.

- [x] Bisect (spec §27): `oxy bisect start|good|bad|run|reset` over dependency-closed prefixes; state under `.oxy/bisect/`.

| Partial and interactive commits (§12.3) | Implemented |

| Blame and bisect (§27) | Implemented |

        /// Commit only these paths; the rest stays as uncommitted work

        paths: Vec<String>,

        /// Choose hunks one by one

        #[arg(short, long)]

        interactive: bool,

    /// Show which change introduced each line of a file

    Blame {

        path: String,

        #[arg(long)]

        json: bool,

    },

    /// Find the change that introduced a regression

    Bisect {

        #[command(subcommand)]

        cmd: BisectCmd,

    },

enum BisectCmd {

    /// Begin; remembers where the working copy was

    Start,

    /// Mark CHANGE... (or the state under test) as good

    Good { changes: Vec<String> },

    /// Mark CHANGE... (or the state under test) as bad

    Bad { changes: Vec<String> },

    /// The state under test cannot be tested; try another

    Skip,

    /// Run a command for each step: exit 0 good, 125 skip, else bad

    Run {

        #[arg(required = true, trailing_var_arg = true)]

        command: Vec<String>,

    },

    /// Where the search stands

    Status,

    /// Restore the working copy and forget the search

    Reset,

}

#[derive(Subcommand)]

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

        Cmd::Blame { path, json } => workspace::blame(&path, json),

        Cmd::Bisect { cmd } => match cmd {

            BisectCmd::Start => workspace::bisect_start(),

            BisectCmd::Good { changes } => workspace::bisect_mark(Some(true), &changes),

            BisectCmd::Bad { changes } => workspace::bisect_mark(Some(false), &changes),

            BisectCmd::Skip => workspace::bisect_mark(None, &[]),

            BisectCmd::Run { command } => workspace::bisect_run(&command),

            BisectCmd::Status => workspace::bisect_status(),

            BisectCmd::Reset => workspace::bisect_reset(),

        },

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

    let selection = if interactive {

        let (_, hunks) = repo.hunks()?;

        if hunks.is_empty() {

            anyhow::bail!("nothing to commit: the working copy matches its base");

        }

        let hunks: Vec<_> = hunks.into_iter().filter(|h| paths.is_empty() || paths.iter().any(|p| h.path == *p || h.path.starts_with(&format!("{}/", p.trim_end_matches('/'))))).collect();

        let mut chosen = Vec::new();

        let stdin = std::io::stdin();

        let mut take_rest = false;

        for (n, h) in hunks.iter().enumerate() {

            if take_rest {

                chosen.push(h.index);

                continue;

            }

            println!("{} {} {}", ui::section(format!("hunk {} of {}", n + 1, hunks.len())), ui::path(&h.path), ui::dim(format!("(#{})", h.index)));

            for line in h.text.lines() {

                let styled = if line.starts_with('+') { ui::ok(line) } else if line.starts_with('-') { ui::err(line) } else { ui::dim(line) };

                println!("  {styled}");

            }

            loop {

                print!("{} ", ui::warn("Commit this hunk? [y]es [n]o [a]ll remaining [q]uit:"));

                use std::io::Write as _;

                std::io::stdout().flush()?;

                let mut answer = String::new();

                if stdin.read_line(&mut answer)? == 0 {

                    anyhow::bail!("aborted");

                }

                match answer.trim() {

                    "y" | "Y" => {

                        chosen.push(h.index);

                        break;

                    }

                    "n" | "N" | "" => break,

                    "a" | "A" => {

                        chosen.push(h.index);

                        take_rest = true;

                        break;

                    }

                    "q" | "Q" => anyhow::bail!("aborted; nothing committed"),

                    _ => continue,

                }

            }

        }

        if chosen.is_empty() {

            anyhow::bail!("no hunks chosen; nothing committed");

        }

        oxy_core::repo::Selection::Hunks(chosen)

    } else if paths.is_empty() {

        oxy_core::repo::Selection::All

    } else {

        oxy_core::repo::Selection::Paths(paths.to_vec())

    };

    let h = repo.commit_selection(message, &deps, &selection)?;

    if !matches!(selection, oxy_core::repo::Selection::All) {

        let rest = repo.snapshot("oxy commit")?;

        if !rest.statuses.is_empty() {

            println!("  {} {}", ui::note(), ui::dim(format!("{} left uncommitted", plural(rest.statuses.len(), "path"))));

        }

    }

    Ok(0)

}

pub fn blame(path: &str, json: bool) -> Result<i32> {

    let repo = open()?;

    let lines = repo.blame(path)?;

    if json {

        let items = lines.iter().map(|l| {

            format!(

                "{{\"line\":{},\"change_id\":{},\"hash\":{},\"index\":{},\"author\":{},\"when_ms\":{}}}",

                l.line,

                oxy_core::repo::json_str(&l.change_id.to_hex()),

                oxy_core::repo::json_str(&l.hash.to_hex()),

                l.index,

                oxy_core::repo::json_str(&l.author),

                l.when_ms

            )

        });

        println!("{}", oxy_core::repo::json_array(items));

        return Ok(0);

    }

    let width = lines.iter().map(|l| l.author.chars().count()).max().unwrap_or(0).min(20);

    let digits = lines.len().to_string().len();

    for l in &lines {

        let author: String = l.author.chars().take(20).collect();

        let text = String::from_utf8_lossy(&l.text);

        println!(

            "{} {} {} {:>digits$}{} {}",

            ui::id(l.change_id.short(8)),

            ui::author(format!("{author:<width$}")),

            ui::dim(ui::ago(l.when_ms)),

            l.line,

            ui::dim(ui::glyph("│", "|")),

            text.trim_end_matches('\n')

        );

    }

    Ok(0)

}

fn bisect_report(repo: &Repo, step: &oxy_core::repo::BisectStep) -> Result<i32> {

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

    match step {

        NeedMarks { good, bad } => {

            println!("{} {} {}", ui::note(), ui::dim(format!("{good} good, {bad} bad;")), ui::dim(if *good == 0 { "mark a known-good change or bookmark: oxy bisect good CHANGE" } else { "mark a known-bad change or bookmark: oxy bisect bad CHANGE" }));

            Ok(0)

        }

        Testing { heads, remaining, steps_left } => {

            println!("{} {} {}", ui::done("Testing"), ui::dim(format!("{} in the state under test;", plural(heads.len(), "head"))), ui::dim(format!("{remaining} candidates left, about {steps_left} more steps")));

            println!("  {} {}", ui::note(), ui::dim("run your test, then oxy bisect good | bad | skip"));

            Ok(0)

        }

        Found { culprit } => {

            let c = repo.store().get_change(culprit)?;

            println!("{} {} {}  {}", ui::done("Found"), ui::id(short_id(&c)), ui::hash(format!("#{}", culprit.short(12))), ui::subject(subject_of(&c.message)));

            println!("  {} {}", ui::note(), ui::dim("the first change whose inclusion makes the state bad; oxy bisect reset to return"));

            Ok(0)

        }

        Inconclusive { candidates } => {

            println!("{} {}", ui::caution(), ui::warn(format!("every remaining candidate was skipped ({}); oxy bisect reset to return", plural(candidates.len(), "change"))));

            Ok(1)

        }

    }

}

pub fn bisect_start() -> Result<i32> {

    let repo = open()?;

    repo.bisect_start()?;

    println!("{} bisect; {}", ui::done("Started"), ui::dim("now: oxy bisect good CHANGE and oxy bisect bad CHANGE"));

    Ok(0)

}

pub fn bisect_mark(good: Option<bool>, changes: &[String]) -> Result<i32> {

    let repo = open()?;

    let mut heads = Vec::new();

    for c in changes {

        heads.extend(repo.resolve_heads(c)?);

    }

    let step = repo.bisect_mark(good, &heads)?;

    bisect_report(&repo, &step)

}

pub fn bisect_run(command: &[String]) -> Result<i32> {

    let repo = open()?;

    let step = repo.bisect_run(command)?;

    bisect_report(&repo, &step)

}

pub fn bisect_status() -> Result<i32> {

    let repo = open()?;

    match repo.bisect_status()? {

        None => {

            println!("{}", ui::dim("No bisect in progress."));

            Ok(0)

        }

        Some(step) => bisect_report(&repo, &step),

    }

}

pub fn bisect_reset() -> Result<i32> {

    let repo = open()?;

    repo.bisect_reset()?;

    println!("{} bisect; working copy restored", ui::done("Reset"));