Rename detection: a removed and an added file at least 50% alike become a Move of the existing node, on snapshots and Git import; Renamed status (spec 0.6o) 6e723b81f5b9

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

    /// Moved from another path (detected by similarity, tracked as a placement change).

    Renamed,

        // Rename detection (spec §7.1, §23): a removed file and an added file

        // of the same kind whose contents are at least half alike become one

        // move of the same node, so identity survives across the rename.

        let renames = detect_renames(base_snapshot, fs_entries, |p| self.in_scope(p));

        let renamed_from: HashMap<&str, &str> = renames.iter().map(|(old, new)| (new.as_str(), old.as_str())).collect();

        let renamed_to: HashMap<&str, &str> = renames.iter().map(|(old, new)| (old.as_str(), new.as_str())).collect();

                None => match renamed_from.get(path.as_str()) {

                    Some(old) => b.move_path(self, old, path, fs_entry, &base_snapshot.files[*old])?,

                    None => b.add_path(self, path, fs_entry)?,

                },

            if fs_entries.contains_key(path) || !self.in_scope(path) || renamed_to.contains_key(path.as_str()) {

    /// Move the node at `old` to `new` and apply `e`'s content to it.

    fn move_path(&mut self, repo: &Repo, old: &str, new: &str, e: &FsEntry, expected: &crate::state::FileState) -> Result<()> {

        let entry = &self.base_snapshot.tree.entries[old];

        let (dir, name) = split_path(new);

        let parent = self.ensure_dir(dir);

        self.tree_ops.push(TreeOp::Move { node: expected.node, old: op_ref(entry.placement), parent, name: name.to_string() });

        self.update_path(repo, old, e, expected)?;

        // update_path reports under the old path; the rename is what the user sees.

        self.statuses.retain(|s| s.path != old);

        self.statuses.push(PathStatus { path: new.to_string(), status: ChangeStatus::Renamed });

        Ok(())

    }

/// Pair removed files with added files of the same kind whose contents are

/// at least `RENAME_THRESHOLD` percent alike, best matches first. Beyond

/// `RENAME_LIMIT` candidate pairs only identical contents are paired.

const RENAME_THRESHOLD: u32 = 50;

const RENAME_LIMIT: usize = 10_000;

fn detect_renames(base_snapshot: &Snapshot, fs_entries: &BTreeMap<String, FsEntry>, in_scope: impl Fn(&str) -> bool) -> Vec<(String, String)> {

    let removed: Vec<(&String, &crate::state::FileState)> = base_snapshot

        .files

        .iter()

        .filter(|(p, f)| f.kind != NodeKind::Dir && !fs_entries.contains_key(*p) && in_scope(p) && !f.is_conflicted())

        .collect();

    let added: Vec<(&String, &FsEntry)> = fs_entries.iter().filter(|(p, e)| e.kind != NodeKind::Dir && !base_snapshot.files.contains_key(*p)).collect();

    if removed.is_empty() || added.is_empty() {

        return vec![];

    }

    let exact_only = removed.len() * added.len() > RENAME_LIMIT;

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

        match &f.content {

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

            _ => None,

        }

    };

    let mut scored: Vec<(u32, usize, usize)> = Vec::new();

    for (ri, (_, f)) in removed.iter().enumerate() {

        let old = old_content(f);

        let old_blob = match &f.content {

            FileContent::Opaque { blobs } if blobs.len() == 1 => Some(blobs[0]),

            _ => None,

        };

        for (ai, (_, e)) in added.iter().enumerate() {

            if e.kind != f.kind {

                continue;

            }

            let score = match (&old, old_blob) {

                (Some(o), _) => {

                    if exact_only {

                        if *o == e.content { 100 } else { 0 }

                    } else {

                        similarity(o, &e.content)

                    }

                }

                (None, Some(b)) if Repo::blob_ref(&e.content) == b => 100,

                _ => 0,

            };

            if score >= RENAME_THRESHOLD {

                scored.push((score, ri, ai));

            }

        }

    }

    scored.sort_by(|a, b| b.0.cmp(&a.0).then(removed[a.1].0.cmp(removed[b.1].0)).then(added[a.2].0.cmp(added[b.2].0)));

    let mut used_r = vec![false; removed.len()];

    let mut used_a = vec![false; added.len()];

    let mut out = Vec::new();

    for (_, ri, ai) in scored {

        if used_r[ri] || used_a[ai] {

            continue;

        }

        used_r[ri] = true;

        used_a[ai] = true;

        out.push((removed[ri].0.clone(), added[ai].0.clone()));

    }

    out

}

/// Percentage of the larger file's bytes found in lines the two share

/// (multiset intersection of lines), like Git's similarity index.

pub fn similarity(a: &[u8], b: &[u8]) -> u32 {

    if a == b {

        return 100;

    }

    if a.is_empty() || b.is_empty() {

        return 0;

    }

    let mut counts: HashMap<&[u8], usize> = HashMap::new();

    for l in split_lines(a) {

        *counts.entry(l).or_default() += 1;

    }

    let mut shared = 0usize;

    for l in split_lines(b) {

        if let Some(n) = counts.get_mut(l) {

            if *n > 0 {

                *n -= 1;

                shared += l.len();

            }

        }

    }

    (shared * 100 / a.len().max(b.len())) as u32

}

    // A rename with a small edit is imported as a move of the same node.

    git(&["mv", "src/lib.rs", "src/lib2.rs"]);

    write(&g, "src/lib2.rs", b"pub fn a() {}\npub fn b() {}\npub fn c() {}\npub fn d() {}\n");

    git(&["add", "."]);

    git(&["commit", "-q", "-m", "rename lib"]);

    assert_eq!(fs::read(dest.join("src/lib2.rs")).unwrap(), b"pub fn a() {}\npub fn b() {}\npub fn c() {}\npub fn d() {}\n");

    assert!(!dest.join("src/lib.rs").exists());

    let tip = repo.log().unwrap().into_iter().find(|e| e.change.message.starts_with("rename lib")).unwrap();

    let c = repo.store().get_change(&tip.hash).unwrap();

    assert!(c.tree_ops.iter().any(|op| matches!(op, TreeOp::Move { name, .. } if name == "lib2.rs")), "{:?}", c.tree_ops);

    assert!(!c.tree_ops.iter().any(|op| matches!(op, TreeOp::AddNode { .. })));

    let out = std::process::Command::new("git").arg("-C").arg(&mirror).args(["show", "main:src/lib2.rs"]).output().unwrap();

    assert_eq!(String::from_utf8_lossy(&out.stdout), "pub fn a() {}\npub fn b() {}\npub fn c() {}\npub fn d() {}\n");

    assert!(!out.status.success(), "the old path is gone from the export");

#[test]

fn renames_are_detected_and_tracked_as_moves() {

    hermetic();

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

    let root = dir.path();

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

    write(root, "src/old.rs", b"fn a() {}\nfn b() {}\nfn c() {}\nfn d() {}\n");

    write(root, "img.bin", b"\x89PNG\0\0\x01\x02");

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

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

    let node_old = repo.load_state(&[h1]).unwrap().materialize().files["src/old.rs"].node;

    let node_img = repo.load_state(&[h1]).unwrap().materialize().files["img.bin"].node;

    // Rename with a small edit, a binary moved unchanged, and a rewrite

    // that shares nothing with the removed file.

    fs::remove_file(root.join("src/old.rs")).unwrap();

    write(root, "lib/new.rs", b"fn a() {}\nfn b() {}\nfn c() {}\nfn e() {}\n");

    fs::remove_file(root.join("img.bin")).unwrap();

    write(root, "assets/img.bin", b"\x89PNG\0\0\x01\x02");

    fs::remove_file(root.join("tiny.txt")).unwrap();

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

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

    let statuses: Vec<(&str, ChangeStatus)> = snap.statuses.iter().map(|s| (s.path.as_str(), s.status)).collect();

    assert_eq!(

        statuses,

        vec![("assets/img.bin", ChangeStatus::Renamed), ("lib/new.rs", ChangeStatus::Renamed), ("other.txt", ChangeStatus::Added), ("src", ChangeStatus::Removed), ("tiny.txt", ChangeStatus::Removed)]

    );

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

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

    let moves: Vec<_> = c.tree_ops.iter().filter(|op| matches!(op, TreeOp::Move { .. })).collect();

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

    assert!(c.tree_ops.iter().any(|op| matches!(op, TreeOp::Move { node, name, .. } if *node == node_old && name == "new.rs")));

    assert!(c.tree_ops.iter().any(|op| matches!(op, TreeOp::Move { node, name, .. } if *node == node_img && name == "img.bin")));

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

    assert_eq!(snap.files["lib/new.rs"].node, node_old, "the node survives the rename");

    assert!(matches!(&snap.files["lib/new.rs"].content, FileContent::Text { bytes, .. } if bytes == b"fn a() {}\nfn b() {}\nfn c() {}\nfn e() {}\n"));

    assert!(!snap.files.contains_key("src/old.rs") && !snap.files.contains_key("src"));

    assert!(render_change(&c, &repo.load_state(&[h1]).unwrap(), &repo.load_state(&[h1]).unwrap().materialize()).contains("R "));

    // A fresh checkout reproduces the tree.

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

    let clone = Repo::clone(&root.to_string_lossy(), other.path()).unwrap();

    assert_eq!(fs::read(other.path().join("lib/new.rs")).unwrap(), b"fn a() {}\nfn b() {}\nfn c() {}\nfn e() {}\n");

    assert!(!other.path().join("src").exists());

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

    // Similarity is line based, byte weighted.

    assert_eq!(similarity(b"a\nb\n", b"a\nb\n"), 100);

    assert_eq!(similarity(b"a\nb\nc\nd\n", b"a\nb\nx\ny\n"), 50);

    assert_eq!(similarity(b"hello\n", b"world\n"), 0);

    assert_eq!(similarity(b"", b"x\n"), 0);

}

| **Status** | Draft 0.6o |

Renames and moves are placement changes, so rename tracking is exact once recorded. A working copy has no way to report a move, so when a snapshot finds a removed file and an added file of the same kind whose contents are at least 50% alike (the share of the larger file's bytes found in lines both have; opaque files must be identical), it records a `Move` of the existing node rather than a removal and an addition. Beyond 10,000 candidate pairs only identical contents are paired. The same detection applies to Git import (§23).

- **Import.** Each Git commit becomes one change whose edits are the diff between the union of its parents' states and its tree, so a merge commit becomes a resolution exactly when the parents conflict in the change model, and an ordinary change otherwise. The commit's author and hash are recorded as `Git-Author` and `Git-Commit` trailers; the author key is the zero KeyId, since nobody can sign on the original author's behalf. Submodule entries are skipped. Renames are detected on import exactly as for a snapshot (§7.1, similarity ≥ 50%), then tracked exactly. The Git commit's `Change-Id` trailer, if present and 128 bits, becomes the ChangeId; otherwise one is derived as BLAKE3-128 of the Git commit hash, so re-import is idempotent. Note that a change's own closure is what it depends on, not the Git snapshot: the imported bookmark's state equals the Git tree, but checking out an individual imported change yields only the files it and its dependencies touch.

*Changelog.* Draft 0.6o (2026-09-27): rename detection on snapshot and Git import records moves of the existing node (§7.1, §23).

Draft 0.6n (2026-09-27): identity lifecycle (§14.2): every identity edit is a rotation that supersedes rather than revokes, expiry bounds authenticated changes, revocations recorded locally; policy proposals for multi-signer updates, chain-aware authorization, bootstrap rule, and policy history on `refs` and in push bundles (§14.5, §16.3).

        "R" => ("➜", ">", "renamed"),

        "V" => ("✔", "r", "resolved"),

        "A" | "V" => s(text).green().to_string(),

        "R" => s(text).cyan().to_string(),

        ChangeStatus::Renamed => "R",

        ChangeStatus::Resolved => "V",