Method stale_files_since_commit

src/tracedecay/indexing.rs:1220–1294

Computes the repo-relative paths changed between `base_commit` and the current git HEAD via a gix tree diff (both directions, including deletions), for diff-scoped incremental syncs by the watcher. Returns: - `Some(paths)` (forward-slash normalized) on a successful bounded diff; - `None` when `base_commit` is missing/unreachable (force-push, gc) — the caller must fall back to a full [`find_stale_

(
        &self,
        base_commit: &str,
        escalation_limit: usize,
    )

    ///
    /// Does not touch the DB; the watcher wires it into `sync_if_stale_silent`.
    pub fn stale_files_since_commit(
        &self,
        base_commit: &str,
        escalation_limit: usize,
    ) -> Option<Vec<String>> {
        let repo = gix::open(&self.project_root).ok()?;

        let base_tree = repo
            .rev_parse_single(base_commit)
            .ok()?
            .object()
            .ok()?
            .peel_to_tree()
            .ok()?;

        let head_tree = repo.head_commit().ok()?.tree().ok()?;

        let mut changed: HashSet<String> = HashSet::new();
        base_tree
            .changes()
            .ok()?
            .for_each_to_obtain_tree(&head_tree, |change| {
                use gix::object::tree::diff::Change;
                {
                    let mut push = |loc: &gix::bstr::BStr, mode: &gix::object::tree::EntryMode| {
                        if !mode.is_tree() {
                            changed.insert(loc.to_string());
                        }
                    };
                    match &change {
                        Change::Addition {
                            location,
                            entry_mode,
                            ..
                        }
                        | Change::Modification {
                            location,
                            entry_mode,
                            ..
                        }
                        | Change::Deletion {
                            location,
                            entry_mode,
                            ..
                        } => push(location, entry_mode),
                        Change::Rewrite {
                            source_location,
                            source_entry_mode,
                            location,
                            entry_mode,
                            ..
                        } => {
                            push(source_location, source_entry_mode);
                            push(location, entry_mode);
                        }
                    }
                }
                // Stop early once the change set is clearly a full-sync case;