@wundr.io/cli 1.0.11 → 1.0.12

package/dist/commands/worktree.js

@@ -1,774 +0,0 @@
-"use strict";
-/**
- * Worktree Management CLI Commands
- *
- * Manages git worktrees for multi-agent development including
- * listing, creating, switching, cleanup, and synchronization.
- *
- * @module commands/worktree
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWorktreeCommand = createWorktreeCommand;
-const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
-const fs = tslib_1.__importStar(require("fs/promises"));
-const os = tslib_1.__importStar(require("os"));
-const path = tslib_1.__importStar(require("path"));
-const util_1 = require("util");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const commander_1 = require("commander");
-const ora_1 = tslib_1.__importDefault(require("ora"));
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
-// Constants
-const WORKTREE_STATE_DIR = path.join(os.homedir(), '.wundr', 'worktrees');
-const WORKTREE_STATE_FILE = path.join(WORKTREE_STATE_DIR, 'state.json');
-// Utility functions
-function getTimestamp() {
-    return new Date().toISOString();
-}
-function padRight(str, length) {
-    return str.length >= length
-        ? str.substring(0, length)
-        : str + ' '.repeat(length - str.length);
-}
-function truncate(str, length) {
-    if (str.length <= length) {
-        return str;
-    }
-    return str.substring(0, length - 3) + '...';
-}
-function formatAge(dateStr) {
-    const date = new Date(dateStr);
-    const now = Date.now();
-    const diffMs = now - date.getTime();
-    const diffMins = Math.floor(diffMs / (1000 * 60));
-    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    if (diffDays > 0) {
-        return `${diffDays}d ago`;
-    }
-    if (diffHours > 0) {
-        return `${diffHours}h ago`;
-    }
-    if (diffMins > 0) {
-        return `${diffMins}m ago`;
-    }
-    return 'just now';
-}
-function generateSessionId() {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 8);
-    return `session-${timestamp}-${random}`;
-}
-function generateBranchName(taskId) {
-    const sanitized = taskId
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '');
-    return `task/${sanitized}`;
-}
-async function ensureStateDir() {
-    await fs.mkdir(WORKTREE_STATE_DIR, { recursive: true });
-}
-async function loadWorktreeState() {
-    try {
-        await ensureStateDir();
-        const content = await fs.readFile(WORKTREE_STATE_FILE, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        // Return empty state if file doesn't exist
-        return {
-            version: '1.0.0',
-            lastUpdated: getTimestamp(),
-            repoPath: process.cwd(),
-            worktrees: [],
-        };
-    }
-}
-async function saveWorktreeState(state) {
-    await ensureStateDir();
-    state.lastUpdated = getTimestamp();
-    await fs.writeFile(WORKTREE_STATE_FILE, JSON.stringify(state, null, 2));
-}
-async function getGitRepoRoot() {
-    try {
-        const { stdout } = await execAsync('git rev-parse --show-toplevel', {
-            timeout: 10000,
-        });
-        return stdout.trim();
-    }
-    catch {
-        return process.cwd();
-    }
-}
-async function executeGitCommand(command, args, cwd) {
-    const fullCommand = `git ${command} ${args.join(' ')}`;
-    try {
-        const { stdout } = await execAsync(fullCommand, { cwd, timeout: 60000 });
-        return stdout.trim();
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Git command failed: ${fullCommand}\n${errorMessage}`);
-    }
-}
-async function listGitWorktrees(repoPath) {
-    const worktrees = [];
-    try {
-        const output = await executeGitCommand('worktree', ['list', '--porcelain'], repoPath);
-        const entries = output.split('\n\n').filter(Boolean);
-        for (const entry of entries) {
-            const lines = entry.split('\n');
-            const info = {
-                isMain: false,
-                isLocked: false,
-            };
-            for (const line of lines) {
-                if (line.startsWith('worktree ')) {
-                    info.path = line.substring('worktree '.length).trim();
-                }
-                else if (line.startsWith('HEAD ')) {
-                    info.commit = line.substring('HEAD '.length).trim();
-                }
-                else if (line.startsWith('branch ')) {
-                    info.branch = line
-                        .substring('branch '.length)
-                        .trim()
-                        .replace('refs/heads/', '');
-                }
-                else if (line === 'bare') {
-                    info.isMain = true;
-                }
-                else if (line === 'locked') {
-                    info.isLocked = true;
-                }
-            }
-            if (info.path) {
-                // Check if this is the main worktree
-                if (info.path === repoPath) {
-                    info.isMain = true;
-                }
-                // Get last modified time
-                try {
-                    const stats = await fs.stat(info.path);
-                    info.lastModified = stats.mtime;
-                }
-                catch {
-                    // Path might not exist for orphaned worktrees
-                }
-                worktrees.push(info);
-            }
-        }
-    }
-    catch {
-        // Return empty list if git command fails
-    }
-    return worktrees;
-}
-async function hasUncommittedChanges(worktreePath) {
-    try {
-        const { stdout } = await execAsync('git status --porcelain', {
-            cwd: worktreePath,
-            timeout: 10000,
-        });
-        return stdout.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-function getStatusColor(status) {
-    switch (status) {
-        case 'active':
-            return chalk_1.default.green;
-        case 'paused':
-            return chalk_1.default.yellow;
-        case 'syncing':
-            return chalk_1.default.blue;
-        case 'creating':
-            return chalk_1.default.cyan;
-        case 'cleanup':
-            return chalk_1.default.magenta;
-        case 'error':
-            return chalk_1.default.red;
-        case 'destroyed':
-            return chalk_1.default.gray;
-        case 'pending':
-            return chalk_1.default.white;
-        default:
-            return chalk_1.default.white;
-    }
-}
-function getStatusIcon(status) {
-    switch (status) {
-        case 'active':
-            return '[ACTIVE]';
-        case 'paused':
-            return '[PAUSED]';
-        case 'syncing':
-            return '[SYNCING]';
-        case 'creating':
-            return '[CREATING]';
-        case 'cleanup':
-            return '[CLEANUP]';
-        case 'error':
-            return '[ERROR]';
-        case 'destroyed':
-            return '[DESTROYED]';
-        case 'pending':
-            return '[PENDING]';
-        default:
-            return '[UNKNOWN]';
-    }
-}
-/**
- * Create the worktree command with all subcommands
- */
-function createWorktreeCommand() {
-    const command = new commander_1.Command('worktree')
-        .alias('wt')
-        .description('Manage git worktrees for multi-agent development')
-        .addHelpText('after', chalk_1.default.gray(`
-Examples:
-  ${chalk_1.default.green('wundr worktree list')}                 List all worktrees
-  ${chalk_1.default.green('wundr wt list --session <id>')}       List worktrees for a session
-  ${chalk_1.default.green('wundr worktree create <taskId>')}     Create new worktree for a task
-  ${chalk_1.default.green('wundr worktree switch <taskId>')}     Switch to an existing worktree
-  ${chalk_1.default.green('wundr worktree cleanup --dry-run')}   Preview what would be cleaned up
-  ${chalk_1.default.green('wundr worktree sync')}                Sync all worktrees from remote
-  ${chalk_1.default.green('wundr worktree sync <taskId>')}       Sync specific worktree
-      `));
-    // List command (default)
-    command
-        .command('list', { isDefault: true })
-        .description('List all worktrees')
-        .option('-s, --session <id>', 'Filter by session ID')
-        .option('--status <status>', 'Filter by status (active, paused, syncing, error, etc.)')
-        .option('-f, --format <format>', 'Output format (table, json)', 'table')
-        .action(async (options) => {
-        await listWorktrees(options);
-    });
-    // Create command (ccswitch create)
-    command
-        .command('create <taskId>')
-        .description('Create a new worktree for a task')
-        .option('-b, --base <branch>', 'Base branch to create from', 'main')
-        .action(async (taskId, options) => {
-        await createWorktree(taskId, options);
-    });
-    // Switch command (ccswitch switch)
-    command
-        .command('switch <taskId>')
-        .description('Switch to an existing worktree')
-        .action(async (taskId) => {
-        await switchWorktree(taskId);
-    });
-    // Cleanup command
-    command
-        .command('cleanup')
-        .description('Clean up stale worktrees')
-        .option('--dry-run', 'Preview what would be cleaned up without making changes')
-        .option('--force', 'Force cleanup even with uncommitted changes')
-        .option('--age <days>', 'Clean up worktrees older than specified days', '7')
-        .action(async (options) => {
-        await cleanupWorktrees(options);
-    });
-    // Sync command
-    command
-        .command('sync [taskId]')
-        .description('Sync worktree(s) from remote')
-        .option('--all', 'Sync all worktrees')
-        .action(async (taskId, options) => {
-        await syncWorktrees(taskId, options);
-    });
-    return command;
-}
-// Command implementations
-async function listWorktrees(options) {
-    const spinner = (0, ora_1.default)('Loading worktrees...').start();
-    try {
-        const state = await loadWorktreeState();
-        let worktrees = state.worktrees;
-        // Filter by session ID if provided
-        if (options.session) {
-            worktrees = worktrees.filter(wt => wt.sessionId === options.session);
-        }
-        // Filter by status if provided
-        if (options.status) {
-            worktrees = worktrees.filter(wt => wt.status === options.status);
-        }
-        spinner.stop();
-        if (options.format === 'json') {
-            console.log(JSON.stringify({
-                timestamp: getTimestamp(),
-                count: worktrees.length,
-                worktrees: worktrees,
-            }, null, 2));
-            return;
-        }
-        console.log(chalk_1.default.cyan('\nWorktree List'));
-        console.log(chalk_1.default.gray('='.repeat(110)));
-        if (worktrees.length === 0) {
-            console.log(chalk_1.default.yellow('\nNo worktrees found.'));
-            if (options.session) {
-                console.log(chalk_1.default.gray(`No worktrees for session: ${options.session}`));
-            }
-            console.log('');
-            return;
-        }
-        // Table header
-        console.log(chalk_1.default.cyan(padRight('Task ID', 20) +
-            padRight('Branch', 25) +
-            padRight('Status', 12) +
-            padRight('Created', 12) +
-            padRight('Path', 40)));
-        console.log(chalk_1.default.gray('-'.repeat(110)));
-        // Table rows
-        for (const wt of worktrees) {
-            const statusColor = getStatusColor(wt.status);
-            const createdAge = formatAge(wt.createdAt);
-            const worktreePath = truncate(wt.worktreePath, 38);
-            const branchName = truncate(wt.branchName, 23);
-            console.log(padRight(wt.taskId, 20) +
-                chalk_1.default.blue(padRight(branchName, 25)) +
-                statusColor(padRight(getStatusIcon(wt.status), 12)) +
-                padRight(createdAge, 12) +
-                chalk_1.default.gray(padRight(worktreePath, 40)));
-        }
-        console.log(chalk_1.default.gray('-'.repeat(110)));
-        console.log(chalk_1.default.gray(`Total: ${worktrees.length} worktree(s)`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail('Failed to load worktrees');
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-    }
-}
-async function createWorktree(taskId, options) {
-    const spinner = (0, ora_1.default)(`Creating worktree for task: ${taskId}...`).start();
-    try {
-        const state = await loadWorktreeState();
-        const repoPath = await getGitRepoRoot();
-        state.repoPath = repoPath;
-        // Check if worktree already exists
-        const existing = state.worktrees.find(wt => wt.taskId === taskId);
-        if (existing) {
-            spinner.fail(`Worktree already exists for task: ${taskId}`);
-            console.log(chalk_1.default.yellow(`Use "wundr worktree switch ${taskId}" to switch to it.`));
-            return;
-        }
-        const baseBranch = options.base || 'main';
-        const branchName = generateBranchName(taskId);
-        const sessionId = generateSessionId();
-        const worktreeRoot = path.join(repoPath, '.git-worktrees', 'sessions');
-        const worktreePath = path.join(worktreeRoot, taskId);
-        // Ensure worktree root exists
-        await fs.mkdir(worktreeRoot, { recursive: true });
-        // Fetch latest from remote
-        try {
-            await executeGitCommand('fetch', ['origin', baseBranch], repoPath);
-        }
-        catch {
-            // Continue even if fetch fails (might be offline)
-        }
-        // Create the worktree with a new branch
-        await executeGitCommand('worktree', ['add', '-b', branchName, worktreePath, `origin/${baseBranch}`], repoPath);
-        // Save to state
-        const entry = {
-            taskId,
-            branchName,
-            worktreePath,
-            sessionId,
-            status: 'active',
-            createdAt: getTimestamp(),
-            lastAccessedAt: getTimestamp(),
-        };
-        state.worktrees.push(entry);
-        await saveWorktreeState(state);
-        spinner.succeed(`Worktree created for task: ${taskId}`);
-        console.log('');
-        console.log(chalk_1.default.white('  Task ID:    ') + chalk_1.default.green(taskId));
-        console.log(chalk_1.default.white('  Branch:     ') + chalk_1.default.blue(branchName));
-        console.log(chalk_1.default.white('  Path:       ') + chalk_1.default.gray(worktreePath));
-        console.log('');
-        console.log(chalk_1.default.gray(`Use "wundr worktree switch ${taskId}" to start working.`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail('Failed to create worktree');
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-    }
-}
-async function switchWorktree(taskId) {
-    const spinner = (0, ora_1.default)(`Switching to worktree: ${taskId}...`).start();
-    try {
-        const state = await loadWorktreeState();
-        // Find the worktree
-        const worktree = state.worktrees.find(wt => wt.taskId === taskId);
-        if (!worktree) {
-            spinner.fail(`Worktree not found: ${taskId}`);
-            console.log(chalk_1.default.yellow(`Use "wundr worktree create ${taskId}" to create it.`));
-            return;
-        }
-        // Check if worktree path exists
-        try {
-            await fs.access(worktree.worktreePath);
-        }
-        catch {
-            spinner.fail(`Worktree directory not found: ${worktree.worktreePath}`);
-            console.log(chalk_1.default.yellow('The worktree may have been deleted. Consider running cleanup.'));
-            return;
-        }
-        // Update status
-        worktree.status = 'active';
-        worktree.lastAccessedAt = getTimestamp();
-        await saveWorktreeState(state);
-        spinner.succeed(`Switched to worktree: ${taskId}`);
-        console.log('');
-        console.log(chalk_1.default.white('  Task ID:    ') + chalk_1.default.green(taskId));
-        console.log(chalk_1.default.white('  Branch:     ') + chalk_1.default.blue(worktree.branchName));
-        console.log(chalk_1.default.white('  Path:       ') + chalk_1.default.gray(worktree.worktreePath));
-        console.log('');
-        console.log(chalk_1.default.cyan('To navigate to this worktree, run:'));
-        console.log(chalk_1.default.white(`  cd ${worktree.worktreePath}`));
-        console.log('');
-    }
-    catch (error) {
-        spinner.fail('Failed to switch worktree');
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-    }
-}
-async function cleanupWorktrees(options) {
-    const maxAgeDays = parseInt(options.age || '7', 10);
-    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-    const spinner = (0, ora_1.default)(options.dryRun ? 'Analyzing worktrees...' : 'Cleaning up worktrees...').start();
-    try {
-        const state = await loadWorktreeState();
-        const repoPath = state.repoPath || (await getGitRepoRoot());
-        const now = Date.now();
-        // Get actual git worktrees
-        const gitWorktrees = await listGitWorktrees(repoPath);
-        // Categorize worktrees for cleanup
-        const toRemove = [];
-        const toSkip = [];
-        // Check state entries
-        for (const entry of state.worktrees) {
-            const createdAt = new Date(entry.createdAt).getTime();
-            const age = now - createdAt;
-            const gitInfo = gitWorktrees.find(g => g.path === entry.worktreePath);
-            // Check if worktree still exists
-            try {
-                await fs.access(entry.worktreePath);
-            }
-            catch {
-                toRemove.push({ entry, reason: 'Directory no longer exists' });
-                continue;
-            }
-            // Check if too old
-            if (age > maxAgeMs) {
-                // Check for uncommitted changes
-                const hasChanges = await hasUncommittedChanges(entry.worktreePath);
-                if (hasChanges && !options.force) {
-                    toSkip.push({ entry, gitInfo, reason: 'Has uncommitted changes' });
-                }
-                else if (gitInfo?.isLocked && !options.force) {
-                    toSkip.push({ entry, gitInfo, reason: 'Worktree is locked' });
-                }
-                else {
-                    toRemove.push({
-                        entry,
-                        gitInfo,
-                        reason: `Older than ${maxAgeDays} days`,
-                    });
-                }
-            }
-            // Check error status
-            if (entry.status === 'error' && !options.force) {
-                toRemove.push({ entry, gitInfo, reason: 'In error state' });
-            }
-        }
-        spinner.stop();
-        if (options.dryRun) {
-            // Show preview
-            console.log(chalk_1.default.cyan('\nCleanup Preview (Dry Run)'));
-            console.log(chalk_1.default.gray('='.repeat(80)));
-            if (toRemove.length === 0) {
-                console.log(chalk_1.default.green('\nNo worktrees need to be cleaned up.'));
-                console.log('');
-                return;
-            }
-            console.log(chalk_1.default.yellow(`\nWorktrees to be removed: ${toRemove.length}`));
-            console.log(chalk_1.default.gray('-'.repeat(80)));
-            for (const { entry, reason } of toRemove) {
-                if (entry) {
-                    console.log(chalk_1.default.white('  Task ID: ') + chalk_1.default.green(entry.taskId));
-                    console.log(chalk_1.default.white('  Path:    ') + chalk_1.default.gray(entry.worktreePath));
-                    console.log(chalk_1.default.white('  Branch:  ') + chalk_1.default.blue(entry.branchName));
-                    console.log(chalk_1.default.white('  Reason:  ') + chalk_1.default.yellow(reason));
-                    console.log('');
-                }
-            }
-            if (toSkip.length > 0) {
-                console.log(chalk_1.default.yellow(`\nWorktrees to be skipped: ${toSkip.length}`));
-                console.log(chalk_1.default.gray('-'.repeat(80)));
-                for (const { entry, reason } of toSkip) {
-                    if (entry) {
-                        console.log(chalk_1.default.white('  Task ID: ') + chalk_1.default.green(entry.taskId));
-                        console.log(chalk_1.default.white('  Path:    ') + chalk_1.default.gray(entry.worktreePath));
-                        console.log(chalk_1.default.white('  Reason:  ') + chalk_1.default.gray(reason));
-                        console.log('');
-                    }
-                }
-            }
-            console.log(chalk_1.default.gray('-'.repeat(80)));
-            console.log(chalk_1.default.gray('Run without --dry-run to perform actual cleanup.'));
-            console.log('');
-        }
-        else {
-            // Perform actual cleanup
-            const result = {
-                success: true,
-                removedCount: 0,
-                removedPaths: [],
-                skippedPaths: [],
-                skipReasons: new Map(),
-                errors: [],
-            };
-            for (const { entry, reason } of toRemove) {
-                if (!entry) {
-                    continue;
-                }
-                try {
-                    // Remove the git worktree
-                    const forceFlag = options.force ? '--force' : '';
-                    await executeGitCommand('worktree', ['remove', forceFlag, entry.worktreePath].filter(Boolean), repoPath);
-                    result.removedCount++;
-                    result.removedPaths.push(entry.worktreePath);
-                }
-                catch (error) {
-                    // Try manual removal if git worktree remove fails
-                    if (options.force) {
-                        try {
-                            await fs.rm(entry.worktreePath, { recursive: true, force: true });
-                            await executeGitCommand('worktree', ['prune'], repoPath);
-                            result.removedCount++;
-                            result.removedPaths.push(entry.worktreePath);
-                        }
-                        catch (rmError) {
-                            result.errors.push({
-                                path: entry.worktreePath,
-                                message: rmError instanceof Error ? rmError.message : String(rmError),
-                            });
-                        }
-                    }
-                    else {
-                        result.errors.push({
-                            path: entry.worktreePath,
-                            message: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                }
-            }
-            for (const { entry, reason } of toSkip) {
-                if (entry) {
-                    result.skippedPaths.push(entry.worktreePath);
-                    result.skipReasons.set(entry.worktreePath, reason);
-                }
-            }
-            // Update state file to remove cleaned worktrees
-            const removedPaths = new Set(result.removedPaths);
-            state.worktrees = state.worktrees.filter(wt => !removedPaths.has(wt.worktreePath));
-            await saveWorktreeState(state);
-            // Show results
-            console.log(chalk_1.default.cyan('\nCleanup Results'));
-            console.log(chalk_1.default.gray('='.repeat(80)));
-            if (result.removedCount === 0 && result.errors.length === 0) {
-                console.log(chalk_1.default.green('\nNo worktrees needed to be cleaned up.'));
-                console.log('');
-                return;
-            }
-            if (result.removedCount > 0) {
-                console.log(chalk_1.default.green(`\nRemoved ${result.removedCount} worktree(s):`));
-                for (const removedPath of result.removedPaths) {
-                    console.log(chalk_1.default.gray(`  - ${removedPath}`));
-                }
-            }
-            if (result.skippedPaths.length > 0) {
-                console.log(chalk_1.default.yellow(`\nSkipped ${result.skippedPaths.length} worktree(s):`));
-                for (const skippedPath of result.skippedPaths) {
-                    const reason = result.skipReasons.get(skippedPath) || 'unknown';
-                    console.log(chalk_1.default.gray(`  - ${skippedPath}: ${reason}`));
-                }
-            }
-            if (result.errors.length > 0) {
-                console.log(chalk_1.default.red(`\nErrors (${result.errors.length}):`));
-                for (const error of result.errors) {
-                    console.log(chalk_1.default.red(`  - ${error.path}: ${error.message}`));
-                }
-            }
-            console.log('');
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to cleanup worktrees');
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-    }
-}
-async function syncWorktrees(taskId, options) {
-    const spinner = (0, ora_1.default)(taskId ? `Syncing worktree: ${taskId}...` : 'Syncing worktrees...').start();
-    try {
-        const state = await loadWorktreeState();
-        const repoPath = state.repoPath || (await getGitRepoRoot());
-        const syncSingleWorktree = async (worktree) => {
-            const timestamp = new Date();
-            let stashedChanges = false;
-            try {
-                // Check for uncommitted changes
-                const hasChanges = await hasUncommittedChanges(worktree.worktreePath);
-                if (hasChanges) {
-                    // Stash changes
-                    await executeGitCommand('stash', ['push', '-m', 'auto-stash before sync'], worktree.worktreePath);
-                    stashedChanges = true;
-                }
-                // Fetch from remote
-                await executeGitCommand('fetch', ['origin'], worktree.worktreePath);
-                // Get current branch
-                const branchName = await executeGitCommand('rev-parse', ['--abbrev-ref', 'HEAD'], worktree.worktreePath);
-                // Try fast-forward pull
-                try {
-                    await executeGitCommand('pull', ['--ff-only', 'origin', branchName], worktree.worktreePath);
-                }
-                catch {
-                    // Fast-forward not possible, try rebase
-                    await executeGitCommand('rebase', [`origin/${branchName}`], worktree.worktreePath);
-                }
-                // Count commits updated (approximate)
-                let commitsUpdated = 0;
-                try {
-                    const { stdout } = await execAsync(`git rev-list --count origin/${branchName}..HEAD`, { cwd: worktree.worktreePath, timeout: 10000 });
-                    commitsUpdated = parseInt(stdout.trim(), 10) || 0;
-                }
-                catch {
-                    // Ignore count errors
-                }
-                // Restore stashed changes
-                if (stashedChanges) {
-                    try {
-                        await executeGitCommand('stash', ['pop'], worktree.worktreePath);
-                    }
-                    catch {
-                        // Stash pop might have conflicts
-                    }
-                }
-                return {
-                    success: true,
-                    message: 'Successfully synced',
-                    worktreePath: worktree.worktreePath,
-                    branchName,
-                    stashedChanges,
-                    commitsUpdated,
-                    timestamp,
-                };
-            }
-            catch (error) {
-                // Try to restore stash on failure
-                if (stashedChanges) {
-                    try {
-                        await executeGitCommand('stash', ['pop'], worktree.worktreePath);
-                    }
-                    catch {
-                        // Ignore
-                    }
-                }
-                return {
-                    success: false,
-                    message: error instanceof Error ? error.message : String(error),
-                    worktreePath: worktree.worktreePath,
-                    stashedChanges,
-                    timestamp,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                };
-            }
-        };
-        if (taskId) {
-            // Sync specific worktree
-            const worktree = state.worktrees.find(wt => wt.taskId === taskId);
-            if (!worktree) {
-                spinner.fail(`Worktree not found: ${taskId}`);
-                return;
-            }
-            // Update status to syncing
-            worktree.status = 'syncing';
-            await saveWorktreeState(state);
-            const result = await syncSingleWorktree(worktree);
-            // Update status based on result
-            worktree.status = result.success ? 'active' : 'error';
-            worktree.lastAccessedAt = getTimestamp();
-            await saveWorktreeState(state);
-            spinner.stop();
-            if (result.success) {
-                console.log(chalk_1.default.green(`\nSuccessfully synced worktree: ${taskId}`));
-                console.log(chalk_1.default.white('  Branch:  ') +
-                    chalk_1.default.blue(result.branchName || 'unknown'));
-                console.log(chalk_1.default.white('  Commits: ') +
-                    chalk_1.default.cyan(`${result.commitsUpdated || 0} updated`));
-                if (result.stashedChanges) {
-                    console.log(chalk_1.default.yellow('  Note: Local changes were stashed and restored.'));
-                }
-            }
-            else {
-                console.log(chalk_1.default.red(`\nFailed to sync worktree: ${taskId}`));
-                console.log(chalk_1.default.red(`  Error: ${result.message}`));
-            }
-            console.log('');
-        }
-        else if (options.all || !taskId) {
-            // Sync all active worktrees
-            const activeWorktrees = state.worktrees.filter(wt => wt.status === 'active' || wt.status === 'paused');
-            if (activeWorktrees.length === 0) {
-                spinner.stop();
-                console.log(chalk_1.default.yellow('\nNo active worktrees to sync.'));
-                console.log('');
-                return;
-            }
-            spinner.text = `Syncing ${activeWorktrees.length} worktree(s)...`;
-            const results = [];
-            for (const wt of activeWorktrees) {
-                wt.status = 'syncing';
-                await saveWorktreeState(state);
-                const result = await syncSingleWorktree(wt);
-                wt.status = result.success ? 'active' : 'error';
-                wt.lastAccessedAt = getTimestamp();
-                results.push({ taskId: wt.taskId, result });
-            }
-            await saveWorktreeState(state);
-            spinner.stop();
-            console.log(chalk_1.default.cyan('\nSync Results'));
-            console.log(chalk_1.default.gray('='.repeat(80)));
-            const successful = results.filter(r => r.result.success);
-            const failed = results.filter(r => !r.result.success);
-            if (successful.length > 0) {
-                console.log(chalk_1.default.green(`\nSuccessfully synced: ${successful.length}`));
-                for (const { taskId: tid, result } of successful) {
-                    console.log(chalk_1.default.gray(`  - ${tid}: ${result.commitsUpdated || 0} commit(s) updated`));
-                }
-            }
-            if (failed.length > 0) {
-                console.log(chalk_1.default.red(`\nFailed to sync: ${failed.length}`));
-                for (const { taskId: tid, result } of failed) {
-                    console.log(chalk_1.default.red(`  - ${tid}: ${result.message}`));
-                }
-            }
-            console.log('');
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to sync worktrees');
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-    }
-}
-// Export for registration
-exports.default = createWorktreeCommand;
-//# sourceMappingURL=worktree.js.map