@sudocode-ai/local-server 0.1.0 → 0.1.1

package/dist/execution/worktree/git-cli.js

@@ -0,0 +1,189 @@
+/**
+ * Git CLI Wrapper
+ *
+ * Provides a wrapper around git CLI commands for worktree operations.
+ * Uses git CLI directly for reliability (recommended over libgit2/nodegit).
+ *
+ * @module execution/worktree/git-cli
+ */
+import { execSync } from 'child_process';
+import { WorktreeError, WorktreeErrorCode } from './types.js';
+/**
+ * GitCli - Implementation of IGitCli using child_process
+ */
+export class GitCli {
+    /**
+     * Execute a git command
+     *
+     * @param command - Git command to execute
+     * @param cwd - Working directory
+     * @returns Command output
+     * @throws WorktreeError on failure
+     */
+    execGit(command, cwd) {
+        try {
+            return execSync(command, {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (error) {
+            const stderr = error.stderr?.toString() || '';
+            const stdout = error.stdout?.toString() || '';
+            const message = stderr || stdout || error.message || 'Unknown git error';
+            throw new WorktreeError(`Git command failed: ${command}\n${message}`, WorktreeErrorCode.GIT_ERROR, error);
+        }
+    }
+    /**
+     * Escape shell argument
+     *
+     * @param arg - Argument to escape
+     * @returns Escaped argument
+     */
+    escapeShellArg(arg) {
+        // Escape single quotes and wrap in single quotes
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+    }
+    async worktreeAdd(repoPath, worktreePath, branch, force = false) {
+        const escapedPath = this.escapeShellArg(worktreePath);
+        const escapedBranch = this.escapeShellArg(branch);
+        const forceFlag = force ? '--force' : '';
+        const command = `git worktree add ${forceFlag} ${escapedPath} ${escapedBranch}`.trim();
+        this.execGit(command, repoPath);
+    }
+    async worktreeRemove(repoPath, worktreePath, force = false) {
+        const escapedPath = this.escapeShellArg(worktreePath);
+        const forceFlag = force ? '--force' : '';
+        const command = `git worktree remove ${forceFlag} ${escapedPath}`.trim();
+        this.execGit(command, repoPath);
+    }
+    async worktreePrune(repoPath) {
+        this.execGit('git worktree prune', repoPath);
+    }
+    async worktreeList(repoPath) {
+        const output = this.execGit('git worktree list --porcelain', repoPath);
+        return this.parseWorktreeList(output);
+    }
+    /**
+     * Parse output from git worktree list --porcelain
+     *
+     * Format:
+     * worktree /path/to/worktree
+     * HEAD abc123...
+     * branch refs/heads/branch-name
+     * locked reason (optional)
+     * prunable reason (optional)
+     *
+     * @param output - Output from git worktree list --porcelain
+     * @returns Array of WorktreeInfo
+     */
+    parseWorktreeList(output) {
+        const worktrees = [];
+        const lines = output.split('\n').filter((line) => line.trim());
+        let currentWorktree = null;
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                // Start a new worktree entry
+                if (currentWorktree && currentWorktree.path) {
+                    worktrees.push(this.finalizeWorktreeInfo(currentWorktree));
+                }
+                currentWorktree = {
+                    path: line.substring('worktree '.length).trim(),
+                    isMain: false,
+                    isLocked: false,
+                };
+            }
+            else if (line.startsWith('HEAD ')) {
+                if (currentWorktree) {
+                    currentWorktree.commit = line.substring('HEAD '.length).trim();
+                }
+            }
+            else if (line.startsWith('branch ')) {
+                if (currentWorktree) {
+                    const branchRef = line.substring('branch '.length).trim();
+                    // Extract branch name from refs/heads/branch-name
+                    currentWorktree.branch = branchRef.replace('refs/heads/', '');
+                }
+            }
+            else if (line.startsWith('bare')) {
+                if (currentWorktree) {
+                    currentWorktree.isMain = true;
+                }
+            }
+            else if (line.startsWith('locked ')) {
+                if (currentWorktree) {
+                    currentWorktree.isLocked = true;
+                    currentWorktree.lockReason = line.substring('locked '.length).trim();
+                }
+            }
+        }
+        // Add the last worktree
+        if (currentWorktree && currentWorktree.path) {
+            worktrees.push(this.finalizeWorktreeInfo(currentWorktree));
+        }
+        return worktrees;
+    }
+    /**
+     * Finalize worktree info with defaults
+     *
+     * @param partial - Partial worktree info
+     * @returns Complete WorktreeInfo
+     */
+    finalizeWorktreeInfo(partial) {
+        return {
+            path: partial.path || '',
+            branch: partial.branch || '(detached)',
+            commit: partial.commit || '',
+            isMain: partial.isMain || false,
+            isLocked: partial.isLocked || false,
+            lockReason: partial.lockReason,
+        };
+    }
+    async createBranch(repoPath, branchName, baseBranchOrCommit) {
+        const escapedBranch = this.escapeShellArg(branchName);
+        const escapedBase = this.escapeShellArg(baseBranchOrCommit);
+        const command = `git branch ${escapedBranch} ${escapedBase}`;
+        this.execGit(command, repoPath);
+    }
+    async deleteBranch(repoPath, branchName, force = false) {
+        const escapedBranch = this.escapeShellArg(branchName);
+        const flag = force ? '-D' : '-d';
+        const command = `git branch ${flag} ${escapedBranch}`;
+        this.execGit(command, repoPath);
+    }
+    async configureSparseCheckout(worktreePath, patterns) {
+        // Enable sparse-checkout
+        this.execGit('git sparse-checkout init --cone', worktreePath);
+        // Set patterns
+        const escapedPatterns = patterns.map((p) => this.escapeShellArg(p)).join(' ');
+        const command = `git sparse-checkout set ${escapedPatterns}`;
+        this.execGit(command, worktreePath);
+    }
+    async isValidRepo(repoPath) {
+        try {
+            this.execGit('git rev-parse --git-dir', repoPath);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async listBranches(repoPath) {
+        const output = this.execGit(`git branch --list --all --format='%(refname:short)'`, repoPath);
+        return output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((branch) => {
+            // Remove 'origin/' prefix if present for remote branches
+            // This gives us both local and remote branch names in a consistent format
+            return branch.replace(/^remotes\/origin\//, '');
+        });
+    }
+    async getCurrentCommit(repoPath) {
+        const output = this.execGit('git rev-parse HEAD', repoPath);
+        return output.trim();
+    }
+}
+//# sourceMappingURL=git-cli.js.map

package/dist/execution/worktree/git-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-cli.js","sourceRoot":"","sources":["../../../src/execution/worktree/git-cli.ts"],"names":[],"mappings":"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"}

package/dist/execution/worktree/index.js

@@ -0,0 +1,15 @@
+/**
+ * Worktree Layer - Public API
+ *
+ * Barrel export for the Worktree Layer of the execution system.
+ * Exports all public types, interfaces, and implementations.
+ *
+ * @module execution/worktree
+ */
+export { WorktreeError, WorktreeErrorCode } from './types.js';
+// Implementation
+export { WorktreeManager } from './manager.js';
+export { GitCli } from './git-cli.js';
+// Configuration
+export { DEFAULT_WORKTREE_CONFIG, getWorktreeConfig, loadWorktreeConfig, validateWorktreeConfig, updateWorktreeConfig, setWorktreeConfigProperty, resetWorktreeConfig, clearWorktreeConfigCache, } from './config.js';
+//# sourceMappingURL=index.js.map

package/dist/execution/worktree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/execution/worktree/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAK9D,iBAAiB;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAI/C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,gBAAgB;AAChB,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,aAAa,CAAC"}

package/dist/execution/worktree/manager.js

@@ -0,0 +1,452 @@
+/**
+ * Worktree Manager
+ *
+ * Manages git worktrees for session isolation.
+ *
+ * WORKTREE ISOLATION:
+ * ===================
+ * Each worktree created by this manager is completely isolated from the main
+ * repository. This prevents race conditions and unexpected modifications during
+ * concurrent executions.
+ *
+ * Isolation is achieved through:
+ * 1. Local database (.sudocode/cache.db) in each worktree
+ * 2. Synced JSONL files with latest state (including uncommitted changes)
+ * 3. Claude config (.claude/config.json) that forces MCP to use local database
+ *
+ * Key Benefit: Multiple executions can run concurrently without interfering
+ * with each other or the main repository. All MCP/CLI operations in a worktree
+ * stay contained within that worktree.
+ *
+ * See setupWorktreeEnvironment() method for detailed implementation.
+ *
+ * @module execution/worktree/manager
+ */
+import { Mutex } from "async-mutex";
+import fs from "fs";
+import path from "path";
+import { WorktreeError, WorktreeErrorCode } from "./types.js";
+import { GitCli } from "./git-cli.js";
+import { initDatabase } from "@sudocode-ai/cli/dist/db.js";
+import { importFromJSONL } from "@sudocode-ai/cli/dist/import.js";
+import { execSync } from "child_process";
+/**
+ * WorktreeManager - Implementation of IWorktreeManager
+ *
+ * Manages git worktrees with proper locking, cleanup, and error recovery.
+ * Uses git CLI commands for reliability.
+ */
+export class WorktreeManager {
+    /** Per-path locks to prevent concurrent operations */
+    locks = new Map();
+    /** Configuration loaded from .sudocode/config.json */
+    config;
+    /** Git CLI wrapper */
+    git;
+    /**
+     * Create a new WorktreeManager
+     *
+     * @param config - Worktree configuration
+     * @param git - Optional git CLI implementation (defaults to GitCli)
+     */
+    constructor(config, git) {
+        this.config = config;
+        this.git = git || new GitCli();
+    }
+    /**
+     * Get or create a lock for a specific path
+     *
+     * @param path - Path to lock
+     * @returns Mutex for the path
+     */
+    getLock(path) {
+        let lock = this.locks.get(path);
+        if (!lock) {
+            lock = new Mutex();
+            this.locks.set(path, lock);
+        }
+        return lock;
+    }
+    async createWorktree(params) {
+        const { repoPath, branchName, worktreePath, baseBranch: _baseBranch, createBranch, commitSha, } = params;
+        try {
+            // 1. Create branch if requested
+            if (createBranch) {
+                // Use the specified commit SHA or the current HEAD commit SHA to branch from
+                const targetCommit = commitSha || (await this.git.getCurrentCommit(repoPath));
+                await this.git.createBranch(repoPath, branchName, targetCommit);
+            }
+            // 2. Create parent directory if needed
+            const parentDir = path.dirname(worktreePath);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            // 3. Call git worktree add
+            await this.git.worktreeAdd(repoPath, worktreePath, branchName);
+            // 4. Apply sparse-checkout if configured
+            if (this.config.enableSparseCheckout &&
+                this.config.sparseCheckoutPatterns) {
+                await this.git.configureSparseCheckout(worktreePath, this.config.sparseCheckoutPatterns);
+            }
+            // 5. Validate creation
+            if (!fs.existsSync(worktreePath)) {
+                throw new WorktreeError(`Worktree creation succeeded but path does not exist: ${worktreePath}`, WorktreeErrorCode.REPOSITORY_ERROR);
+            }
+            // 6. Setup isolated worktree environment
+            // This is critical for preventing the worktree from modifying the main repository.
+            // It creates a local database, syncs JSONL files, and configures Claude to use
+            // the local environment. See setupWorktreeEnvironment() for detailed explanation.
+            await this.setupWorktreeEnvironment(repoPath, worktreePath);
+        }
+        catch (error) {
+            if (error instanceof WorktreeError) {
+                throw error;
+            }
+            throw new WorktreeError(`Failed to create worktree: ${error}`, WorktreeErrorCode.REPOSITORY_ERROR, error);
+        }
+    }
+    /**
+     * Setup isolated environment for worktree
+     *
+     * WORKTREE ISOLATION ARCHITECTURE:
+     * ================================
+     * Problem: Previously, MCP/CLI tools running in worktrees would search upward
+     * and find the main repository's database, causing race conditions and
+     * unexpected modifications to the main repo during execution.
+     *
+     * Solution: Each worktree gets its own isolated environment:
+     * - Local database (.sudocode/cache.db in worktree)
+     * - Synced JSONL files with latest state (including uncommitted changes)
+     * - Claude config that forces MCP to use the local database
+     *
+     * Benefits:
+     * - Worktree operations never affect main repository
+     * - Multiple executions can run concurrently without conflicts
+     * - Worktree gets consistent state (newly created issues are available)
+     * - Easy to inspect/debug worktree state after execution
+     *
+     * Flow:
+     * 1. Git creates worktree → checks out files from committed git tree
+     * 2. This method runs → copies latest JSONL (including uncommitted changes)
+     * 3. Initializes local DB from JSONL → worktree has complete state
+     * 4. Creates .claude/config.json → MCP uses local DB via env vars
+     * 5. Claude runs → all MCP operations stay in worktree
+     * 6. (Future) Merge worktree changes back to main after execution
+     *
+     * @param repoPath - Path to the main git repository
+     * @param worktreePath - Path to the worktree directory
+     */
+    async setupWorktreeEnvironment(repoPath, worktreePath) {
+        console.debug("[WorktreeManager] Setting up isolated worktree environment", {
+            repoPath,
+            worktreePath,
+        });
+        const mainSudocodeDir = path.join(repoPath, ".sudocode");
+        const worktreeSudocodeDir = path.join(worktreePath, ".sudocode");
+        console.debug("[WorktreeManager] Directory paths", {
+            mainSudocodeDir,
+            worktreeSudocodeDir,
+        });
+        // Ensure .sudocode directory exists in worktree
+        if (!fs.existsSync(worktreeSudocodeDir)) {
+            fs.mkdirSync(worktreeSudocodeDir, { recursive: true });
+            console.debug(`[WorktreeManager] Created .sudocode directory in worktree: ${worktreeSudocodeDir}`);
+        }
+        else {
+            console.debug(`[WorktreeManager] .sudocode directory already exists in worktree`);
+        }
+        // STEP 1: Copy uncommitted JSONL files from main repo to worktree
+        // ================================================================
+        // Why: Git worktree checkout only gets committed files from git history.
+        // If the user created new issues/specs before starting the execution,
+        // those changes are in the main repo's JSONL files but not committed.
+        // We need to copy them so the worktree has the complete, up-to-date state.
+        //
+        // Example: User creates ISSUE-144, starts execution immediately.
+        // - Git tree: has 138 issues (old state)
+        // - Main JSONL: has 140 issues (includes ISSUE-144, uncommitted)
+        // - Without this copy: worktree would only have 138 issues, ISSUE-144 missing!
+        // - With this copy: worktree gets all 140 issues, execution can reference ISSUE-144
+        const jsonlFiles = ["issues.jsonl", "specs.jsonl"];
+        for (const file of jsonlFiles) {
+            const mainFile = path.join(mainSudocodeDir, file);
+            const worktreeFile = path.join(worktreeSudocodeDir, file);
+            console.debug(`[WorktreeManager] Processing ${file}`, {
+                mainFile,
+                worktreeFile,
+                mainFileExists: fs.existsSync(mainFile),
+            });
+            if (fs.existsSync(mainFile)) {
+                const mainStats = fs.statSync(mainFile);
+                fs.copyFileSync(mainFile, worktreeFile);
+                const worktreeStats = fs.statSync(worktreeFile);
+                console.debug(`[WorktreeManager] Synced ${file} from main repo to worktree`, {
+                    mainFileSize: mainStats.size,
+                    worktreeFileSize: worktreeStats.size,
+                });
+            }
+            else {
+                console.debug(`[WorktreeManager] Main file does not exist: ${mainFile}`);
+            }
+        }
+        // STEP 2: Copy config.json
+        // ========================
+        // Copy sudocode configuration to maintain consistency
+        const mainConfig = path.join(mainSudocodeDir, "config.json");
+        const worktreeConfig = path.join(worktreeSudocodeDir, "config.json");
+        if (fs.existsSync(mainConfig)) {
+            fs.copyFileSync(mainConfig, worktreeConfig);
+            console.debug(`[WorktreeManager] Copied config.json from main repo to worktree`);
+        }
+        else {
+            console.debug(`[WorktreeManager] No config.json to copy from main repo`);
+        }
+        // STEP 3: Initialize local database in worktree
+        // ==============================================
+        // Create a brand new SQLite database in the worktree and import the JSONL
+        // files we just copied. This gives the worktree its own isolated database
+        // with the complete current state.
+        //
+        // Important: This database is completely separate from the main repo's DB.
+        // All MCP/CLI operations in the worktree will use THIS database, not the main one.
+        const worktreeDbPath = path.join(worktreeSudocodeDir, "cache.db");
+        // Initialize database with CLI's initDatabase (creates all tables)
+        const db = initDatabase({ path: worktreeDbPath, verbose: false });
+        try {
+            await importFromJSONL(db, {
+                inputDir: worktreeSudocodeDir,
+            });
+            console.debug(`[WorktreeManager] Successfully initialized local database in worktree at ${worktreeDbPath}`);
+            // Verify database was created
+            if (fs.existsSync(worktreeDbPath)) {
+                const dbStats = fs.statSync(worktreeDbPath);
+                console.debug("[WorktreeManager] Database file created", {
+                    path: worktreeDbPath,
+                    size: dbStats.size,
+                });
+            }
+            else {
+                console.error("[WorktreeManager] ERROR: Database file was not created!");
+            }
+        }
+        catch (error) {
+            console.error("[WorktreeManager] Failed to initialize database", error);
+            throw error;
+        }
+        finally {
+            db.close();
+        }
+        console.debug("[WorktreeManager] Worktree environment setup complete");
+    }
+    async ensureWorktreeExists(repoPath, branchName, worktreePath) {
+        // Get lock for this specific path
+        const lock = this.getLock(worktreePath);
+        const release = await lock.acquire();
+        try {
+            // Check if already exists and valid
+            if (await this.isWorktreeValid(repoPath, worktreePath)) {
+                return;
+            }
+            // Recreate worktree
+            await this.recreateWorktree(repoPath, branchName, worktreePath);
+        }
+        finally {
+            release();
+        }
+    }
+    async cleanupWorktree(worktreePath, repoPath) {
+        // Get lock for this specific path
+        const lock = this.getLock(worktreePath);
+        const release = await lock.acquire();
+        try {
+            // Infer repoPath if not provided (try to find from worktree)
+            const effectiveRepoPath = repoPath || (await this.inferRepoPath(worktreePath));
+            if (!effectiveRepoPath) {
+                // Can't determine repo path, just cleanup the directory
+                if (fs.existsSync(worktreePath)) {
+                    fs.rmSync(worktreePath, { recursive: true, force: true });
+                }
+                return;
+            }
+            // Get worktree info to find branch name (for optional deletion)
+            let branchName;
+            try {
+                const worktrees = await this.git.worktreeList(effectiveRepoPath);
+                // Normalize paths for comparison (resolves symlinks like /var -> /private/var on macOS)
+                const normalizedWorktreePath = fs.realpathSync(worktreePath);
+                const worktreeInfo = worktrees.find((w) => {
+                    try {
+                        const normalizedGitPath = fs.realpathSync(w.path);
+                        return normalizedGitPath === normalizedWorktreePath;
+                    }
+                    catch {
+                        // If path doesn't exist, try direct comparison
+                        return w.path === worktreePath;
+                    }
+                });
+                if (worktreeInfo) {
+                    branchName = worktreeInfo.branch;
+                }
+            }
+            catch (error) {
+                // Ignore errors, branch deletion is optional
+            }
+            // 1. Remove git worktree registration
+            try {
+                await this.git.worktreeRemove(effectiveRepoPath, worktreePath, true);
+            }
+            catch (error) {
+                // Worktree might already be removed or invalid, continue cleanup
+            }
+            // 2. Force cleanup metadata directory
+            const worktreeName = path.basename(worktreePath);
+            const metadataPath = path.join(effectiveRepoPath, ".git", "worktrees", worktreeName);
+            if (fs.existsSync(metadataPath)) {
+                fs.rmSync(metadataPath, { recursive: true, force: true });
+            }
+            // 3. Remove filesystem directory
+            if (fs.existsSync(worktreePath)) {
+                fs.rmSync(worktreePath, { recursive: true, force: true });
+            }
+            // 4. Prune stale worktree entries
+            try {
+                await this.git.worktreePrune(effectiveRepoPath);
+            }
+            catch (error) {
+                // Prune is best-effort, continue even if it fails
+            }
+            // 5. Delete branch if configured
+            if (this.config.autoDeleteBranches &&
+                branchName &&
+                branchName !== "(detached)") {
+                try {
+                    await this.git.deleteBranch(effectiveRepoPath, branchName, true);
+                }
+                catch (error) {
+                    // Branch deletion is optional, don't fail the cleanup
+                }
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async isWorktreeValid(repoPath, worktreePath) {
+        try {
+            // 1. Check filesystem path exists
+            if (!fs.existsSync(worktreePath)) {
+                return false;
+            }
+            // 2. Check worktree is registered in git metadata
+            const worktrees = await this.git.worktreeList(repoPath);
+            // Normalize paths for comparison (resolves symlinks like /var -> /private/var on macOS)
+            const normalizedWorktreePath = fs.realpathSync(worktreePath);
+            const isRegistered = worktrees.some((w) => {
+                try {
+                    const normalizedGitPath = fs.realpathSync(w.path);
+                    return normalizedGitPath === normalizedWorktreePath;
+                }
+                catch {
+                    // If path doesn't exist, try direct comparison
+                    return w.path === worktreePath;
+                }
+            });
+            return isRegistered;
+        }
+        catch (error) {
+            // On any error, consider invalid
+            return false;
+        }
+    }
+    async listWorktrees(repoPath) {
+        return await this.git.worktreeList(repoPath);
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    async isValidRepo(repoPath) {
+        return this.git.isValidRepo(repoPath);
+    }
+    async listBranches(repoPath) {
+        return this.git.listBranches(repoPath);
+    }
+    /**
+     * Recreate a worktree (internal method)
+     *
+     * @param repoPath - Path to repository
+     * @param branchName - Branch name
+     * @param worktreePath - Worktree path
+     */
+    async recreateWorktree(repoPath, branchName, worktreePath) {
+        // 1. Comprehensive cleanup of existing worktree
+        await this.cleanupWorktree(worktreePath, repoPath);
+        // 2. Create parent directory if needed
+        const parentDir = path.dirname(worktreePath);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        // 3. Create worktree with retry logic
+        let lastError;
+        const maxRetries = 1;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this.git.worktreeAdd(repoPath, worktreePath, branchName);
+                // Apply sparse-checkout if configured
+                if (this.config.enableSparseCheckout &&
+                    this.config.sparseCheckoutPatterns) {
+                    await this.git.configureSparseCheckout(worktreePath, this.config.sparseCheckoutPatterns);
+                }
+                // Validate creation
+                if (!fs.existsSync(worktreePath)) {
+                    throw new WorktreeError(`Worktree creation succeeded but path does not exist: ${worktreePath}`, WorktreeErrorCode.REPOSITORY_ERROR);
+                }
+                // Setup isolated worktree environment (see setupWorktreeEnvironment for details)
+                await this.setupWorktreeEnvironment(repoPath, worktreePath);
+                return; // Success!
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxRetries) {
+                    // Cleanup metadata and try again
+                    const worktreeName = path.basename(worktreePath);
+                    const metadataPath = path.join(repoPath, ".git", "worktrees", worktreeName);
+                    if (fs.existsSync(metadataPath)) {
+                        fs.rmSync(metadataPath, { recursive: true, force: true });
+                    }
+                }
+            }
+        }
+        // All retries failed
+        throw new WorktreeError(`Failed to recreate worktree after ${maxRetries + 1} attempts: ${lastError}`, WorktreeErrorCode.REPOSITORY_ERROR, lastError);
+    }
+    /**
+     * Infer git repository path from a worktree
+     * Uses git rev-parse --git-common-dir
+     *
+     * @param worktreePath - Path to worktree
+     * @returns Repository path or undefined
+     */
+    async inferRepoPath(worktreePath) {
+        try {
+            if (!fs.existsSync(worktreePath)) {
+                return undefined;
+            }
+            // Try to use git to find the common git directory
+            const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+                cwd: worktreePath,
+                encoding: "utf8",
+            }).trim();
+            // git-common-dir gives us the .git directory
+            // We need the working directory (parent of .git)
+            const gitDirPath = path.resolve(worktreePath, gitCommonDir);
+            if (path.basename(gitDirPath) === ".git") {
+                return path.dirname(gitDirPath);
+            }
+            return gitDirPath;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=manager.js.map