Squash and rebase (spec 0.8 section 8.5): squash folds a change into a dependency with dependents following its atoms; rebase re-derives a change against another base with content-matched correspondence; correspondences keyed by node; spec 0.8a and docs 728da0f92161

Bookmarks (`oxy bookmark create|switch`, `oxy merge`), submodules (`oxy submodule add|update`),

partial commits (`oxy commit PATH..`, `oxy commit -i`), `oxy blame`, `oxy bisect`, `oxy squash` and

`oxy rebase` cover the everyday Git toolbox; see the guide.

impl Repo {

    /// Fold change `c` into its dependency `into` (spec §8.5): the result

    /// keeps `into`'s ChangeId, dependents of both are rewritten, and `c`

    /// leaves the state.

    pub fn squash(&self, c: &ChangeHash, into: &ChangeHash) -> Result<ChangeHash> {

        if c == into {

            return fail("a change cannot be squashed into itself");

        }

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

        let dst = self.store.get_change(into)?;

        if src.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; use `oxy amend --into`");

        }

        if dst.kind == ChangeKind::WorkingCopy {

            return fail("cannot squash into the working copy");

        }

        let closure = self.load_state(&[*into])?;

        let outside: Vec<String> = src.deps.iter().filter(|d| *d != into && !closure.contains(d)).map(|d| d.short(12)).collect();

        if !outside.is_empty() {

            return fail(format!("{} depends on {} which #{} does not; squash those first or squash into a later change", src.change_id.short(8), outside.join(", "), into.short(12)));

        }

        let ok_change = |h: &ChangeHash| *h == *into || closure.contains(h);

        let ok_node = |n: &NodeId| n.is_root() || closure.tree().introducer(n).is_some();

        let too_new = |what: &str| RepoError::Msg(format!("{what} was introduced after change #{}; squash into a later change instead", into.short(12)));

        let src_added: BTreeSet<NodeId> = src.tree_ops.iter().filter_map(|o| if let TreeOp::AddNode { node, .. } = o { Some(*node) } else { None }).collect();

        for op in &src.tree_ops {

            match op {

                TreeOp::AddNode { parent, .. } => {

                    if !ok_node(parent) && !src_added.contains(parent) {

                        return Err(too_new("the parent directory"));

                    }

                }

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

                    if !ok_node(node) || !ok_change(&placement.change) {

                        return Err(too_new("a removed file"));

                    }

                }

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

                    if !ok_node(node) || !ok_change(&old.change) || (!ok_node(parent) && !src_added.contains(parent)) {

                        return Err(too_new("a moved file"));

                    }

                }

                TreeOp::SetMode { node, old, .. } => {

                    if !ok_node(node) || !ok_change(&old.change) {

                        return Err(too_new("a file whose mode changed"));

                    }

                }

            }

        }

        for e in &src.edits {

            let n = e.node();

            if !src_added.contains(&n) && !ok_node(&n) {

                return Err(too_new("an edited file"));

            }

            let refs: Vec<ChangeHash> = match e {

                Edit::Insert { after, before, .. } => [after, before].iter().filter_map(|r| if let AtomRef::Atom { change, .. } = r { Some(*change) } else { None }).collect(),

                Edit::Delete { atoms, .. } => atoms.iter().map(|r| r.change).collect(),

                Edit::Replace { .. } => vec![],

            };

            if refs.iter().any(|h| !h.is_zero() && !ok_change(h)) {

                return Err(too_new("an edited line"));

            }

        }

        // Compose dst then src, with src's references to dst turned into

        // self references and its own atoms shifted past dst's.

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

        for e in &dst.edits {

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

                *per_node.entry(*node).or_default() += lines.len() as u32;

            }

        }

        let op_offset = dst.tree_ops.len() as u32;

        let fold_op = |r: OpRef| -> OpRef {

            if r.change == *into {

                OpRef { change: ObjectRef::ZERO, index: r.index }

            } else if r.change.is_zero() {

                OpRef { change: ObjectRef::ZERO, index: r.index + op_offset }

            } else {

                r

            }

        };

        let mut tree_ops = dst.tree_ops.clone();

        for op in &src.tree_ops {

            tree_ops.push(match op {

                TreeOp::RemoveNode { node, placement } => TreeOp::RemoveNode { node: *node, placement: fold_op(*placement) },

                TreeOp::Move { node, old, parent, name } => TreeOp::Move { node: *node, old: fold_op(*old), parent: *parent, name: name.clone() },

                TreeOp::SetMode { node, old, mode } => TreeOp::SetMode { node: *node, old: fold_op(*old), mode: *mode },

                add => add.clone(),

            });

        }

        let mut edits = dst.edits.clone();

        for e in &src.edits {

            edits.push(match e {

                Edit::Insert { node, after, before, lines } => Edit::Insert {

                    node: *node,

                    after: fold_atom(*after, into, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    before: fold_atom(*before, into, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    lines: lines.clone(),

                },

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

                    node: *node,

                    atoms: atoms

                        .iter()

                        .map(|r| {

                            if r.change == *into {

                                AtomRange { change: ObjectRef::ZERO, from: r.from, to: r.to }

                            } else if r.change.is_zero() {

                                let off = per_node.get(node).copied().unwrap_or(0);

                                AtomRange { change: ObjectRef::ZERO, from: r.from + off, to: r.to + off }

                            } else {

                                *r

                            }

                        })

                        .collect(),

                },

                other => other.clone(),

            });

        }

        let mut new = Change {

            change_id: dst.change_id,

            deps: vec![],

            author: dst.author,

            hlc: Hlc::now(),

            message: dst.message.clone(),

            tree_ops,

            edits,

            kind: if dst.kind == ChangeKind::Resolution || src.kind == ChangeKind::Resolution { ChangeKind::Resolution } else { ChangeKind::Normal },

        };

        let beneath = self.load_state(&dst.deps)?;

        let mut deps: BTreeSet<ChangeHash> = dst.deps.iter().copied().collect();

        deps.extend(referenced_changes(&new, &beneath).into_iter().filter(|h| *h != *into && *h != *c));

        deps.extend(src.deps.iter().filter(|d| **d != *into).copied());

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

        new.normalize();

        // Dependents of dst keep their indices; dependents of src follow its

        // atoms and operations to their shifted places in the new change.

        let cmd = format!("oxy squash {} --into {}", src.change_id.short(8), dst.change_id.short(8));

        let dst_new = self.rewrite_change(into, Some(&new), &Correspondence::identity(&dst), &cmd)?.unwrap();

        // src was rewritten along with the other dependents of dst; find it by ChangeId.

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

        let mut all = self.bookmark_heads()?;

        all.push(wc_hash);

        let state = self.load_state(&all)?;

        let src_now = state.changes().find(|(_, m)| m.change_id == src.change_id).map(|(h, _)| *h).unwrap_or(*c);

        let src_change = self.store.get_change(&src_now)?;

        let mut corr = Correspondence { atoms: HashMap::new(), ops: HashMap::new() };

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

        for e in &src_change.edits {

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

                let off = per_node.get(node).copied().unwrap_or(0);

                let idx = counts.entry(*node).or_default();

                for _ in lines {

                    corr.atoms.insert((*node, *idx), *idx + off);

                    *idx += 1;

                }

            }

        }

        for i in 0..src_change.tree_ops.len() as u32 {

            corr.ops.insert(i, i + op_offset);

        }

        let final_new = self.store.get_change(&dst_new)?;

        self.rewrite_change(&src_now, Some(&final_new), &corr, &cmd)?;

        Ok(dst_new)

    }

    /// Re-express change `c` against the state `onto` names (spec §8.5): its

    /// effect on the files it touches is re-derived as edits against that

    /// state. Keeps the ChangeId; dependents follow by content.

    pub fn rebase(&self, c: &ChangeHash, onto: &[ChangeHash]) -> Result<ChangeHash> {

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

        if old.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; check out the new base instead");

        }

        let target = self.load_state(onto)?;

        if target.contains(c) {

            return fail(format!("#{} is already part of the target state", c.short(12)));

        }

        let onto = target.maximal(onto);

        let target_snapshot = target.materialize();

        let before = self.load_state(&old.deps)?.materialize();

        let after = self.load_state(&[*c])?.materialize();

        // The paths whose file differs between the state with and without c.

        let mut touched: BTreeSet<String> = BTreeSet::new();

        for p in before.files.keys().chain(after.files.keys()) {

            match (before.files.get(p), after.files.get(p)) {

                (Some(a), Some(b)) if a.kind == b.kind && a.mode == b.mode && a.content == b.content => {}

                _ => {

                    touched.insert(p.clone());

                }

            }

        }

        for p in &touched {

            if target_snapshot.files.get(p).is_some_and(|f| f.is_conflicted()) {

                return fail(format!("{p} is conflicted in the target state; resolve it first"));

            }

        }

        // Entries: the target's files, with touched paths as c leaves them.

        let mut entries: BTreeMap<String, FsEntry> = BTreeMap::new();

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

        let content_of = |f: &crate::state::FileState| -> Result<Option<Vec<u8>>> {

            Ok(match &f.content {

                FileContent::Dir => None,

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

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

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

                    None => None,

                },

            })

        };

        for (p, f) in &target_snapshot.files {

            if touched.contains(p) {

                continue;

            }

            if let Some(content) = content_of(f)? {

                entries.insert(p.clone(), FsEntry::new(f.kind, f.mode.exec, content));

            }

        }

        for p in &touched {

            if let Some(f) = after.files.get(p) {

                if let Some(content) = content_of(f)? {

                    entries.insert(p.clone(), FsEntry::new(f.kind, f.mode.exec, content));

                }

                if !target_snapshot.files.contains_key(p) {

                    reuse.insert(p.clone(), (f.node, f.kind));

                }

            }

        }

        let built = self.build_from_entries(&target, &target_snapshot, reuse, &entries)?;

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

            return fail("rebasing would leave the change empty; the target already has its effect");

        }

        let mut new = Change {

            change_id: old.change_id,

            deps: vec![],

            author: old.author,

            hlc: Hlc::now(),

            message: old.message.clone(),

            tree_ops: built.tree_ops,

            edits: built.edits,

            kind: if built.resolves { ChangeKind::Resolution } else { ChangeKind::Normal },

        };

        let mut deps: BTreeSet<ChangeHash> = onto.iter().copied().collect();

        deps.extend(referenced_changes(&new, &target));

        deps.extend(built.contributors.iter().copied());

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

        new.normalize();

        let corr = Correspondence::by_content(&old, &new);

        let cmd = format!("oxy rebase {} --onto {}", old.change_id.short(8), onto.iter().map(|h| h.short(12)).collect::<Vec<_>>().join(" "));

        Ok(self.rewrite_change(c, Some(&new), &corr, &cmd)?.unwrap())

    }

}

#[test]

fn squash_folds_a_change_into_its_dependency() {

    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\n");

    let a = repo.commit("A", &[]).unwrap();

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

    let c = repo.commit("C", &[]).unwrap();

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

    let e = repo.commit("E", &[]).unwrap();

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

    let b = repo.commit("B", &[]).unwrap();

    let id_a = repo.store().get_change(&a).unwrap().change_id;

    let id_e = repo.store().get_change(&e).unwrap().change_id;

    // E depends on C which A lacks: refused, naming it.

    let err = repo.squash(&e, &a).unwrap_err().to_string();

    assert!(err.contains(&c.short(12)), "{err}");

    // C into A: A' has both, C is gone, E follows and still reads the same.

    let a2 = repo.squash(&c, &a).unwrap();

    let a2c = repo.store().get_change(&a2).unwrap();

    assert_eq!(a2c.change_id, id_a);

    assert!(a2c.deps.is_empty());

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

    let st = repo.load_state(&heads).unwrap();

    assert!(!st.contains(&c) && !st.contains(&a) && !st.contains(&e));

    let e2 = st.changes().find(|(_, m)| m.change_id == id_e).map(|(h, _)| *h).unwrap();

    assert_eq!(repo.store().get_change(&e2).unwrap().deps, vec![a2], "E now depends on A' alone");

    let files = st.materialize().files;

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

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

    assert!(st.contains(&b));

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

    assert_eq!(repo.log().unwrap().len(), 4, "working copy, B, E', A'");

    // Undo restores the three original changes.

    repo.undo().unwrap();

    repo.undo().unwrap();

    let st = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap();

    assert!(st.contains(&c) && st.contains(&a) && st.contains(&e));

}

#[test]

fn rebase_re_expresses_a_change_against_another_base() {

    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\n");

    let a = repo.commit("A", &[]).unwrap();

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

    let c = repo.commit("C: append 3", &[]).unwrap();

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

    let e = repo.commit("E: append 4", &[]).unwrap();

    // A different base: A plus a change that prepends a line.

    repo.checkout(&[a], true, "checkout").unwrap();

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

    let d = repo.commit("D: prepend 0", &[]).unwrap();

    let id_c = repo.store().get_change(&c).unwrap().change_id;

    let id_e = repo.store().get_change(&e).unwrap().change_id;

    // Rebase C onto D: its effect (append 3) re-derived against D's text.

    let c2 = repo.rebase(&c, &[d]).unwrap();

    let c2c = repo.store().get_change(&c2).unwrap();

    assert_eq!(c2c.change_id, id_c);

    assert!(c2c.deps.contains(&d), "{:?}", c2c.deps);

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

    let st = repo.load_state(&heads).unwrap();

    assert!(!st.contains(&c) && st.contains(&d));

    let e2 = st.changes().find(|(_, m)| m.change_id == id_e).map(|(h, _)| *h).unwrap();

    let e2deps = repo.store().get_change(&e2).unwrap().deps;

    assert!(e2deps.contains(&c2) && !e2deps.contains(&c) && e2deps.contains(&a), "E follows C by content and still depends on A, which introduced the file: {e2deps:?}");

    let files = st.materialize().files;

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

    assert!(!files["a.txt"].is_conflicted());

    // Rebasing onto a state that already contains the change is refused.

    assert!(repo.rebase(&c2, &[c2]).is_err());

    let err = repo.rebase(&e2, &[d]).unwrap_err().to_string();

    assert!(err.contains("empty") || err.contains("already"), "{err}");

}

    /// `(node, old atom index)` → new atom index. Absent means the atom no

    /// longer exists.

    pub atoms: HashMap<(crate::ids::NodeId, u32), u32>,

                    atoms.insert((*node, *idx), *idx);

        let ops = (0..change.tree_ops.len() as u32).map(|i| (i, i)).collect();

        Correspondence { atoms, ops }

    }

    /// Match `old`'s atoms to `new`'s by content, per node, in order (the

    /// correspondence of a re-derived change, spec §8.5); operations match

    /// by node and variant.

    pub fn by_content(old: &Change, new: &Change) -> Correspondence {

        let lines_of = |c: &Change| -> HashMap<crate::ids::NodeId, Vec<Vec<u8>>> {

            let mut m: HashMap<crate::ids::NodeId, Vec<Vec<u8>>> = HashMap::new();

            for e in &c.edits {

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

                    m.entry(*node).or_default().extend(lines.iter().cloned());

                }

            }

            m

        };

        let (a, b) = (lines_of(old), lines_of(new));

        let mut atoms = HashMap::new();

        for (node, olds) in &a {

            let Some(news) = b.get(node) else { continue };

            let mut j = 0usize;

            for (i, line) in olds.iter().enumerate() {

                while j < news.len() && news[j] != *line {

                    j += 1;

                }

                if j < news.len() {

                    atoms.insert((*node, i as u32), j as u32);

                    j += 1;

                }

            }

        }

        let mut ops = HashMap::new();

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

            if let Some(j) = new.tree_ops.iter().position(|n| n.node() == op.node() && std::mem::discriminant(n) == std::mem::discriminant(op)) {

                ops.insert(i as u32, j as u32);

            }

    node: crate::ids::NodeId,

            out.push(Chain { node: *node, first: *idx, last: *idx + lines.len() as u32 - 1, after: *after, before: *before });

            if let Some(nj) = corr.atoms.get(&(ch.node, j)) {

    let map_anchor = |r: AtomRef, node: &crate::ids::NodeId, want_after: bool, notes: &mut Vec<String>| -> AtomRef {

                Some(Replacement::Change(nh)) => match corrs[&change].atoms.get(&(*node, index)) {

                after: map_anchor(*after, node, true, notes),

                before: map_anchor(*before, node, false, notes),

                            Some(Replacement::Change(nh)) => match corrs[&r.change].atoms.get(&(*node, i)) {

        let corr = Correspondence { atoms: [((f, 0), 0)].into_iter().collect(), ops: [(0, 0)].into_iter().collect() };

oxy squash 658990aa --into 9df9ac29     # fold a change into one it depends on

oxy rebase 658990aa --onto feature      # re-express a change against another base

ChangeIds. Because unrelated changes already coexist, `rebase` is rarely

needed; its job is to change what a change is said to build on, for instance

to drop a dependency on something you are about to abandon. Where a dependent referred to a line that no longer exists, the

- [x] Squash (spec §8.5): `oxy squash CHANGE --into DEST` generalising `amend --into`, with rewrite propagation.

- [x] Rebase (spec §8.5): `oxy rebase CHANGE --onto HEADS..` re-deriving edits against a new base; refused on conflicted files.

- [x] Guide, README and §26.1 updated for each; spec changelog per item.

| **Status** | Draft 0.8a |

| Rewrites (§8.4, §8.5) | Implemented: describe, amend (also into older changes), split (any change), abandon, squash, rebase; orphaned references re-anchored |

*Changelog.* 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).

Draft 0.8 (2026-09-27): subrepositories with Oxygen and Git pins (§7.8, §23); squash and rebase defined as history edits (§8.5); multiple bookmarks per repository with a per-workspace current bookmark and `oxy merge` (§10.1); partial and interactive commits (§12.3); blame and bisect (§27); open questions moved to §28.

    /// Fold CHANGE into one of its dependencies (keeps that change's id)

    Squash {

        change: String,

        #[arg(long)]

        into: String,

    },

    /// Re-express CHANGE against another base state

    Rebase {

        change: String,

        /// The changes, bookmark or tag whose state becomes the new base

        #[arg(long, required = true, num_args = 1..)]

        onto: Vec<String>,

    },

        Cmd::Squash { change, into } => workspace::squash(&change, &into),

        Cmd::Rebase { change, onto } => workspace::rebase(&change, &onto),

pub fn squash(change: &str, into: &str) -> Result<i32> {

    let repo = open()?;

    let c = repo.resolve_change(change)?;

    let d = repo.resolve_change(into)?;

    let sp = ui::spinner("Squashing…");

    let h = repo.squash(&c, &d)?;

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

    sp.done(&format!("{} into {} {}  {}", ui::done("Squashed"), ui::id(short_id(&new)), ui::hash(format!("#{}", h.short(12))), ui::subject(subject_of(&new.message))));

    Ok(0)

}

pub fn rebase(change: &str, onto: &[String]) -> Result<i32> {

    let repo = open()?;

    let c = repo.resolve_change(change)?;

    let mut heads = Vec::new();

    for o in onto {

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

    }

    let sp = ui::spinner("Rebasing…");

    let h = repo.rebase(&c, &heads)?;

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

    sp.done(&format!("{} {} {}  {}", ui::done("Rebased"), ui::id(short_id(&new)), ui::hash(format!("#{}", h.short(12))), ui::dim(format!("now depends on {}", plural(new.deps.len(), "change")))));

    Ok(0)

}