The history of a range of lines: oxy log -L START,END:PATH 83d61e803ccd

    /// Every atom on some path from `first` to `last`, both included, live

    /// or deleted (spec §8): the atoms a range of lines is made of, and

    /// those that were deleted from between them. Empty when `last` does

    /// not follow `first`.

    pub fn between(&self, first: &AtomKey, last: &AtomKey) -> Vec<AtomKey> {

        let (from, to) = (Vertex::Atom(*first), Vertex::Atom(*last));

        let mut ahead: HashSet<Vertex> = HashSet::default();

        let mut stack = vec![from];

        while let Some(v) = stack.pop() {

            if ahead.insert(v) {

                stack.extend(

                    self.succ

                        .get(&v)

                        .map(|e| e.as_slice())

                        .unwrap_or(&[])

                        .iter()

                        .copied(),

                );

            }

        }

        if !ahead.contains(&to) {

            return vec![];

        }

        let mut pred: HashMap<Vertex, Vec<Vertex>> = HashMap::default();

        for (u, es) in &self.succ {

            if ahead.contains(u) {

                for w in es.iter() {

                    pred.entry(*w).or_default().push(*u);

                }

            }

        }

        let mut behind: HashSet<Vertex> = HashSet::default();

        let mut stack = vec![to];

        while let Some(v) = stack.pop() {

            if behind.insert(v) {

                stack.extend(pred.get(&v).into_iter().flatten().copied());

            }

        }

        let mut out: Vec<AtomKey> = ahead

            .intersection(&behind)

            .filter_map(|v| match v {

                Vertex::Atom(k) if self.atoms.contains_key(k) => Some(*k),

                _ => None,

            })

            .collect();

        out.sort();

        out

    }

    /// The changes that inserted or deleted any of `atoms`.

    pub fn touching(&self, atoms: &[AtomKey]) -> BTreeSet<ChangeHash> {

        let mut out = BTreeSet::new();

        for k in atoms {

            out.insert(k.0);

            if let Some(info) = self.atoms.get(k) {

                out.extend(info.deleted_by.iter().copied());

            }

        }

        out

    }

    /// The history of lines `first..=last` (1-based) of `path` in the

    /// state `heads` make (spec §27): every change that inserted or

    /// deleted one of their atoms, or an atom deleted from between them,

    /// newest first. Exact, as atoms keep their identity across edits.

    pub fn line_history(

        &self,

        heads: &[ChangeHash],

        path: &str,

        first: usize,

        last: usize,

    ) -> Result<Vec<LogEntry>> {

        if first == 0 || last < first {

            return fail(format!(

                "lines {first},{last}: expected FIRST,LAST from 1 with FIRST ≤ LAST"

            ));

        }

        let mut state = self.load_state_history(heads)?;

        let Some(node) = state.tree().view().entries.get(path).map(|e| e.node) else {

            return fail(format!("{path} is not in that state"));

        };

        self.load_graphs_of(&mut state, &[node])?;

        let live = state.live_lines(&node);

        if last > live.len() {

            return fail(format!(

                "{path} has {} lines; asked for {first},{last}",

                live.len()

            ));

        }

        let Some(g) = state.file(&node) else {

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

        };

        let atoms = g.between(&live[first - 1].0, &live[last - 1].0);

        let touched = g.touching(&atoms);

        Ok(self

            .log_of(&state)

            .into_iter()

            .filter(|e| touched.contains(&e.hash))

            .collect())

    }

/// The history of a range of lines (spec §27): the changes that wrote

/// or deleted its atoms, or deleted atoms from between them; edits outside

/// the range and changes the range's lines survived are not in it.

#[test]

fn line_ranges_have_exact_histories() {

    hermetic();

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

    let root = dir.path();

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

    write(root, "f.rs", b"use x;\nfn a() {\n  one();\n  two();\n}\n");

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

    write(root, "f.rs", b"use y;\nfn a() {\n  one();\n  two();\n}\n");

    let outside = repo.commit("change the import", &[]).unwrap();

    write(root, "f.rs", b"use y;\nfn a() {\n  ONE();\n  two();\n}\n");

    let inside = repo.commit("edit a line of a", &[]).unwrap();

    write(root, "f.rs", b"use y;\nfn a() {\n  ONE();\n}\n");

    let deleted = repo.commit("delete a line of a", &[]).unwrap();

    write(root, "f.rs", b"use y;\nfn a() {\n  ONE();\n}\nfn b() {}\n");

    let after = repo.commit("add b after a", &[]).unwrap();

    let heads = repo.bookmark_heads().unwrap();

    // Lines 2..4 are `fn a() {`, `ONE();`, `}` now.

    let hist: Vec<ChangeHash> = repo

        .line_history(&heads, "f.rs", 2, 4)

        .unwrap()

        .iter()

        .map(|e| e.hash)

        .collect();

    for (h, what) in [

        (base, "wrote it"),

        (inside, "edited a line"),

        (deleted, "deleted a line from inside"),

    ] {

        assert!(hist.contains(&h), "{what}");

    }

    for (h, what) in [(outside, "an edit above"), (after, "an addition below")] {

        assert!(!hist.contains(&h), "{what}");

    }

    assert_eq!(hist[0], deleted, "newest first");

    // One line: only what touched it.

    let one: Vec<ChangeHash> = repo

        .line_history(&heads, "f.rs", 1, 1)

        .unwrap()

        .iter()

        .map(|e| e.hash)

        .collect();

    assert!(one.contains(&outside) && !one.contains(&inside));

    assert!(repo.line_history(&heads, "f.rs", 3, 9).is_err());

    assert!(repo.line_history(&heads, "f.rs", 0, 1).is_err());

    assert!(repo.line_history(&heads, "nope.rs", 1, 1).is_err());

}

- [x] P2a Function history in oxy-core and the CLI: `Repo::line_history`, `oxy log -L START,END:PATH` (first part of P2, below).

- [ ] P2b Function history on the hub: tree-sitter function boundaries (Rust, TypeScript, Python, shell), and a function's history as a list and a small graph from the file page.

| **Status** | Draft 0.8n |

oxy log [-n N] [-v] [-L S,E:PATH]   oxy show CHANGE

**Line history.** For the same reason the history of a range of lines, such as a function, is exact: `oxy log -L START,END:PATH` lists every change that inserted or deleted an atom on some path in the file graph from the range's first line to its last (the lines' own atoms and those deleted from between them), newest first, with lines numbered as in the working copy's base. Changes elsewhere in the file are not in it, and edits within the range stay in it however the lines moved around them. Hosts use the same query for a function's history (tree-sitter gives the range).

*Changelog.* Draft 0.8n (2026-09-29): line history, `oxy log -L` (§27). Draft 0.8m (2026-09-29): resolving replace conflicts (§9.3). Draft 0.8l (2026-09-28): deleting a reference on a remote; first serials from the clock (§16.4). Draft 0.8k (2026-09-28): the manifest records graph keys, so unchanged files are neither read nor rendered (§12.4). Draft 0.8j (2026-09-28): checkpoint payload version 2, file graphs by reference (§11).

        /// Only changes that wrote or deleted lines START to END of PATH

        /// (numbered as in the working copy's base), or deleted lines from

        /// between them: the history of a function

        #[arg(short = 'L', value_name = "START,END:PATH", conflicts_with = "path")]

        lines: Option<String>,

            lines,

        } => workspace::log(limit, verbose, path.as_deref(), lines.as_deref(), json),

/// `START,END:PATH` for `oxy log -L`.

fn parse_line_range(spec: &str) -> Result<(usize, usize, &str)> {

    let bad = || anyhow::anyhow!("-L {spec}: expected START,END:PATH, as 10,24:src/lib.rs");

    let (range, path) = spec.split_once(':').ok_or_else(bad)?;

    let (a, b) = range.split_once(',').ok_or_else(bad)?;

    Ok((

        a.trim().parse().map_err(|_| bad())?,

        b.trim().parse().map_err(|_| bad())?,

        path,

    ))

}

pub fn log(

    limit: Option<usize>,

    verbose: bool,

    path: Option<&str>,

    lines: Option<&str>,

    as_json: bool,

) -> Result<i32> {

    let entries = match (path, lines) {

        (_, Some(spec)) => {

            let (first, last, p) = parse_line_range(spec)?;

            repo.line_history(&snap.base.maximal(&snap.wc.deps), p, first, last)?

        }

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

        (None, None) => repo.log()?,

/// `oxy log -L START,END:PATH`: the history of a range of lines.

#[test]

fn the_history_of_a_function() {

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

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

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

    let dir = tmp.path().join("r");

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

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

    write(&dir, "f.rs", "use x;\nfn a() {\n  one();\n}\n");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "add f"]).0, 0);

    write(&dir, "f.rs", "use y;\nfn a() {\n  one();\n}\n");

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

    write(&dir, "f.rs", "use y;\nfn a() {\n  two();\n}\n");

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

    let v = json(&dir, &home, &["log", "--json", "-L", "2,4:f.rs"]);

    let messages: Vec<&str> = v["changes"]

        .as_array()

        .unwrap()

        .iter()

        .map(|c| c["message"].as_str().unwrap())

        .collect();

    assert_eq!(messages, ["body", "add f"], "not the import");

    let (code, _, err) = oxy(&dir, &home, &["log", "-L", "2:f.rs"]);

    assert_ne!(code, 0);

    assert!(err.contains("START,END:PATH"), "{err}");

}