chant/worktree/

git_ops.rs

//! Low-level git worktree operations.
//!
//! Provides utilities for creating, managing, and removing git worktrees.
//! These functions handle the mechanics of worktree lifecycle management.
//!
//! # Doc Audit
//! - audited: 2026-01-25
//! - docs: scale/isolation.md
//! - ignore: false

use anyhow::{Context, Result};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::Mutex;
use std::time::Duration;

/// Run a git command with arguments in a specific directory and return stdout on success.
///
/// # Errors
///
/// Returns an error if the command fails to execute or exits with non-zero status.
fn run_git_in_dir(args: &[&str], work_dir: Option<&Path>) -> Result<String> {
    let mut cmd = Command::new("git");
    cmd.args(args);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }

    let output = cmd
        .output()
        .context(format!("Failed to run git {}", args.join(" ")))?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("git {} failed: {}", args.join(" "), stderr);
    }

    Ok(String::from_utf8_lossy(&output.stdout).to_string())
}

/// Global mutex to serialize worktree creation operations.
///
/// This prevents race conditions when multiple concurrent `git worktree add` calls
/// attempt to access git's internal locks simultaneously.
static WORKTREE_CREATION_LOCK: Mutex<()> = Mutex::new(());

/// Returns the worktree path for a given spec ID.
///
/// This does not check whether the worktree exists.
pub fn worktree_path_for_spec(spec_id: &str, project_name: Option<&str>) -> PathBuf {
    match project_name.filter(|n| !n.is_empty()) {
        Some(name) => PathBuf::from(format!("/tmp/chant-{}-{}", name, spec_id)),
        None => PathBuf::from(format!("/tmp/chant-{}", spec_id)),
    }
}

/// Returns the worktree path for a spec if an active worktree exists.
///
/// Returns Some(path) if the worktree directory exists, None otherwise.
pub fn get_active_worktree(spec_id: &str, project_name: Option<&str>) -> Option<PathBuf> {
    let path = worktree_path_for_spec(spec_id, project_name);
    if path.exists() && path.is_dir() {
        Some(path)
    } else {
        None
    }
}

/// Checks if a worktree has uncommitted changes.
///
/// # Arguments
///
/// * `worktree_path` - Path to the worktree
///
/// # Returns
///
/// Ok(true) if there are uncommitted changes (staged or unstaged), Ok(false) if clean.
pub fn has_uncommitted_changes(worktree_path: &Path) -> Result<bool> {
    let status_output = run_git_in_dir(&["status", "--porcelain"], Some(worktree_path))?;
    Ok(!status_output.trim().is_empty())
}

/// Commits changes in a worktree.
///
/// # Arguments
///
/// * `worktree_path` - Path to the worktree
/// * `message` - Commit message
///
/// # Returns
///
/// Ok(commit_hash) if commit was successful, Err if failed.
pub fn commit_in_worktree(worktree_path: &Path, message: &str) -> Result<String> {
    // Stage all changes
    run_git_in_dir(&["add", "-A"], Some(worktree_path))
        .context("Failed to stage changes in worktree")?;

    // Check if there are any changes to commit
    let status_output = run_git_in_dir(&["status", "--porcelain"], Some(worktree_path))?;
    if status_output.trim().is_empty() {
        // No changes to commit, return the current HEAD
        let hash = run_git_in_dir(&["rev-parse", "HEAD"], Some(worktree_path))?;
        return Ok(hash.trim().to_string());
    }

    // Commit the changes
    run_git_in_dir(&["commit", "-m", message], Some(worktree_path))
        .context("Failed to commit changes in worktree")?;

    // Get the commit hash
    let hash = run_git_in_dir(&["rev-parse", "HEAD"], Some(worktree_path))?;
    Ok(hash.trim().to_string())
}

/// Creates a new git worktree for the given spec.
///
/// This function is serialized to prevent concurrent `git worktree add` calls from
/// racing on git's internal locks. If worktree creation fails due to a lock error,
/// it will retry once after a short delay.
///
/// # Arguments
///
/// * `spec_id` - The specification ID (used to create unique worktree paths)
/// * `branch` - The branch name to create in the worktree
/// * `project_name` - Optional project name to namespace the worktree path
///
/// # Returns
///
/// The absolute path to the created worktree directory.
///
/// # Errors
///
/// Returns an error if:
/// - Git worktree creation fails after retry
/// - Directory cleanup/creation fails
pub fn create_worktree(spec_id: &str, branch: &str, project_name: Option<&str>) -> Result<PathBuf> {
    // Acquire the global lock to serialize worktree creation
    let _lock = WORKTREE_CREATION_LOCK
        .lock()
        .map_err(|e| anyhow::anyhow!("Failed to acquire worktree creation lock: {}", e))?;

    let worktree_path = worktree_path_for_spec(spec_id, project_name);

    // Check if worktree already exists
    if worktree_path.exists() {
        // Clean up existing worktree
        let _ = Command::new("git")
            .args([
                "worktree",
                "remove",
                "--force",
                &worktree_path.to_string_lossy(),
            ])
            .output();

        // Force remove directory if still present
        if worktree_path.exists() {
            let _ = std::fs::remove_dir_all(&worktree_path);
        }
    }

    // Check if branch already exists
    let output = Command::new("git")
        .args(["rev-parse", "--verify", branch])
        .output()
        .context("Failed to check if branch exists")?;

    if output.status.success() {
        // Branch exists - delete it forcefully
        let _ = Command::new("git").args(["branch", "-D", branch]).output();
    }

    // Attempt to create the worktree with retry on lock errors
    let max_attempts = 2;
    let mut last_error = None;

    for attempt in 1..=max_attempts {
        let output = Command::new("git")
            .args([
                "worktree",
                "add",
                "-b",
                branch,
                &worktree_path.to_string_lossy(),
            ])
            .output()
            .context("Failed to execute git worktree add")?;

        if output.status.success() {
            return Ok(worktree_path);
        }

        let stderr = String::from_utf8_lossy(&output.stderr);
        let error_msg = stderr.trim().to_string();

        // Check if this is a transient lock error
        let is_lock_error = error_msg.contains("lock")
            || error_msg.contains("unable to create")
            || error_msg.contains("already exists");

        last_error = Some(error_msg.clone());

        if is_lock_error && attempt < max_attempts {
            // Retry after a short delay
            eprintln!(
                "⚠️  [{}] Worktree creation failed (attempt {}/{}): {}. Retrying...",
                spec_id, attempt, max_attempts, error_msg
            );
            std::thread::sleep(Duration::from_millis(250));
        } else {
            // Not a lock error or out of retries
            break;
        }
    }

    // All attempts failed
    let error_msg = last_error.unwrap_or_else(|| "Unknown error".to_string());
    anyhow::bail!(
        "Failed to create worktree after {} attempts: {}",
        max_attempts,
        error_msg
    )
}

/// Copies the spec file from the main working directory to a worktree.
///
/// This ensures the worktree has the current spec state (e.g., in_progress status)
/// even when the change hasn't been committed to main yet.
///
/// # Arguments
///
/// * `spec_id` - The specification ID
/// * `worktree_path` - The path to the worktree
///
/// # Returns
///
/// Ok(()) if the spec file was successfully copied and committed.
///
/// # Errors
///
/// Returns an error if:
/// - The spec file doesn't exist in the main working directory
/// - The copy operation fails
/// - The commit fails
pub fn copy_spec_to_worktree(spec_id: &str, worktree_path: &Path) -> Result<()> {
    // Use absolute path from git root to avoid issues when current directory changes
    let git_root = std::env::current_dir().context("Failed to get current directory")?;
    let main_spec_path = git_root
        .join(".chant/specs")
        .join(format!("{}.md", spec_id));
    let worktree_specs_dir = worktree_path.join(".chant/specs");
    let worktree_spec_path = worktree_specs_dir.join(format!("{}.md", spec_id));

    // Ensure the .chant/specs directory exists in the worktree
    std::fs::create_dir_all(&worktree_specs_dir).context(format!(
        "Failed to create specs directory in worktree: {:?}",
        worktree_specs_dir
    ))?;

    // Copy the spec file from main to worktree
    std::fs::copy(&main_spec_path, &worktree_spec_path).context(format!(
        "Failed to copy spec file to worktree: {:?}",
        worktree_spec_path
    ))?;

    // Commit the updated spec in the worktree
    commit_in_worktree(
        worktree_path,
        &format!("chant({}): update spec status to in_progress", spec_id),
    )?;

    Ok(())
}

/// Isolates the worktree environment by removing all specs except the working spec.
///
/// This prevents agents from seeing sibling specs and getting confused about their task,
/// especially in group scenarios where many related specs exist.
///
/// # Arguments
///
/// * `spec_id` - The specification ID (the only spec to keep)
/// * `worktree_path` - The path to the worktree
///
/// # Returns
///
/// Ok(()) if the isolation was successful.
///
/// # Errors
///
/// Returns an error if:
/// - Directory operations fail
/// - The working spec doesn't exist in the worktree
pub fn isolate_worktree_specs(spec_id: &str, worktree_path: &Path) -> Result<()> {
    let worktree_specs_dir = worktree_path.join(".chant/specs");
    let worktree_archive_dir = worktree_path.join(".chant/archive");
    let working_spec_filename = format!("{}.md", spec_id);

    // Remove the archive directory entirely (agents don't need it)
    if worktree_archive_dir.exists() {
        std::fs::remove_dir_all(&worktree_archive_dir).context(format!(
            "Failed to remove archive directory in worktree: {:?}",
            worktree_archive_dir
        ))?;
    }

    // Remove all specs except the working spec
    if worktree_specs_dir.exists() {
        let entries = std::fs::read_dir(&worktree_specs_dir).context(format!(
            "Failed to read specs directory in worktree: {:?}",
            worktree_specs_dir
        ))?;

        for entry in entries {
            let entry = entry.context("Failed to read directory entry")?;
            let path = entry.path();

            // Skip if it's not a file
            if !path.is_file() {
                continue;
            }

            // Skip the working spec
            if let Some(filename) = path.file_name() {
                if filename == working_spec_filename.as_str() {
                    continue;
                }
            }

            // Remove all other spec files
            std::fs::remove_file(&path).context(format!(
                "Failed to remove spec file in worktree: {:?}",
                path
            ))?;
        }
    }

    Ok(())
}

/// Removes a git worktree and cleans up its directory.
///
/// This function is idempotent - it does not error if the worktree is already gone.
///
/// # Arguments
///
/// * `path` - The path to the worktree to remove
///
/// # Returns
///
/// Ok(()) if the worktree was successfully removed or didn't exist.
pub fn remove_worktree(path: &Path) -> Result<()> {
    // Try to remove the git worktree entry
    let _output = Command::new("git")
        .args(["worktree", "remove", &path.to_string_lossy()])
        .output()
        .context("Failed to run git worktree remove")?;

    // Even if git worktree remove fails, try to clean up the directory
    if path.exists() {
        std::fs::remove_dir_all(path)
            .context(format!("Failed to remove worktree directory at {:?}", path))?;
    }

    Ok(())
}

/// Result of a merge operation
#[derive(Debug, Clone)]
pub struct MergeCleanupResult {
    pub success: bool,
    pub has_conflict: bool,
    pub error: Option<String>,
}

/// Checks if a branch is behind the main branch (main has commits not in branch).
///
/// # Arguments
///
/// * `branch` - The branch name to check
/// * `main_branch` - The name of the main branch
/// * `work_dir` - Optional working directory for the git command
///
/// # Returns
///
/// Ok(true) if main has commits not in branch, Ok(false) otherwise.
fn branch_is_behind_main(branch: &str, main_branch: &str, work_dir: Option<&Path>) -> Result<bool> {
    let mut cmd = Command::new("git");
    cmd.args([
        "rev-list",
        "--count",
        &format!("{}..{}", branch, main_branch),
    ]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = cmd
        .output()
        .context("Failed to check if branch is behind main")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Failed to check branch status: {}", stderr);
    }

    let count_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
    let count: i32 = count_str
        .parse()
        .context(format!("Failed to parse commit count: {}", count_str))?;
    Ok(count > 0)
}

/// Rebases a branch onto the main branch.
///
/// # Arguments
///
/// * `branch` - The branch name to rebase
/// * `main_branch` - The name of the main branch
/// * `work_dir` - Optional working directory for the git command
///
/// # Returns
///
/// Ok(()) if rebase succeeded, Err if rebase had conflicts or failed.
fn rebase_branch_onto_main(branch: &str, main_branch: &str, work_dir: Option<&Path>) -> Result<()> {
    // Checkout the branch
    let mut cmd = Command::new("git");
    cmd.args(["checkout", branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = cmd
        .output()
        .context("Failed to checkout branch for rebase")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Failed to checkout branch: {}", stderr);
    }

    // Rebase onto main
    let mut cmd = Command::new("git");
    cmd.args(["rebase", main_branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = cmd.output().context("Failed to rebase onto main")?;

    if !output.status.success() {
        anyhow::bail!("Rebase had conflicts");
    }

    // Return to main branch
    let mut cmd = Command::new("git");
    cmd.args(["checkout", main_branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = cmd
        .output()
        .context("Failed to checkout main after rebase")?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!("Failed to checkout main: {}", stderr);
    }

    Ok(())
}

/// Aborts a rebase in progress and returns to main branch.
///
/// # Arguments
///
/// * `main_branch` - The name of the main branch
/// * `work_dir` - Optional working directory for the git command
///
/// This function is best-effort and does not return errors.
fn abort_rebase(main_branch: &str, work_dir: Option<&Path>) {
    // Abort the rebase
    let mut cmd = Command::new("git");
    cmd.args(["rebase", "--abort"]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let _ = cmd.output();

    // Try to ensure we're on main branch
    let mut cmd = Command::new("git");
    cmd.args(["checkout", main_branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let _ = cmd.output();
}

/// Merges a branch to main and cleans up.
///
/// # Arguments
///
/// * `branch` - The branch name to merge
/// * `main_branch` - The name of the main branch
/// * `no_rebase` - If true, skip automatic rebase even if branch is behind
///
/// # Returns
///
/// Returns a MergeCleanupResult indicating:
/// - success: true if merge succeeded and branch was deleted
/// - has_conflict: true if merge failed due to conflicts
/// - error: optional error message
///
/// If there are merge conflicts, the branch is preserved for manual resolution.
pub fn merge_and_cleanup(branch: &str, main_branch: &str, no_rebase: bool) -> MergeCleanupResult {
    merge_and_cleanup_in_dir(branch, main_branch, None, no_rebase)
}

/// Internal function that merges a branch to main with optional working directory.
fn merge_and_cleanup_in_dir(
    branch: &str,
    main_branch: &str,
    work_dir: Option<&Path>,
    no_rebase: bool,
) -> MergeCleanupResult {
    // Checkout main branch
    let mut cmd = Command::new("git");
    cmd.args(["checkout", main_branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = match cmd.output() {
        Ok(o) => o,
        Err(e) => {
            return MergeCleanupResult {
                success: false,
                has_conflict: false,
                error: Some(format!("Failed to checkout {}: {}", main_branch, e)),
            };
        }
    };

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        // Try to ensure we're on main branch before returning error
        let _ = crate::git::ensure_on_main_branch(main_branch);
        return MergeCleanupResult {
            success: false,
            has_conflict: false,
            error: Some(format!("Failed to checkout {}: {}", main_branch, stderr)),
        };
    }

    // Check if branch needs rebase (is behind main) and attempt rebase if needed
    if !no_rebase {
        match branch_is_behind_main(branch, main_branch, work_dir) {
            Ok(true) => {
                // Branch is behind main, attempt automatic rebase
                println!(
                    "Branch '{}' is behind {}, attempting automatic rebase...",
                    branch, main_branch
                );
                match rebase_branch_onto_main(branch, main_branch, work_dir) {
                    Ok(()) => {
                        println!("Rebase succeeded, proceeding with merge...");
                    }
                    Err(e) => {
                        // Rebase failed (conflicts), abort and preserve branch
                        abort_rebase(main_branch, work_dir);
                        return MergeCleanupResult {
                            success: false,
                            has_conflict: true,
                            error: Some(format!("Auto-rebase failed due to conflicts: {}", e)),
                        };
                    }
                }
            }
            Ok(false) => {
                // Branch is not behind main, proceed normally
            }
            Err(e) => {
                // Failed to check if branch is behind, log warning and proceed
                eprintln!(
                    "Warning: Failed to check if branch is behind {}: {}",
                    main_branch, e
                );
            }
        }
    }

    // Perform fast-forward merge
    let mut cmd = Command::new("git");
    cmd.args(["merge", "--ff-only", branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = match cmd.output() {
        Ok(o) => o,
        Err(e) => {
            return MergeCleanupResult {
                success: false,
                has_conflict: false,
                error: Some(format!("Failed to perform merge: {}", e)),
            };
        }
    };

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        // Check if this was a conflict
        let has_conflict = stderr.contains("CONFLICT") || stderr.contains("merge conflict");

        // Abort merge if there was a conflict to preserve the branch
        if has_conflict {
            let mut cmd = Command::new("git");
            cmd.args(["merge", "--abort"]);
            if let Some(dir) = work_dir {
                cmd.current_dir(dir);
            }
            let _ = cmd.output();
        }

        // Extract spec_id from branch name (strip prefix like "chant/" or "chant/frontend/")
        let spec_id = branch.rsplit('/').next().unwrap_or(branch);
        let error_msg = if has_conflict {
            crate::merge_errors::merge_conflict(spec_id, branch, main_branch)
        } else {
            crate::merge_errors::fast_forward_conflict(spec_id, branch, main_branch, &stderr)
        };
        // Try to ensure we're on main branch before returning error
        let _ = crate::git::ensure_on_main_branch(main_branch);
        return MergeCleanupResult {
            success: false,
            has_conflict,
            error: Some(error_msg),
        };
    }

    // Delete the local branch after successful merge
    let mut cmd = Command::new("git");
    cmd.args(["branch", "-d", branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    let output = match cmd.output() {
        Ok(o) => o,
        Err(e) => {
            return MergeCleanupResult {
                success: false,
                has_conflict: false,
                error: Some(format!("Failed to delete branch: {}", e)),
            };
        }
    };

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return MergeCleanupResult {
            success: false,
            has_conflict: false,
            error: Some(format!("Failed to delete branch '{}': {}", branch, stderr)),
        };
    }

    // Delete the remote branch (best-effort, don't fail if it doesn't exist)
    let mut cmd = Command::new("git");
    cmd.args(["push", "origin", "--delete", branch]);
    if let Some(dir) = work_dir {
        cmd.current_dir(dir);
    }
    // Ignore errors - remote branch may not exist or remote may be unavailable
    let _ = cmd.output();

    MergeCleanupResult {
        success: true,
        has_conflict: false,
        error: None,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use std::process::Command as StdCommand;

    /// Helper to initialize a temporary git repo for testing.
    fn setup_test_repo(repo_dir: &Path) -> Result<()> {
        fs::create_dir_all(repo_dir)?;

        let output = StdCommand::new("git")
            .args(["init", "-b", "main"])
            .current_dir(repo_dir)
            .output()
            .context("Failed to run git init")?;
        anyhow::ensure!(
            output.status.success(),
            "git init failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );

        let output = StdCommand::new("git")
            .args(["config", "user.email", "test@example.com"])
            .current_dir(repo_dir)
            .output()
            .context("Failed to run git config")?;
        anyhow::ensure!(
            output.status.success(),
            "git config email failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );

        let output = StdCommand::new("git")
            .args(["config", "user.name", "Test User"])
            .current_dir(repo_dir)
            .output()
            .context("Failed to run git config")?;
        anyhow::ensure!(
            output.status.success(),
            "git config name failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );

        // Create an initial commit
        fs::write(repo_dir.join("README.md"), "# Test")?;

        let output = StdCommand::new("git")
            .args(["add", "."])
            .current_dir(repo_dir)
            .output()
            .context("Failed to run git add")?;
        anyhow::ensure!(
            output.status.success(),
            "git add failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );

        let output = StdCommand::new("git")
            .args(["commit", "-m", "Initial commit"])
            .current_dir(repo_dir)
            .output()
            .context("Failed to run git commit")?;
        anyhow::ensure!(
            output.status.success(),
            "git commit failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );

        Ok(())
    }

    /// Helper to clean up test repos.
    fn cleanup_test_repo(repo_dir: &Path) -> Result<()> {
        if repo_dir.exists() {
            fs::remove_dir_all(repo_dir)?;
        }
        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_create_worktree_branch_already_exists() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-branch-exists");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let result = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let spec_id = "test-spec-branch-exists";
            let branch = "spec/test-spec-branch-exists";

            // Create the branch first
            let output = StdCommand::new("git")
                .args(["branch", branch])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git branch failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            create_worktree(spec_id, branch, None)
        };

        // Always restore original directory
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;
        cleanup_test_repo(&repo_dir)?;

        // Should now succeed - auto-clean existing branch and create fresh worktree
        assert!(
            result.is_ok(),
            "create_worktree should auto-clean and succeed"
        );
        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_merge_and_cleanup_with_conflict_preserves_branch() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-conflict-preserve");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let result = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let branch = "feature/conflict-test";

            // Create a feature branch that conflicts with main
            let output = StdCommand::new("git")
                .args(["branch", branch])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git branch failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            let output = StdCommand::new("git")
                .args(["checkout", branch])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git checkout branch failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            fs::write(repo_dir.join("README.md"), "feature version")?;

            let output = StdCommand::new("git")
                .args(["add", "."])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git add failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            let output = StdCommand::new("git")
                .args(["commit", "-m", "Modify README on feature"])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git commit feature failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            // Modify README on main differently
            let output = StdCommand::new("git")
                .args(["checkout", "main"])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git checkout main failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            fs::write(repo_dir.join("README.md"), "main version")?;

            let output = StdCommand::new("git")
                .args(["add", "."])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git add main failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            let output = StdCommand::new("git")
                .args(["commit", "-m", "Modify README on main"])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git commit main failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            // Now call merge_and_cleanup with explicit repo directory
            merge_and_cleanup_in_dir(branch, "main", Some(&repo_dir), false)
        };

        // Always restore original directory
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;

        // Check that branch still exists (wasn't deleted)
        let branch_check = StdCommand::new("git")
            .args(["rev-parse", "--verify", "feature/conflict-test"])
            .current_dir(&repo_dir)
            .output()?;

        cleanup_test_repo(&repo_dir)?;

        // Merge should fail (either due to conflict or non-ff situation)
        assert!(!result.success);
        // Branch should still exist
        assert!(branch_check.status.success());
        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_merge_and_cleanup_successful_merge() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-merge-success");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let result = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let branch = "feature/new-feature";

            // Create a fast-forwardable feature branch
            let output = StdCommand::new("git")
                .args(["branch", branch])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git branch failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            let output = StdCommand::new("git")
                .args(["checkout", branch])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git checkout failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            fs::write(repo_dir.join("feature.txt"), "feature content")?;

            let output = StdCommand::new("git")
                .args(["add", "."])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git add failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            let output = StdCommand::new("git")
                .args(["commit", "-m", "Add feature"])
                .current_dir(&repo_dir)
                .output()?;
            anyhow::ensure!(
                output.status.success(),
                "git commit failed: {}",
                String::from_utf8_lossy(&output.stderr)
            );

            // Merge the branch with explicit repo directory
            merge_and_cleanup_in_dir(branch, "main", Some(&repo_dir), false)
        };

        // Always restore original directory
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;

        // Check that branch no longer exists
        let branch_check = StdCommand::new("git")
            .args(["rev-parse", "--verify", "feature/new-feature"])
            .current_dir(&repo_dir)
            .output()?;

        cleanup_test_repo(&repo_dir)?;

        assert!(
            result.success && result.error.is_none(),
            "Merge result: {:?}",
            result
        );
        // Branch should be deleted after merge
        assert!(!branch_check.status.success());
        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_create_worktree_success() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-create-success");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let result = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let spec_id = "test-spec-create-success";
            let branch = "spec/test-spec-create-success";

            create_worktree(spec_id, branch, None)
        };

        // Always restore original directory
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;

        // Verify worktree was created successfully
        assert!(result.is_ok(), "create_worktree should succeed");
        let worktree_path = result.unwrap();
        assert!(worktree_path.exists(), "Worktree directory should exist");
        assert_eq!(
            worktree_path,
            PathBuf::from("/tmp/chant-test-spec-create-success"),
            "Worktree path should match expected format"
        );

        // Verify branch was created
        let branch_check = StdCommand::new("git")
            .args(["rev-parse", "--verify", "spec/test-spec-create-success"])
            .current_dir(&repo_dir)
            .output()?;
        assert!(branch_check.status.success(), "Branch should exist");

        // Cleanup
        let _ = StdCommand::new("git")
            .args(["worktree", "remove", worktree_path.to_str().unwrap()])
            .current_dir(&repo_dir)
            .output();
        let _ = fs::remove_dir_all(&worktree_path);
        cleanup_test_repo(&repo_dir)?;

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_copy_spec_to_worktree_success() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-copy-spec");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let result: Result<PathBuf> = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let spec_id = "test-spec-copy";
            let branch = "spec/test-spec-copy";

            // Create .chant/specs directory in main repo
            let specs_dir = repo_dir.join(".chant/specs");
            fs::create_dir_all(&specs_dir)?;

            // Create a test spec file in main repo
            let spec_path = specs_dir.join(format!("{}.md", spec_id));
            fs::write(
                &spec_path,
                "---\ntype: code\nstatus: in_progress\n---\n# Test Spec\n",
            )?;

            // Create worktree
            let worktree_path = create_worktree(spec_id, branch, None)?;

            // Copy spec to worktree
            copy_spec_to_worktree(spec_id, &worktree_path)?;

            // Verify spec was copied to worktree
            let worktree_spec_path = worktree_path
                .join(".chant/specs")
                .join(format!("{}.md", spec_id));
            assert!(
                worktree_spec_path.exists(),
                "Spec file should exist in worktree"
            );

            let worktree_spec_content = fs::read_to_string(&worktree_spec_path)?;
            assert!(
                worktree_spec_content.contains("in_progress"),
                "Spec should contain in_progress status"
            );

            // Verify the copy was committed
            let log_output = StdCommand::new("git")
                .args(["log", "--oneline", "-n", "1"])
                .current_dir(&worktree_path)
                .output()?;
            let log = String::from_utf8_lossy(&log_output.stdout);
            assert!(
                log.contains("update spec status"),
                "Commit message should mention spec update"
            );

            Ok(worktree_path)
        };

        // Always restore original directory
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;

        // Cleanup
        if let Ok(worktree_path) = result {
            let _ = StdCommand::new("git")
                .args(["worktree", "remove", worktree_path.to_str().unwrap()])
                .current_dir(&repo_dir)
                .output();
            let _ = fs::remove_dir_all(&worktree_path);
        }
        cleanup_test_repo(&repo_dir)?;

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_remove_worktree_success() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-repo-remove-success");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        let original_dir = std::env::current_dir()?;

        let worktree_path = {
            std::env::set_current_dir(&repo_dir).context("Failed to change to repo directory")?;

            let spec_id = "test-spec-remove";
            let branch = "spec/test-spec-remove";

            // Create worktree
            let path = create_worktree(spec_id, branch, None)?;
            assert!(path.exists(), "Worktree should exist after creation");
            path
        };

        // Always restore original directory before cleanup
        std::env::set_current_dir(&original_dir).context("Failed to restore original directory")?;

        // Remove the worktree
        let result = remove_worktree(&worktree_path);
        assert!(result.is_ok(), "remove_worktree should succeed");

        // Verify worktree directory no longer exists
        assert!(
            !worktree_path.exists(),
            "Worktree directory should be removed"
        );

        cleanup_test_repo(&repo_dir)?;
        Ok(())
    }

    #[test]
    fn test_remove_worktree_idempotent() -> Result<()> {
        let path = PathBuf::from("/tmp/nonexistent-worktree-12345");

        // Try to remove a non-existent worktree - should succeed
        let result = remove_worktree(&path);

        assert!(result.is_ok());
        Ok(())
    }

    #[test]
    fn test_worktree_path_for_spec() {
        let path = worktree_path_for_spec("2026-01-27-001-abc", None);
        assert_eq!(path, PathBuf::from("/tmp/chant-2026-01-27-001-abc"));

        let path = worktree_path_for_spec("2026-01-27-001-abc", Some("myproject"));
        assert_eq!(
            path,
            PathBuf::from("/tmp/chant-myproject-2026-01-27-001-abc")
        );

        let path = worktree_path_for_spec("2026-01-27-001-abc", Some(""));
        assert_eq!(path, PathBuf::from("/tmp/chant-2026-01-27-001-abc"));
    }

    #[test]
    fn test_get_active_worktree_nonexistent() {
        // Test with a spec ID that definitely doesn't have a worktree
        let result = get_active_worktree("nonexistent-spec-12345", None);
        assert!(result.is_none());
    }

    #[test]
    #[serial_test::serial]
    fn test_commit_in_worktree() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-commit-in-worktree");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        // Create a new file
        fs::write(repo_dir.join("new_file.txt"), "content")?;

        // Commit the changes
        let result = commit_in_worktree(&repo_dir, "Test commit message");

        cleanup_test_repo(&repo_dir)?;

        assert!(result.is_ok());
        let hash = result.unwrap();
        // Commit hash should be a 40-character hex string
        assert_eq!(hash.len(), 40);
        assert!(hash.chars().all(|c| c.is_ascii_hexdigit()));

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_commit_in_worktree_no_changes() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-commit-no-changes");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        // Don't make any changes, just try to commit
        let result = commit_in_worktree(&repo_dir, "Empty commit");

        cleanup_test_repo(&repo_dir)?;

        // Should still succeed (returns HEAD)
        assert!(result.is_ok());
        let hash = result.unwrap();
        assert_eq!(hash.len(), 40);

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_has_uncommitted_changes_clean() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-uncommitted-clean");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        // Check for uncommitted changes on a clean repo
        let has_changes = has_uncommitted_changes(&repo_dir)?;

        cleanup_test_repo(&repo_dir)?;

        assert!(
            !has_changes,
            "Clean repo should have no uncommitted changes"
        );

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_has_uncommitted_changes_with_unstaged() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-uncommitted-unstaged");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        // Create a new file (unstaged)
        fs::write(repo_dir.join("newfile.txt"), "content")?;

        // Check for uncommitted changes
        let has_changes = has_uncommitted_changes(&repo_dir)?;

        cleanup_test_repo(&repo_dir)?;

        assert!(has_changes, "Repo with unstaged changes should return true");

        Ok(())
    }

    #[test]
    #[serial_test::serial]
    fn test_has_uncommitted_changes_with_staged() -> Result<()> {
        let repo_dir = PathBuf::from("/tmp/test-chant-uncommitted-staged");
        cleanup_test_repo(&repo_dir)?;
        setup_test_repo(&repo_dir)?;

        // Create a new file and stage it
        fs::write(repo_dir.join("newfile.txt"), "content")?;
        let output = StdCommand::new("git")
            .args(["add", "newfile.txt"])
            .current_dir(&repo_dir)
            .output()?;
        assert!(output.status.success());

        // Check for uncommitted changes
        let has_changes = has_uncommitted_changes(&repo_dir)?;

        cleanup_test_repo(&repo_dir)?;

        assert!(has_changes, "Repo with staged changes should return true");

        Ok(())
    }
}