Function commit_files

crates/flowtrace-cli/src/git.rs:112–155

Stage exactly the listed trace-relative paths and commit. Replaces the `add -A` sweep with an explicit declaration of what this commit contains. Caller is responsible for ensuring every path exists on disk.

(root: &Path, msg: &str, files: &[&str])

/// `add -A` sweep with an explicit declaration of what this commit contains.
/// Caller is responsible for ensuring every path exists on disk.
pub fn commit_files(root: &Path, msg: &str, files: &[&str]) -> Result<()> {
    let repo = open_or_init(root)?;
    // Serialize cross-process writes to this repo. Held until function exits.
    let _lock = CommitLock::acquire(&repo)?;
    let mut index = repo.index().context("reading git index")?;

    let translate_one = |rel: &str| -> String {
        match repo_subpath(&repo, root) {
            Some(sub) => sub.join(rel).to_string_lossy().replace('\\', "/"),
            None => rel.to_string(),
        }
    };

    for f in files {
        let translated = translate_one(f);
        index
            .add_path(Path::new(&translated))
            .with_context(|| format!("staging {}", translated))?;
    }
    index.write().context("writing git index")?;

    let head = repo.head().ok();
    let tree_oid = index.write_tree().context("writing tree from index")?;

    // No-op guard: tree unchanged vs HEAD.
    if let Some(head_ref) = head.as_ref() {
        if let Ok(parent_commit) = head_ref.peel_to_commit() {
            if parent_commit.tree_id() == tree_oid {
                return Ok(());
            }
        }
    }

    let tree = repo.find_tree(tree_oid)?;
    let sig = signature()?;
    let parents: Vec<git2::Commit> = match head.as_ref() {
        Some(h) => vec![h.peel_to_commit()?],
        None => vec![],
    };
    let parent_refs: Vec<&git2::Commit> = parents.iter().collect();
    repo.commit(Some("HEAD"), &sig, &sig, msg, &tree, &parent_refs)
        .context("git commit")?;
    Ok(())
}

pub async fn commit_files_async(root: PathBuf, msg: String, files: Vec<String>) -> Result<()> {
    tokio::task::spawn_blocking(move || {