Merge pull request #1161 from org2AI/chloe/modularize-git-worktree

refactor(git): split the worktree module into focused submodules

Author: Harry19081

src-tauri/crates/git/src/worktree.rs

@@ -0,0 +1,184 @@
+//! Worktree creation: the explicit-branch linked worktree and the
+//! per-agent-session worktree (including limit enforcement and stale-state
+//! cleanup before `git worktree add`).
+
+use std::path::Path;
+
+use tracing::{error, info};
+
+use super::git_cmd::{current_head_ref, git_stderr, git_stdout, run_git};
+use super::paths::session_worktree_dir;
+use super::setup_hooks::run_worktree_setup_hooks;
+use super::{
+    list_session_worktrees, session_branch_name, validate_session_id, LinkedWorktreeInfo,
+    WorktreeInfo,
+};
+
+/// Fallback used when the caller does not supply a configurable limit.
+const DEFAULT_MAX_CONCURRENT_WORKTREES: usize = 8;
+
+// ============================================
+// Public API
+// ============================================
+
+/// Create a linked worktree for an explicit branch name.
+///
+/// Unlike [`create_session_worktree`], this is not tied to an agent session:
+/// the caller supplies the branch and target path. Existing local branches are
+/// reused; otherwise a new branch is created from `base_ref` (or `HEAD`).
+pub fn create_linked_worktree(
+    repo_path: &Path,
+    worktree_path: &Path,
+    branch: &str,
+    base_ref: Option<&str>,
+) -> Result<LinkedWorktreeInfo, String> {
+    let branch = branch.trim();
+    if branch.is_empty() {
+        return Err("branch cannot be empty".to_string());
+    }
+    let path_string = worktree_path.to_string_lossy().to_string();
+    if worktree_path.exists() {
+        return Err(format!("Worktree path already exists: {}", path_string));
+    }
+    if let Some(parent) = worktree_path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|err| format!("Failed to create worktree parent dir: {}", err))?;
+    }
+
+    let branch_exists = run_git(repo_path, &["rev-parse", "--verify", branch])
+        .map(|output| output.status.success())
+        .unwrap_or(false);
+    let output = if branch_exists {
+        run_git(repo_path, &["worktree", "add", &path_string, branch])?
+    } else {
+        run_git(
+            repo_path,
+            &[
+                "worktree",
+                "add",
+                "-b",
+                branch,
+                &path_string,
+                base_ref.unwrap_or("HEAD"),
+            ],
+        )?
+    };
+
+    if !output.status.success() {
+        return Err(format!("git worktree add failed: {}", git_stderr(&output)));
+    }
+
+    if let Err(err) = run_worktree_setup_hooks(repo_path, worktree_path) {
+        let _ = run_git(repo_path, &["worktree", "remove", "--force", &path_string]);
+        if !branch_exists {
+            let _ = run_git(repo_path, &["branch", "-D", branch]);
+        }
+        return Err(err);
+    }
+
+    let head_sha = run_git(worktree_path, &["rev-parse", "HEAD"])
+        .map(|output| git_stdout(&output))
+        .unwrap_or_default();
+    Ok(LinkedWorktreeInfo {
+        path: path_string,
+        branch: branch.to_string(),
+        head_sha,
+    })
+}
+
+/// Create an isolated worktree for a coding agent session.
+///
+/// Creates a new branch from `base_branch` (or current HEAD) and sets up
+/// a worktree at `~/.orgii/agent-worktrees/{repo-hash}/{session-id}/`.
+///
+/// `max_count` — caller-supplied limit from `git.worktree.maxCount`.
+/// Falls back to `DEFAULT_MAX_CONCURRENT_WORKTREES` when `None`.
+pub fn create_session_worktree(
+    repo_path: &Path,
+    session_id: &str,
+    base_branch: Option<&str>,
+    max_count: Option<usize>,
+) -> Result<WorktreeInfo, String> {
+    validate_session_id(session_id)?;
+    let repo_str = repo_path.to_string_lossy().to_string();
+    let wt_path = session_worktree_dir(&repo_str, session_id);
+    let branch = session_branch_name(session_id);
+
+    // Enforce configurable max concurrent worktrees for this repo
+    let limit = max_count.unwrap_or(DEFAULT_MAX_CONCURRENT_WORKTREES);
+    let existing = list_session_worktrees(repo_path)?;
+    if existing.len() >= limit {
+        return Err(format!(
+            "Maximum concurrent worktrees ({limit}) reached for this repo. \
+             Merge or discard existing sessions first."
+        ));
+    }
+
+    // Determine base branch
+    let base = match base_branch {
+        Some(b) => b.to_string(),
+        None => current_head_ref(repo_path)?,
+    };
+
+    // Clean up stale worktree if path exists but isn't registered
+    if wt_path.exists() {
+        info!(
+            "[worktree] Cleaning up stale worktree directory: {}",
+            wt_path.display()
+        );
+        let _ = run_git(repo_path, &["worktree", "prune"]);
+        if wt_path.exists() {
+            std::fs::remove_dir_all(&wt_path)
+                .map_err(|err| format!("Failed to remove stale worktree: {}", err))?;
+        }
+    }
+
+    // Delete branch if it exists (stale from previous run)
+    let branch_check = run_git(repo_path, &["rev-parse", "--verify", &branch]);
+    if let Ok(ref output) = branch_check {
+        if output.status.success() {
+            info!("[worktree] Deleting stale branch: {}", branch);
+            let _ = run_git(repo_path, &["branch", "-D", &branch]);
+        }
+    }
+
+    // Create parent directory
+    if let Some(parent) = wt_path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|err| format!("Failed to create worktree parent dir: {}", err))?;
+    }
+
+    // Create worktree with new branch
+    let wt_path_str = wt_path.to_string_lossy().to_string();
+    let output = run_git(
+        repo_path,
+        &["worktree", "add", "-b", &branch, &wt_path_str, &base],
+    )?;
+
+    if !output.status.success() {
+        let stderr = git_stderr(&output);
+        error!("[worktree] Failed to create worktree: {}", stderr);
+        return Err(format!("git worktree add failed: {}", stderr));
+    }
+
+    info!(
+        "[worktree] Created worktree for session {} at {} (branch: {}, base: {})",
+        session_id,
+        wt_path.display(),
+        branch,
+        base
+    );
+
+    if let Err(err) = run_worktree_setup_hooks(repo_path, &wt_path) {
+        let _ = run_git(repo_path, &["worktree", "remove", "--force", &wt_path_str]);
+        let _ = run_git(repo_path, &["branch", "-D", &branch]);
+        return Err(err);
+    }
+
+    Ok(WorktreeInfo {
+        path: wt_path_str,
+        branch,
+        base_branch: Some(base),
+        session_id: session_id.to_string(),
+    })
+}

src-tauri/crates/git/src/worktree/create.rs

@@ -0,0 +1,47 @@
+//! Thin git invocation layer shared by the worktree submodules: the retrying
+//! `git` runner plus the stdout/stderr and HEAD/cleanliness accessors built
+//! on top of it.
+
+use std::path::Path;
+use std::process::Output;
+
+use crate::util::run_git_with_retry;
+
+const GIT_RETRIES: u32 = 3;
+
+/// Check that a repo working directory is clean (no uncommitted changes).
+pub(super) fn is_working_dir_clean(repo_path: &Path) -> Result<bool, String> {
+    let output = run_git(repo_path, &["status", "--porcelain"])?;
+    if !output.status.success() {
+        return Err(format!("git status failed: {}", git_stderr(&output)));
+    }
+    Ok(git_stdout(&output).is_empty())
+}
+
+pub(super) fn run_git(cwd: &Path, args: &[&str]) -> Result<Output, String> {
+    run_git_with_retry(cwd, args, GIT_RETRIES)
+}
+
+pub(super) fn git_stdout(output: &Output) -> String {
+    String::from_utf8_lossy(&output.stdout).trim().to_string()
+}
+
+pub(super) fn git_stderr(output: &Output) -> String {
+    String::from_utf8_lossy(&output.stderr).trim().to_string()
+}
+
+/// Get the current branch or HEAD commit of a repo.
+pub(super) fn current_head_ref(repo_path: &Path) -> Result<String, String> {
+    let output = run_git(repo_path, &["rev-parse", "--abbrev-ref", "HEAD"])?;
+    if !output.status.success() {
+        return Err(format!("Failed to get HEAD: {}", git_stderr(&output)));
+    }
+    let branch = git_stdout(&output);
+    if branch == "HEAD" {
+        let output = run_git(repo_path, &["rev-parse", "HEAD"])?;
+        if output.status.success() {
+            return Ok(git_stdout(&output));
+        }
+    }
+    Ok(branch)
+}

src-tauri/crates/git/src/worktree/git_cmd.rs

@@ -0,0 +1,82 @@
+//! Read-only queries about a session worktree: its unmerged-work snapshot and
+//! the diff against its base branch.
+
+use std::path::Path;
+
+use super::git_cmd::{git_stderr, git_stdout, is_working_dir_clean, run_git};
+use super::paths::session_worktree_dir;
+use super::{session_branch_name, validate_session_id, SessionWorktreeState};
+
+/// Inspect a session worktree for unmerged work: uncommitted file state
+/// and commits ahead of `base_branch` (when known). A missing worktree
+/// directory reports `worktree_exists: false` with `dirty: false`; the
+/// ahead-count is still computed so a manually pruned worktree with a
+/// surviving committed branch is not treated as clean.
+pub fn session_worktree_state(
+    repo_path: &Path,
+    session_id: &str,
+    base_branch: Option<&str>,
+) -> Result<SessionWorktreeState, String> {
+    validate_session_id(session_id)?;
+    let repo_str = repo_path.to_string_lossy().to_string();
+    let worktree_path = session_worktree_dir(&repo_str, session_id);
+    let branch = session_branch_name(session_id);
+
+    let worktree_exists = worktree_path.exists();
+    let dirty = if worktree_exists {
+        !is_working_dir_clean(&worktree_path)?
+    } else {
+        false
+    };
+
+    let mut commits_ahead_of_base = 0u64;
+    if let Some(base) = base_branch {
+        let branch_exists = matches!(
+            run_git(repo_path, &["rev-parse", "--verify", &branch]),
+            Ok(ref output) if output.status.success()
+        );
+        if branch_exists {
+            let range = format!("{}..{}", base, branch);
+            let output = run_git(repo_path, &["rev-list", "--count", &range])?;
+            if !output.status.success() {
+                return Err(format!(
+                    "git rev-list --count {} failed: {}",
+                    range,
+                    git_stderr(&output)
+                ));
+            }
+            commits_ahead_of_base = git_stdout(&output).parse().unwrap_or(0);
+        }
+    }
+
+    Ok(SessionWorktreeState {
+        worktree_path,
+        branch,
+        worktree_exists,
+        dirty,
+        commits_ahead_of_base,
+    })
+}
+
+/// Get diff between a session's branch and its base branch.
+pub fn get_session_diff(
+    repo_path: &Path,
+    session_id: &str,
+    base_branch: &str,
+) -> Result<String, String> {
+    let branch = session_branch_name(session_id);
+    let output = run_git(
+        repo_path,
+        &[
+            "diff",
+            "--unified=3",
+            &format!("{}...{}", base_branch, branch),
+        ],
+    )?;
+
+    if !output.status.success() {
+        return Err(format!("git diff failed: {}", git_stderr(&output)));
+    }
+
+    Ok(git_stdout(&output))
+}