bobs-workshop 0.1.4

package/dist/tools/worktreeTools.js

@@ -0,0 +1,705 @@
+// src/tools/worktreeTools.ts
+import simpleGit from "simple-git";
+import { z } from "zod";
+import { spawn } from "child_process";
+import path from "path";
+const git = simpleGit();
+export const WorktreeCreateInput = z.object({
+    spec_id: z.string(),
+    branch: z.string(),
+    base: z.string().optional().default("main")
+});
+export const WorktreeCreateOutput = z.object({
+    worktree_id: z.string(),
+    branch: z.string(),
+    path: z.string(),
+    status: z.string()
+});
+export const WorktreeStatusInput = z.object({
+    worktree_id: z.string()
+});
+export const WorktreeStatusOutput = z.object({
+    branch: z.string(),
+    dirty: z.boolean(),
+    ahead: z.number(),
+    behind: z.number(),
+    changed_files: z.array(z.string())
+});
+export const WorktreeMergeInput = z.object({
+    worktree_id: z.string()
+});
+export const WorktreeRemoveInput = z.object({
+    worktree_id: z.string(),
+    spec_id: z.string().optional()
+});
+export const WorktreeListOutput = z.object({
+    committed: z.array(z.string()),
+    dirty: z.array(z.string()),
+    clean: z.array(z.string())
+});
+export const WorktreeStartServerInput = z.object({
+    worktree_id: z.string(),
+    command: z.string().default("npm run dev"),
+    port: z.number().optional()
+});
+export const WorktreeStartServerOutput = z.object({
+    status: z.string(),
+    url: z.string().optional(),
+    pid: z.number()
+});
+export const WorktreeStopServerInput = z.object({
+    pid: z.number()
+});
+export const WorktreeStopServerOutput = z.object({
+    status: z.string()
+});
+// Store running server processes
+const runningServers = new Map();
+export async function worktreeCreateHandler(input) {
+    const validated = WorktreeCreateInput.parse(input);
+    const branchName = validated.branch || `feature/${validated.spec_id}`;
+    try {
+        console.log(`🔧 Creating actual git worktree for branch: ${branchName}`);
+        // Create the worktree directory path
+        const worktreePath = path.resolve(process.cwd(), `.bob/worktrees/${branchName}`);
+        // Ensure the worktrees directory exists
+        const fs = await import('fs-extra');
+        await fs.ensureDir(path.dirname(worktreePath));
+        // FIXED: Actually create a git worktree (not just a branch)
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        // Create the worktree with a new branch
+        console.log(`Creating worktree at: ${worktreePath}`);
+        await execAsync(`git worktree add ${worktreePath} -b ${branchName} ${validated.base}`);
+        // Install dependencies in the new worktree
+        console.log(`Installing dependencies in worktree: ${worktreePath}`);
+        await installDependenciesInWorktree(worktreePath);
+        // Update SPEC with worktree creation and metadata
+        if (validated.spec_id) {
+            const { specUpdateHandler } = await import("./specTools.js");
+            await specUpdateHandler({
+                spec_id: validated.spec_id,
+                worktree: {
+                    branch: branchName,
+                    path: worktreePath,
+                    status: "active",
+                    created_at: new Date().toISOString()
+                },
+                execution_log: {
+                    timestamp: new Date().toISOString(),
+                    engineer: "system",
+                    action: "worktree_created",
+                    task_id: "system-worktree-creation",
+                    files_changed: [],
+                    commit_hash: "pending",
+                    note: `Created actual git worktree at ${worktreePath} with branch ${branchName} and installed dependencies`
+                }
+            });
+        }
+        console.log(`✅ Worktree created successfully at: ${worktreePath}`);
+        return {
+            worktree_id: branchName,
+            branch: branchName,
+            path: worktreePath,
+            status: "created"
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Helper function to install dependencies in a worktree
+async function installDependenciesInWorktree(worktreePath) {
+    try {
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const fs = await import('fs-extra');
+        // Check if package.json exists in the worktree
+        const packageJsonPath = path.join(worktreePath, 'package.json');
+        if (await fs.pathExists(packageJsonPath)) {
+            console.log(`Installing npm dependencies in ${worktreePath}...`);
+            // Install dependencies (use npm ci for faster, reliable installs)
+            try {
+                await execAsync('npm ci', { cwd: worktreePath });
+                console.log(`✅ Dependencies installed successfully in ${worktreePath}`);
+            }
+            catch (ciError) {
+                // Fallback to npm install if npm ci fails
+                console.log(`npm ci failed, falling back to npm install...`);
+                await execAsync('npm install', { cwd: worktreePath });
+                console.log(`✅ Dependencies installed successfully in ${worktreePath}`);
+            }
+        }
+        else {
+            console.log(`No package.json found in ${worktreePath}, skipping dependency installation`);
+        }
+        // Check for other package managers
+        const yarnLockPath = path.join(worktreePath, 'yarn.lock');
+        const pnpmLockPath = path.join(worktreePath, 'pnpm-lock.yaml');
+        if (await fs.pathExists(yarnLockPath)) {
+            console.log(`Installing yarn dependencies in ${worktreePath}...`);
+            await execAsync('yarn install --frozen-lockfile', { cwd: worktreePath });
+            console.log(`✅ Yarn dependencies installed successfully in ${worktreePath}`);
+        }
+        else if (await fs.pathExists(pnpmLockPath)) {
+            console.log(`Installing pnpm dependencies in ${worktreePath}...`);
+            await execAsync('pnpm install --frozen-lockfile', { cwd: worktreePath });
+            console.log(`✅ PNPM dependencies installed successfully in ${worktreePath}`);
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Failed to install dependencies in worktree: ${error}`);
+        // Don't throw - dependency installation failure shouldn't break worktree creation
+    }
+}
+export async function worktreeStatusHandler(input) {
+    const validated = WorktreeStatusInput.parse(input);
+    try {
+        const status = await git.status();
+        return {
+            branch: validated.worktree_id,
+            dirty: !status.isClean(),
+            ahead: 0, // simplified for now
+            behind: 0, // simplified for now
+            changed_files: [...status.modified, ...status.created, ...status.deleted]
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get worktree status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function worktreeMergeHandler(input) {
+    const validated = WorktreeMergeInput.parse(input);
+    try {
+        // Safety checks before merging
+        const currentBranch = await git.branch();
+        const status = await git.status();
+        // Ensure we're not on the branch being merged
+        if (currentBranch.current === validated.worktree_id) {
+            throw new Error(`Cannot merge while on branch ${validated.worktree_id}. Switch to main first.`);
+        }
+        // Check if main branch is clean
+        if (!status.isClean()) {
+            throw new Error("Main branch has uncommitted changes. Please commit or stash them before merging.");
+        }
+        // Check if branch exists
+        const branches = Object.keys(currentBranch.branches);
+        if (!branches.includes(validated.worktree_id)) {
+            throw new Error(`Branch ${validated.worktree_id} does not exist`);
+        }
+        // Switch to main and pull latest (if remote exists)
+        await git.checkout("main");
+        try {
+            // Try to pull latest main (ignore errors if no remote)
+            await git.pull("origin", "main");
+        }
+        catch (pullError) {
+            console.warn("Could not pull latest main (no remote or network issue):", pullError);
+        }
+        // Check for merge conflicts by doing a dry run
+        try {
+            await git.raw(['merge', '--no-commit', '--no-ff', validated.worktree_id]);
+            // If successful, abort the merge to complete it properly
+            await git.merge(['--abort']);
+        }
+        catch (dryRunError) {
+            throw new Error(`Merge would result in conflicts: ${dryRunError instanceof Error ? dryRunError.message : String(dryRunError)}`);
+        }
+        // Perform the actual merge
+        await git.merge([validated.worktree_id, '--no-ff']);
+        return {
+            status: "merged",
+            commit_hash: await git.revparse('HEAD'),
+            note: `Successfully merged ${validated.worktree_id} into main`
+        };
+    }
+    catch (error) {
+        // Ensure we're back on main if merge failed
+        try {
+            const currentBranch = await git.branch();
+            if (currentBranch.current !== "main") {
+                await git.checkout("main");
+            }
+        }
+        catch (cleanupError) {
+            console.warn("Failed to cleanup after merge error:", cleanupError);
+        }
+        throw new Error(`Failed to merge worktree: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function worktreeRemoveHandler(input) {
+    const validated = WorktreeRemoveInput.parse(input);
+    try {
+        console.log(`🔧 Removing worktree: ${validated.worktree_id}`);
+        // FIXED: Actually remove the git worktree, not just the branch
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const fs = await import('fs-extra');
+        const worktreePath = path.resolve(process.cwd(), `.bob/worktrees/${validated.worktree_id}`);
+        // Check if worktree exists
+        if (await fs.pathExists(worktreePath)) {
+            console.log(`Removing worktree directory: ${worktreePath}`);
+            // Remove the worktree using git command
+            await execAsync(`git worktree remove ${worktreePath} --force`);
+            console.log(`✅ Worktree removed: ${worktreePath}`);
+        }
+        else {
+            console.log(`Worktree directory not found: ${worktreePath}`);
+        }
+        // Switch to main branch in main repository
+        await git.checkout("main");
+        // Delete the local branch
+        try {
+            await git.deleteLocalBranch(validated.worktree_id);
+            console.log(`✅ Branch deleted: ${validated.worktree_id}`);
+        }
+        catch (branchError) {
+            console.log(`Warning: Could not delete branch ${validated.worktree_id}:`, branchError);
+            // Don't fail the whole operation if branch deletion fails
+        }
+        // Update SPEC with worktree removal
+        if (validated.spec_id) {
+            try {
+                const { specUpdateHandler } = await import("./specTools.js");
+                await specUpdateHandler({
+                    spec_id: validated.spec_id,
+                    worktree: {
+                        status: "removed",
+                        removed_at: new Date().toISOString()
+                    }
+                });
+            }
+            catch (specError) {
+                console.warn(`Warning: Could not update SPEC ${validated.spec_id}:`, specError);
+                // Don't fail the whole operation if SPEC update fails
+            }
+        }
+        return {
+            status: "removed"
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to remove worktree: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function worktreeListHandler() {
+    try {
+        const branchInfo = await git.branch();
+        const status = await git.status();
+        // Filter out remote branches and main branch - only show local feature branches
+        const branches = Object.keys(branchInfo.branches).filter(name => name !== "main" &&
+            !name.startsWith("remotes/") &&
+            !name.includes("origin/"));
+        const committed = [];
+        const dirty = [];
+        const clean = [];
+        for (const branch of branches) {
+            const branchData = {
+                name: branch
+            };
+            if (branch === branchInfo.current && !status.isClean()) {
+                dirty.push(branchData);
+            }
+            else {
+                // simplified branch categorization for now
+                clean.push(branchData);
+            }
+        }
+        return {
+            committed,
+            dirty,
+            clean
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to list worktrees: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function worktreeStartServerHandler(input) {
+    const validated = WorktreeStartServerInput.parse(input);
+    try {
+        // FIXED: Find the actual worktree directory instead of just switching branches
+        const worktreePath = path.resolve(process.cwd(), `.bob/worktrees/${validated.worktree_id}`);
+        // Check if worktree exists
+        const fs = await import('fs-extra');
+        if (!await fs.pathExists(worktreePath)) {
+            throw new Error(`Worktree not found at ${worktreePath}. Please create the worktree first.`);
+        }
+        console.log(`Starting server in worktree: ${worktreePath}`);
+        // Parse command parts
+        const commandParts = validated.command.split(" ");
+        const command = commandParts[0];
+        const args = commandParts.slice(1);
+        // Spawn the server process in the worktree directory
+        const serverProcess = spawn(command, args, {
+            cwd: worktreePath, // FIXED: Run in the actual worktree directory
+            stdio: 'pipe',
+            detached: false,
+            env: { ...process.env, PORT: validated.port?.toString() || process.env.PORT }
+        });
+        if (!serverProcess.pid) {
+            throw new Error("Failed to start server process");
+        }
+        // Store the process for later management
+        runningServers.set(serverProcess.pid, serverProcess);
+        // Log server output for debugging
+        serverProcess.stdout?.on('data', (data) => {
+            console.log(`[SERVER ${serverProcess.pid}] ${data.toString()}`);
+        });
+        serverProcess.stderr?.on('data', (data) => {
+            console.log(`[SERVER ${serverProcess.pid}] ERROR: ${data.toString()}`);
+        });
+        // Determine URL if port is known
+        let url;
+        if (validated.port) {
+            url = `http://localhost:${validated.port}`;
+        }
+        else if (validated.command.includes("dev") || validated.command.includes("start")) {
+            // Common development server ports
+            url = "http://localhost:3000";
+        }
+        // Update SPEC with server start event
+        const { specUpdateHandler } = await import("./specTools.js");
+        await specUpdateHandler({
+            spec_id: validated.worktree_id.replace("feature/", ""),
+            execution_log: {
+                timestamp: new Date().toISOString(),
+                engineer: "system",
+                action: "server_started",
+                task_id: "system-server-start",
+                files_changed: [],
+                commit_hash: "pending",
+                note: `Started server in worktree ${worktreePath}: ${validated.command} (PID: ${serverProcess.pid})`
+            }
+        });
+        console.log(`✅ Server started successfully in worktree (PID: ${serverProcess.pid})`);
+        return {
+            status: "running",
+            url,
+            pid: serverProcess.pid
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to start server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function worktreeStopServerHandler(input) {
+    const validated = WorktreeStopServerInput.parse(input);
+    try {
+        const serverProcess = runningServers.get(validated.pid);
+        if (!serverProcess) {
+            throw new Error(`No running server found with PID ${validated.pid}`);
+        }
+        // Kill the process
+        serverProcess.kill('SIGTERM');
+        // Remove from tracking
+        runningServers.delete(validated.pid);
+        return {
+            status: "stopped"
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to stop server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// NEW MCP TOOL: Comprehensive Worktree Debug & Maintenance
+// ============================================================================
+export const WorktreeDebugInput = z.object({
+    action: z.enum(["repair", "cleanup", "validate", "status"]).describe("Debug action to perform"),
+    spec_id: z.string().optional().describe("Optional SPEC ID to focus on"),
+    max_age_days: z.number().optional().default(7).describe("Max age in days for cleanup action")
+});
+export const WorktreeDebugOutput = z.object({
+    action: z.string(),
+    success: z.boolean(),
+    report: z.string(),
+    actions_taken: z.array(z.string()),
+    recommendations: z.array(z.string()).optional(),
+    worktrees_found: z.number().optional(),
+    worktrees_cleaned: z.number().optional(),
+    issues_found: z.array(z.string()).optional()
+});
+/**
+ * bob.worktree.debug - Comprehensive worktree maintenance tool
+ * Handles repair, cleanup, validation, and status reporting
+ */
+export async function worktreeDebugHandler(input) {
+    const validated = WorktreeDebugInput.parse(input);
+    try {
+        console.log(`bob.worktree.debug called with action: ${validated.action}`);
+        switch (validated.action) {
+            case "status":
+                return await debugStatus(validated.spec_id);
+            case "validate":
+                return await debugValidate(validated.spec_id);
+            case "repair":
+                return await debugRepair(validated.spec_id);
+            case "cleanup":
+                return await debugCleanup(validated.max_age_days);
+            default:
+                throw new Error(`Unknown debug action: ${validated.action}`);
+        }
+    }
+    catch (error) {
+        return {
+            action: validated.action,
+            success: false,
+            report: `Debug action failed: ${error instanceof Error ? error.message : String(error)}`,
+            actions_taken: [],
+            recommendations: ["Check logs for detailed error information"],
+            issues_found: [String(error)]
+        };
+    }
+}
+// Helper: Get detailed status of all worktrees
+async function debugStatus(specId) {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    const fs = await import('fs-extra');
+    const actionsTaken = [];
+    const issuesFound = [];
+    // Get git worktrees
+    const { stdout } = await execAsync('git worktree list --porcelain');
+    const worktrees = stdout.trim().split('\n\n').filter(w => w.length > 0);
+    const worktreeCount = worktrees.length - 1; // Exclude main repo
+    actionsTaken.push(`Found ${worktreeCount} worktrees (excluding main repo)`);
+    // Parse worktrees
+    for (const worktreeInfo of worktrees) {
+        const lines = worktreeInfo.split('\n');
+        const worktreePath = lines[0].replace('worktree ', '');
+        if (worktreePath === process.cwd())
+            continue; // Skip main
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : 'unknown';
+        // Check if directory exists
+        const exists = await fs.pathExists(worktreePath);
+        if (!exists) {
+            issuesFound.push(`Worktree registered but directory missing: ${worktreePath} (${branch})`);
+        }
+        else {
+            actionsTaken.push(`✓ ${branch} → ${worktreePath}`);
+        }
+    }
+    // Check SPEC metadata if specId provided
+    if (specId) {
+        const { specGetHandler } = await import("./specTools.js");
+        try {
+            const spec = await specGetHandler({ spec_id: specId });
+            if (spec.worktree) {
+                actionsTaken.push(`SPEC ${specId} worktree metadata: ${spec.worktree.status} | ${spec.worktree.branch} → ${spec.worktree.path}`);
+                if (spec.worktree.path && !await fs.pathExists(spec.worktree.path)) {
+                    issuesFound.push(`SPEC worktree path does not exist: ${spec.worktree.path}`);
+                }
+            }
+            else {
+                actionsTaken.push(`SPEC ${specId} has no worktree metadata`);
+            }
+        }
+        catch (error) {
+            issuesFound.push(`Could not load SPEC ${specId}: ${error}`);
+        }
+    }
+    return {
+        action: "status",
+        success: true,
+        report: `Status report: ${worktreeCount} worktrees found, ${issuesFound.length} issues detected`,
+        actions_taken: actionsTaken,
+        recommendations: issuesFound.length > 0 ? ["Run 'repair' action to fix issues"] : undefined,
+        worktrees_found: worktreeCount,
+        issues_found: issuesFound.length > 0 ? issuesFound : undefined
+    };
+}
+// Helper: Validate worktree exists before operations
+async function debugValidate(specId) {
+    if (!specId) {
+        return {
+            action: "validate",
+            success: false,
+            report: "Validation requires a spec_id parameter",
+            actions_taken: [],
+            recommendations: ["Provide spec_id to validate worktree"]
+        };
+    }
+    const { specGetHandler } = await import("./specTools.js");
+    const fs = await import('fs-extra');
+    const actionsTaken = [];
+    const issuesFound = [];
+    try {
+        const spec = await specGetHandler({ spec_id: specId });
+        if (!spec.worktree || !spec.worktree.branch || !spec.worktree.path) {
+            issuesFound.push("SPEC missing worktree metadata");
+            return {
+                action: "validate",
+                success: false,
+                report: "SPEC has incomplete worktree metadata",
+                actions_taken: [],
+                issues_found: issuesFound,
+                recommendations: ["Check if worktree was created properly", "Run workflow.start to create worktree"]
+            };
+        }
+        actionsTaken.push(`SPEC worktree: ${spec.worktree.branch} → ${spec.worktree.path}`);
+        actionsTaken.push(`Status: ${spec.worktree.status}`);
+        // Validate directory exists
+        if (!await fs.pathExists(spec.worktree.path)) {
+            issuesFound.push(`Worktree directory does not exist: ${spec.worktree.path}`);
+        }
+        else {
+            actionsTaken.push("✓ Worktree directory exists");
+        }
+        // Validate it's in git worktree list
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        const { stdout } = await execAsync('git worktree list --porcelain');
+        if (!stdout.includes(spec.worktree.path)) {
+            issuesFound.push(`Worktree not registered in git: ${spec.worktree.path}`);
+        }
+        else {
+            actionsTaken.push("✓ Worktree registered in git");
+        }
+        return {
+            action: "validate",
+            success: issuesFound.length === 0,
+            report: issuesFound.length === 0
+                ? `Worktree for ${specId} is valid and ready`
+                : `Worktree for ${specId} has ${issuesFound.length} issues`,
+            actions_taken: actionsTaken,
+            issues_found: issuesFound.length > 0 ? issuesFound : undefined,
+            recommendations: issuesFound.length > 0 ? ["Run 'repair' action to fix issues"] : undefined
+        };
+    }
+    catch (error) {
+        return {
+            action: "validate",
+            success: false,
+            report: `Validation failed: ${error}`,
+            actions_taken: actionsTaken,
+            issues_found: [String(error)]
+        };
+    }
+}
+// Helper: Repair worktree inconsistencies
+async function debugRepair(specId) {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    const fs = await import('fs-extra');
+    const actionsTaken = [];
+    const issuesFound = [];
+    // Get git worktrees
+    const { stdout } = await execAsync('git worktree list --porcelain');
+    const worktrees = stdout.trim().split('\n\n');
+    // Check for orphaned worktrees (registered but directory missing)
+    for (const worktreeInfo of worktrees) {
+        const lines = worktreeInfo.split('\n');
+        const worktreePath = lines[0].replace('worktree ', '');
+        if (worktreePath === process.cwd())
+            continue;
+        if (!await fs.pathExists(worktreePath)) {
+            issuesFound.push(`Orphaned worktree: ${worktreePath}`);
+            try {
+                await execAsync(`git worktree remove ${worktreePath} --force`);
+                actionsTaken.push(`✓ Removed orphaned worktree: ${worktreePath}`);
+            }
+            catch (error) {
+                actionsTaken.push(`✗ Failed to remove ${worktreePath}: ${error}`);
+            }
+        }
+    }
+    // If specId provided, sync SPEC metadata with reality
+    if (specId) {
+        const { specGetHandler, specUpdateHandler } = await import("./specTools.js");
+        try {
+            const spec = await specGetHandler({ spec_id: specId });
+            if (spec.worktree && spec.worktree.path) {
+                const exists = await fs.pathExists(spec.worktree.path);
+                const inGit = stdout.includes(spec.worktree.path);
+                if (!exists && !inGit && spec.worktree.status !== "removed") {
+                    // Worktree is gone but SPEC thinks it's active
+                    await specUpdateHandler({
+                        spec_id: specId,
+                        worktree: {
+                            status: "removed",
+                            removed_at: new Date().toISOString()
+                        }
+                    });
+                    actionsTaken.push(`✓ Updated SPEC ${specId} worktree status to 'removed'`);
+                }
+            }
+        }
+        catch (error) {
+            actionsTaken.push(`Could not update SPEC ${specId}: ${error}`);
+        }
+    }
+    // Prune stale git worktree references
+    try {
+        await execAsync('git worktree prune');
+        actionsTaken.push("✓ Pruned stale git worktree references");
+    }
+    catch (error) {
+        actionsTaken.push(`✗ Failed to prune: ${error}`);
+    }
+    return {
+        action: "repair",
+        success: true,
+        report: `Repair completed: ${actionsTaken.length} actions taken, ${issuesFound.length} issues found`,
+        actions_taken: actionsTaken,
+        issues_found: issuesFound.length > 0 ? issuesFound : undefined,
+        recommendations: issuesFound.length > 0 ? ["Some issues remain - manual intervention may be required"] : undefined
+    };
+}
+// Helper: Cleanup stale worktrees
+async function debugCleanup(maxAgeDays) {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    const fs = await import('fs-extra');
+    const actionsTaken = [];
+    let cleanedCount = 0;
+    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    // Get all worktrees
+    const { stdout } = await execAsync('git worktree list --porcelain');
+    const worktrees = stdout.trim().split('\n\n');
+    for (const worktreeInfo of worktrees) {
+        const lines = worktreeInfo.split('\n');
+        const worktreePath = lines[0].replace('worktree ', '');
+        if (worktreePath === process.cwd())
+            continue;
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : 'unknown';
+        if (!await fs.pathExists(worktreePath)) {
+            actionsTaken.push(`Skipping missing worktree: ${branch}`);
+            continue;
+        }
+        // Check last modification time
+        try {
+            const stats = await fs.stat(worktreePath);
+            const ageMs = now - stats.mtimeMs;
+            if (ageMs > maxAgeMs) {
+                actionsTaken.push(`Stale worktree found: ${branch} (${Math.floor(ageMs / (24 * 60 * 60 * 1000))} days old)`);
+                // Remove worktree
+                await execAsync(`git worktree remove ${worktreePath} --force`);
+                cleanedCount++;
+                actionsTaken.push(`✓ Removed stale worktree: ${branch}`);
+            }
+        }
+        catch (error) {
+            actionsTaken.push(`✗ Failed to process ${branch}: ${error}`);
+        }
+    }
+    return {
+        action: "cleanup",
+        success: true,
+        report: `Cleanup completed: ${cleanedCount} stale worktrees removed`,
+        actions_taken: actionsTaken,
+        worktrees_cleaned: cleanedCount,
+        recommendations: cleanedCount > 0 ? ["Review removed worktrees to ensure no important work was lost"] : undefined
+    };
+}
+//# sourceMappingURL=worktreeTools.js.map