@mod-computer/cli 0.2.4 → 0.2.5

package/dist/commands/branch.js

@@ -1,1411 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { createModWorkspace } from '@mod/mod-core/mod-workspace';
-import { readModConfig, writeModConfig } from '../services/mod-config.js';
-import { AutomaticFileTracker } from '../services/automatic-file-tracker.js';
-import { SyncDaemon } from '../services/sync-daemon.js';
-class MyersDiffCalculator {
-    static calculateDiff(baseline, current) {
-        const baselineLines = baseline.split('\n');
-        const currentLines = current.split('\n');
-        // Early exit optimization for identical content
-        if (baseline === current) {
-            return { linesAdded: 0, linesRemoved: 0, changes: [] };
-        }
-        // Simplified Myers algorithm implementation
-        const changes = this.computeChanges(baselineLines, currentLines);
-        let linesAdded = 0;
-        let linesRemoved = 0;
-        for (const change of changes) {
-            if (change.type === 'add')
-                linesAdded++;
-            if (change.type === 'remove')
-                linesRemoved++;
-        }
-        return { linesAdded, linesRemoved, changes };
-    }
-    static computeChanges(baseline, current) {
-        const changes = [];
-        const lcs = this.longestCommonSubsequence(baseline, current);
-        let baselineIndex = 0;
-        let currentIndex = 0;
-        let lcsIndex = 0;
-        while (baselineIndex < baseline.length || currentIndex < current.length) {
-            if (lcsIndex < lcs.length &&
-                baselineIndex < baseline.length &&
-                baseline[baselineIndex] === lcs[lcsIndex] &&
-                currentIndex < current.length &&
-                current[currentIndex] === lcs[lcsIndex]) {
-                // Lines match - unchanged
-                changes.push({
-                    type: 'unchanged',
-                    line: baseline[baselineIndex],
-                    lineNumber: baselineIndex + 1
-                });
-                baselineIndex++;
-                currentIndex++;
-                lcsIndex++;
-            }
-            else if (currentIndex < current.length &&
-                (lcsIndex >= lcs.length || current[currentIndex] !== lcs[lcsIndex])) {
-                // Line added in current
-                changes.push({
-                    type: 'add',
-                    line: current[currentIndex],
-                    lineNumber: currentIndex + 1
-                });
-                currentIndex++;
-            }
-            else if (baselineIndex < baseline.length &&
-                (lcsIndex >= lcs.length || baseline[baselineIndex] !== lcs[lcsIndex])) {
-                // Line removed from baseline
-                changes.push({
-                    type: 'remove',
-                    line: baseline[baselineIndex],
-                    lineNumber: baselineIndex + 1
-                });
-                baselineIndex++;
-            }
-        }
-        return changes;
-    }
-    static longestCommonSubsequence(a, b) {
-        const m = a.length;
-        const n = b.length;
-        const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
-        // Build LCS table
-        for (let i = 1; i <= m; i++) {
-            for (let j = 1; j <= n; j++) {
-                if (a[i - 1] === b[j - 1]) {
-                    dp[i][j] = dp[i - 1][j - 1] + 1;
-                }
-                else {
-                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-                }
-            }
-        }
-        // Backtrack to find LCS
-        const lcs = [];
-        let i = m, j = n;
-        while (i > 0 && j > 0) {
-            if (a[i - 1] === b[j - 1]) {
-                lcs.unshift(a[i - 1]);
-                i--;
-                j--;
-            }
-            else if (dp[i - 1][j] > dp[i][j - 1]) {
-                i--;
-            }
-            else {
-                j--;
-            }
-        }
-        return lcs;
-    }
-}
-class FileFilter {
-    constructor() {
-        this.ignorePatterns = [];
-        this.loadIgnorePatterns();
-    }
-    loadIgnorePatterns() {
-        const patterns = [
-            // Common build artifacts that should be excluded
-            '*.js', '*.d.ts', '*.js.map', // TypeScript build outputs
-            'node_modules/**',
-            'dist/**', 'build/**',
-            '.cache/**',
-            '*.log',
-            '.DS_Store',
-            'coverage/**'
-        ];
-        // Load .gitignore if exists
-        const gitignorePath = path.join(process.cwd(), '.gitignore');
-        if (fs.existsSync(gitignorePath)) {
-            try {
-                const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
-                const gitignorePatterns = gitignoreContent
-                    .split('\n')
-                    .map(line => line.trim())
-                    .filter(line => line && !line.startsWith('#'));
-                patterns.push(...gitignorePatterns);
-            }
-            catch (error) {
-                console.warn('Could not read .gitignore:', error);
-            }
-        }
-        // Load .modignore if exists  
-        const modignorePath = path.join(process.cwd(), '.modignore');
-        if (fs.existsSync(modignorePath)) {
-            try {
-                const modignoreContent = fs.readFileSync(modignorePath, 'utf8');
-                const modignorePatterns = modignoreContent
-                    .split('\n')
-                    .map(line => line.trim())
-                    .filter(line => line && !line.startsWith('#'));
-                patterns.push(...modignorePatterns);
-            }
-            catch (error) {
-                console.warn('Could not read .modignore:', error);
-            }
-        }
-        this.ignorePatterns = patterns;
-    }
-    isSourceFile(filePath) {
-        // Check if file should be ignored
-        if (this.shouldIgnoreFile(filePath)) {
-            return false;
-        }
-        // Check if it's a source file type
-        const sourceExtensions = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.py', '.go', '.rs', '.java', '.cpp', '.c', '.h', '.hpp', '.md', '.yaml', '.yml', '.json'];
-        const ext = path.extname(filePath).toLowerCase();
-        // Special case: exclude .js/.d.ts files if corresponding .ts file exists
-        if (ext === '.js' || ext === '.d.ts') {
-            const tsFile = filePath.replace(/\.(js|d\.ts)$/, '.ts');
-            if (fs.existsSync(tsFile)) {
-                return false; // This is a build artifact
-            }
-        }
-        return sourceExtensions.includes(ext);
-    }
-    shouldIgnoreFile(filePath) {
-        const normalizedPath = filePath.replace(/\\/g, '/');
-        return this.ignorePatterns.some(pattern => {
-            // Simple glob pattern matching
-            if (pattern.includes('**')) {
-                const regex = new RegExp(pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*'));
-                return regex.test(normalizedPath);
-            }
-            else if (pattern.includes('*')) {
-                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-                return regex.test(path.basename(normalizedPath));
-            }
-            else {
-                return normalizedPath.includes(pattern) || path.basename(normalizedPath) === pattern;
-            }
-        });
-    }
-    filterSourceFiles(files) {
-        return files.filter(file => {
-            const filePath = file.path || file.name || '';
-            return this.isSourceFile(filePath);
-        });
-    }
-}
-function generateBranchName(input) {
-    return input
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, '') // Remove special chars except spaces and hyphens
-        .replace(/\s+/g, '-') // Replace spaces with hyphens
-        .replace(/-+/g, '-') // Collapse multiple hyphens
-        .replace(/^-|-$/g, '') // Remove leading/trailing hyphens
-        .substring(0, 50); // Limit length
-}
-export async function branchCommand(args, repo) {
-    const cfg = readModConfig();
-    if (!cfg?.workspaceId) {
-        console.error('No active workspace configured in .mod/config.json');
-        process.exit(1);
-    }
-    const modWorkspace = createModWorkspace(repo);
-    let workspaceHandle;
-    try {
-        workspaceHandle = await openExistingWorkspace(modWorkspace, cfg.workspaceId);
-    }
-    catch (error) {
-        console.error('Failed to initialize workspace:', error);
-        console.log('Try running: mod sync-workspace to repair workspace state');
-        process.exit(1);
-    }
-    const [subcommand, ...rest] = args;
-    switch (subcommand) {
-        case 'create':
-            await handleCreateBranch(workspaceHandle, rest);
-            break;
-        case 'switch':
-            await handleSwitchBranch(workspaceHandle, rest);
-            break;
-        case 'list':
-            await handleListBranches(workspaceHandle, rest);
-            break;
-        case 'status':
-            await handleBranchStatus(workspaceHandle, rest);
-            break;
-        case 'coverage':
-            await handleCoverageAnalysis(workspaceHandle, rest);
-            break;
-        case 'tree':
-            await handleTreeView(workspaceHandle, rest);
-            break;
-        case 'auto-track':
-            await handleAutoTrack(workspaceHandle, rest, repo);
-            return; // Don't exit when auto-track is running
-        default:
-            await handleListBranches(workspaceHandle, []);
-    }
-    process.exit(0);
-}
-function detectBranchType(branchName, hasSpecFlag, hasLightweightFlag) {
-    // Explicit flags override auto-detection
-    if (hasSpecFlag)
-        return 'specification';
-    if (hasLightweightFlag)
-        return 'lightweight';
-    const lightweightPrefixes = ['fix-', 'hotfix-', 'patch-', 'deps-', 'chore-'];
-    if (lightweightPrefixes.some(prefix => branchName.startsWith(prefix))) {
-        return 'lightweight';
-    }
-    const specPrefixes = ['feature-', 'feat-', 'refactor-', 'implement-'];
-    if (specPrefixes.some(prefix => branchName.startsWith(prefix))) {
-        return 'specification';
-    }
-    return 'lightweight';
-}
-async function handleCreateBranch(workspaceHandle, args) {
-    if (args.length === 0) {
-        console.error('Usage: mod branch create <branch-name> [--from <parent-branch>] [--spec <spec-path>] [--lightweight]');
-        process.exit(1);
-    }
-    const branchName = args[0];
-    const fromIndex = args.indexOf('--from');
-    const specIndex = args.indexOf('--spec');
-    const lightweightFlag = args.includes('--lightweight');
-    const fromBranch = fromIndex >= 0 && fromIndex + 1 < args.length ? args[fromIndex + 1] : undefined;
-    const specPath = specIndex >= 0 && specIndex + 1 < args.length ? args[specIndex + 1] : undefined;
-    const branchType = detectBranchType(branchName, !!specPath, lightweightFlag);
-    try {
-        const typeIndicator = branchType === 'specification' ? 'specification' : 'lightweight';
-        console.log(`Creating ${typeIndicator} branch: ${branchName}${fromBranch ? ` from ${fromBranch}` : ''}...`);
-        const createOptions = {
-            name: branchName,
-            fromBranch: fromBranch,
-            spec: (branchType === 'specification' && specPath) ? {
-                file: specPath,
-                title: branchName
-            } : undefined
-        };
-        const branch = await workspaceHandle.branch.create(createOptions);
-        console.log(`[DEBUG] Created branch: ${branch.name} (${branch.id})`);
-        await workspaceHandle.branch.switchActive(branch.id);
-        console.log(`[DEBUG] Switched to branch: ${branch.id}`);
-        // Wait a moment and verify the branch appears in the list
-        const branches = await workspaceHandle.branch.list();
-        console.log(`[DEBUG] Branches after creation:`, branches.map((b) => `${b.name} (${b.id})`));
-        const createdBranchExists = branches.find((b) => b.id === branch.id);
-        console.log(`[DEBUG] Created branch exists in list: ${!!createdBranchExists}`);
-        // Add delay and force persistence to ensure branch is saved
-        await new Promise(resolve => setTimeout(resolve, 500));
-        const cfg = readModConfig();
-        const updatedConfig = {
-            ...cfg,
-            workspaceId: cfg?.workspaceId,
-            activeBranchId: branch.id,
-            lastSpecificationPath: specPath
-        };
-        writeModConfig(updatedConfig);
-        console.log(`✓ Created and switched to ${typeIndicator} branch: ${branchName} (${branch.id})`);
-        if (specPath && branchType === 'specification') {
-            console.log(`✓ Linked to specification: ${specPath}`);
-        }
-        else if (branchType === 'lightweight') {
-            console.log(`💡 Lightweight branch - no specification tracking required`);
-        }
-    }
-    catch (error) {
-        console.error('Failed to create branch:', error);
-        console.log('Try running: mod branches list --wait to check workspace sync status');
-        process.exit(1);
-    }
-}
-async function handleSwitchBranch(workspaceHandle, args) {
-    if (args.length === 0) {
-        console.error('Usage: mod branch switch <branch-name>');
-        process.exit(1);
-    }
-    const targetBranchName = args[0];
-    try {
-        const branches = await workspaceHandle.branch.list();
-        const targetBranch = branches.find((b) => b.name === targetBranchName || b.id === targetBranchName);
-        if (!targetBranch) {
-            console.error(`Branch not found: ${targetBranchName}`);
-            console.log('Available branches:');
-            branches.forEach((b) => console.log(`  ${b.name} (${b.id})`));
-            process.exit(1);
-        }
-        await workspaceHandle.branch.switchActive(targetBranch.id);
-        const cfg = readModConfig();
-        const updatedConfig = {
-            ...cfg,
-            workspaceId: cfg?.workspaceId,
-            activeBranchId: targetBranch.id
-        };
-        writeModConfig(updatedConfig);
-        console.log(`✓ Switched to branch: ${targetBranch.name} (${targetBranch.id})`);
-    }
-    catch (error) {
-        console.error('Failed to switch branch:', error);
-        process.exit(1);
-    }
-}
-async function handleListBranches(workspaceHandle, args) {
-    try {
-        const branches = await workspaceHandle.branch.list();
-        const activeBranch = await workspaceHandle.branch.getActive();
-        if (branches.length === 0) {
-            console.log('No branches found.');
-            return;
-        }
-        console.log('Available branches:');
-        branches.forEach((branch) => {
-            const isActive = activeBranch && branch.id === activeBranch.id;
-            const indicator = isActive ? '* ' : '  ';
-            const parent = branch.parentBranchId ? ` ← ${branch.parentBranchId}` : '';
-            const branchType = detectBranchType(branch.name, false, false);
-            const typeIndicator = branchType === 'specification' ? '[spec]' : '[lite]';
-            console.log(`${indicator}${branch.name} ${typeIndicator} (${branch.id})${parent}`);
-        });
-    }
-    catch (error) {
-        const errorMessage = String(error?.message || error || '');
-        // Handle specific Automerge corruption errors
-        if (errorMessage.includes('corrupt deflate stream') || errorMessage.includes('unable to parse chunk')) {
-            console.error('❌ Document loading error during branch listing');
-            console.error('Error details:', errorMessage);
-            // Try to extract the problematic document ID from the error stack
-            const cfg = readModConfig();
-            if (cfg?.workspaceId) {
-                console.log(`\n📍 Workspace ID: ${cfg.workspaceId}`);
-                console.log('💡 The issue is likely with the branches document referenced by this workspace');
-            }
-            console.log('\n🔧 Recovery options:');
-            console.log('  1. Reset workspace: `mod recover workspace`');
-            console.log('  2. Try switching to a different workspace');
-            console.log('  3. Check for stale document references');
-            console.log('\n💡 This error indicates a stale or invalid document reference, not file corruption');
-            process.exit(1);
-        }
-        console.error('Failed to list branches:', error);
-        process.exit(1);
-    }
-}
-async function getFileChangesSummary(workspaceHandle, branch) {
-    const fileFilter = new FileFilter();
-    try {
-        const currentFiles = await workspaceHandle.file.list();
-        const filteredCurrentFiles = fileFilter.filterSourceFiles(currentFiles);
-        // Get baseline from parent branch or empty if this is root
-        let parentFiles = [];
-        if (branch.parentBranchId) {
-            // Temporarily switch to parent to get its files
-            const currentBranchId = branch.id;
-            await workspaceHandle.branch.switchActive(branch.parentBranchId);
-            const allParentFiles = await workspaceHandle.file.list();
-            parentFiles = fileFilter.filterSourceFiles(allParentFiles);
-            // Switch back
-            await workspaceHandle.branch.switchActive(currentBranchId);
-        }
-        const parentFileMap = new Map(parentFiles.map((f) => [f.name, f]));
-        const currentFileMap = new Map(filteredCurrentFiles.map((f) => [f.name, f]));
-        const newFiles = [];
-        const modifiedFiles = [];
-        const deletedFiles = [];
-        let totalLinesAdded = 0;
-        let totalLinesRemoved = 0;
-        // Process new and modified files
-        for (const currentFile of filteredCurrentFiles) {
-            const parentFile = parentFileMap.get(currentFile.name);
-            if (!parentFile) {
-                const currentContent = await getFileContent(workspaceHandle, currentFile, currentFile.name);
-                const lines = currentContent ? currentContent.split('\n').length : 0;
-                newFiles.push({
-                    name: currentFile.name,
-                    path: currentFile.path || currentFile.name,
-                    status: 'A',
-                    linesAdded: lines,
-                    linesRemoved: 0,
-                    isSourceFile: true
-                });
-                totalLinesAdded += lines;
-            }
-            else {
-                // Compare content for modifications
-                const currentContent = await getFileContent(workspaceHandle, currentFile, currentFile.name);
-                const parentContent = await getFileContent(workspaceHandle, parentFile, parentFile.name);
-                if (currentContent !== parentContent) {
-                    const diffResult = MyersDiffCalculator.calculateDiff(parentContent || '', currentContent || '');
-                    modifiedFiles.push({
-                        name: currentFile.name,
-                        path: currentFile.path || currentFile.name,
-                        status: 'M',
-                        linesAdded: diffResult.linesAdded,
-                        linesRemoved: diffResult.linesRemoved,
-                        isSourceFile: true
-                    });
-                    totalLinesAdded += diffResult.linesAdded;
-                    totalLinesRemoved += diffResult.linesRemoved;
-                }
-            }
-        }
-        // Process deleted files
-        for (const parentFile of parentFiles) {
-            if (!currentFileMap.has(parentFile.name)) {
-                const parentContent = await getFileContent(workspaceHandle, parentFile, parentFile.name);
-                const lines = parentContent ? parentContent.split('\n').length : 0;
-                deletedFiles.push({
-                    name: parentFile.name,
-                    path: parentFile.path || parentFile.name,
-                    status: 'D',
-                    linesAdded: 0,
-                    linesRemoved: lines,
-                    isSourceFile: true
-                });
-                totalLinesRemoved += lines;
-            }
-        }
-        return {
-            totalFiles: filteredCurrentFiles.length,
-            totalChanges: newFiles.length + modifiedFiles.length + deletedFiles.length,
-            totalLinesAdded,
-            totalLinesRemoved,
-            newFiles,
-            modifiedFiles,
-            deletedFiles,
-            branchCreatedAt: branch.createdAt || 'unknown'
-        };
-    }
-    catch (error) {
-        console.warn('Error getting file changes:', error);
-        return {
-            totalFiles: 0,
-            totalChanges: 0,
-            totalLinesAdded: 0,
-            totalLinesRemoved: 0,
-            newFiles: [],
-            modifiedFiles: [],
-            deletedFiles: [],
-            branchCreatedAt: branch.createdAt || 'unknown'
-        };
-    }
-}
-async function handleBranchStatus(workspaceHandle, args) {
-    try {
-        // Read active branch from CLI config first, then fall back to workspace default
-        const cfg = readModConfig();
-        let activeBranch = null;
-        if (cfg?.activeBranchId) {
-            // Find the branch by ID from CLI config
-            const branches = await workspaceHandle.branch.list();
-            activeBranch = branches.find((b) => b.id === cfg.activeBranchId);
-        }
-        // Fall back to workspace's default active branch if not found in config
-        if (!activeBranch) {
-            activeBranch = await workspaceHandle.branch.getActive();
-        }
-        if (!activeBranch) {
-            console.log('No active branch');
-            return;
-        }
-        console.log(`Active branch: ${activeBranch.name} (${activeBranch.id})`);
-        if (activeBranch.parentBranchId) {
-            console.log(`Parent branch: ${activeBranch.parentBranchId}`);
-        }
-        const changes = await getFileChangesSummary(workspaceHandle, activeBranch);
-        console.log(`\nFile changes since branch creation:`);
-        if (changes.totalChanges === 0) {
-            console.log('  No changes detected');
-        }
-        else {
-            changes.newFiles.forEach(file => {
-                console.log(`  A  +${file.linesAdded}/-${file.linesRemoved}  ${file.path}`);
-            });
-            changes.modifiedFiles.forEach(file => {
-                console.log(`  M  +${file.linesAdded}/-${file.linesRemoved}  ${file.path}`);
-            });
-            changes.deletedFiles.forEach(file => {
-                console.log(`  D  +${file.linesAdded}/-${file.linesRemoved}  ${file.path}`);
-            });
-            console.log(`\nTotal: ${changes.totalChanges} files changed, ${changes.totalLinesAdded} insertions(+), ${changes.totalLinesRemoved} deletions(-)`);
-        }
-        const files = await workspaceHandle.file.list();
-        const trackedFiles = files || [];
-        console.log(`\nTracked files: ${trackedFiles.length}`);
-        const daemon = new SyncDaemon();
-        const daemonStatus = await daemon.status();
-        console.log('\n📡 Sync Daemon Status:');
-        if (daemonStatus && daemonStatus.status === 'running') {
-            const uptimeSeconds = daemonStatus.uptime ? Math.floor(daemonStatus.uptime / 1000) : 0;
-            const minutes = Math.floor(uptimeSeconds / 60);
-            const seconds = uptimeSeconds % 60;
-            console.log(`  🟢 Running (${minutes}m ${seconds}s) - Watching ${daemonStatus.watchedFiles} files`);
-            console.log(`  📊 Last activity: ${new Date(daemonStatus.lastActivity).toLocaleString()}`);
-            if (daemonStatus.crashCount > 0) {
-                console.log(`  ⚠️  Crashes: ${daemonStatus.crashCount}`);
-            }
-        }
-        else if (daemonStatus && daemonStatus.status === 'crashed') {
-            console.log(`  💥 Crashed - ${daemonStatus.lastError || 'Unknown error'}`);
-            console.log('  💡 Run `mod sync restart` to restart daemon');
-        }
-        else {
-            console.log('  🔴 Not running');
-            console.log('  💡 Run `mod sync start` to enable real-time file tracking');
-        }
-        console.log('\n💡 File synchronization:');
-        if (daemonStatus && daemonStatus.status === 'running') {
-            console.log('  - Changes are being automatically synced to this branch in real-time');
-            console.log('  - Use `mod sync status` for detailed daemon information');
-        }
-        else {
-            console.log('  - Run `mod sync start` to enable background sync daemon');
-            console.log('  - Changes will be automatically synced to this branch');
-        }
-        console.log('  - Use `mod branch auto-track status` for legacy tracking details');
-    }
-    catch (error) {
-        console.error('Failed to get branch status:', error);
-        process.exit(1);
-    }
-}
-async function handleCoverageAnalysis(workspaceHandle, args) {
-    try {
-        const activeBranch = await workspaceHandle.branch.getActive();
-        if (!activeBranch) {
-            console.error('No active branch found');
-            process.exit(1);
-        }
-        // Get files modified in current branch
-        const changes = await getFileChangesSummary(workspaceHandle, activeBranch);
-        const modifiedFiles = [...changes.newFiles, ...changes.modifiedFiles];
-        if (modifiedFiles.length === 0) {
-            console.log('No files modified in current branch - no coverage analysis needed');
-            return;
-        }
-        console.log(`Analyzing ${modifiedFiles.length} modified files for @spec traceability...`);
-        const cacheDir = path.join(process.cwd(), '.mod', '.cache');
-        const cachePath = path.join(cacheDir, 'coverage.json');
-        // Ensure cache directory exists
-        if (!fs.existsSync(cacheDir)) {
-            fs.mkdirSync(cacheDir, { recursive: true });
-        }
-        let totalSpecComments = 0;
-        let filesWithSpecs = 0;
-        const specReferences = [];
-        const invalidRefs = [];
-        const fileDetails = [];
-        for (const fileObj of modifiedFiles) {
-            try {
-                const fileName = fileObj.name;
-                const filePath = fileObj.path || fileName;
-                // Skip non-code files
-                if (!isCodeFile(fileName))
-                    continue;
-                const content = await getFileContent(workspaceHandle, fileObj, filePath);
-                if (!content) {
-                    fileDetails.push({
-                        path: filePath,
-                        specComments: 0,
-                        invalidRefs: 0,
-                        functions: 0,
-                        classes: 0,
-                        untraced: 0,
-                        hasCode: false
-                    });
-                    continue;
-                }
-                const analysis = analyzeFileForSpecComments(content, filePath);
-                const codeStructure = analyzeCodeStructure(content);
-                const fileInvalidRefs = analysis.invalidRefs.length;
-                const fileSpecComments = analysis.specComments.length;
-                if (fileSpecComments > 0) {
-                    filesWithSpecs++;
-                    totalSpecComments += fileSpecComments;
-                    specReferences.push(...analysis.specComments.map(spec => spec.requirementId));
-                    invalidRefs.push(...analysis.invalidRefs);
-                }
-                fileDetails.push({
-                    path: filePath,
-                    specComments: fileSpecComments,
-                    invalidRefs: fileInvalidRefs,
-                    functions: codeStructure.functions,
-                    classes: codeStructure.classes,
-                    untraced: Math.max(0, (codeStructure.functions + codeStructure.classes) - fileSpecComments),
-                    hasCode: analysis.hasCode
-                });
-            }
-            catch (error) {
-                console.warn(`Could not analyze file: ${fileObj.name}`);
-                fileDetails.push({
-                    path: fileObj.name,
-                    specComments: 0,
-                    invalidRefs: 0,
-                    functions: 0,
-                    classes: 0,
-                    untraced: 0,
-                    hasCode: false
-                });
-            }
-        }
-        // Only count code files among the modified files
-        const totalCodeFiles = fileDetails.filter(f => f.hasCode).length;
-        const untracedFiles = fileDetails.filter(f => f.hasCode && f.specComments === 0);
-        const coveragePercentage = totalCodeFiles > 0 ?
-            Math.round((filesWithSpecs / totalCodeFiles) * 100) : 0;
-        console.log(`\nCoverage Analysis Results (Branch: ${activeBranch.name || activeBranch.branchId}):`);
-        console.log(`  Modified code files analyzed: ${totalCodeFiles}`);
-        console.log(`  Files with @spec comments: ${filesWithSpecs}`);
-        console.log(`  Total @spec comments found: ${totalSpecComments}`);
-        console.log(`  Coverage percentage: ${coveragePercentage}%`);
-        console.log(`\nPer-file traceability analysis:`);
-        fileDetails
-            .filter(f => f.hasCode)
-            .sort((a, b) => b.specComments - a.specComments)
-            .forEach(file => {
-            const status = file.specComments > 0 ? '✓' : '✗';
-            const tracedIndicator = file.untraced > 0 ? ` (${file.untraced} untraced)` : '';
-            const invalidIndicator = file.invalidRefs > 0 ? ` ⚠️${file.invalidRefs}` : '';
-            console.log(`  ${status} ${file.path} - ${file.specComments} traces, ${file.functions}f/${file.classes}c${tracedIndicator}${invalidIndicator}`);
-        });
-        if (invalidRefs.length > 0) {
-            console.log(`\nInvalid @spec references found:`);
-            invalidRefs.forEach(ref => console.log(`  ⚠️  ${ref}`));
-        }
-        if (untracedFiles.length > 0) {
-            console.log(`\nFiles lacking @spec traceability (${untracedFiles.length}):`);
-            untracedFiles.forEach(file => {
-                console.log(`  - ${file.path} (${file.functions} functions, ${file.classes} classes)`);
-            });
-        }
-        const analyzedFiles = {};
-        fileDetails.forEach(file => {
-            analyzedFiles[file.path] = {
-                specReferences: [], // Would need detailed parsing for individual refs
-                lastModified: new Date(),
-                hash: '', // Would need content hash
-                linesAdded: 0, // From file change summary
-                linesRemoved: 0, // From file change summary  
-                isSourceFile: file.hasCode
-            };
-        });
-        const cacheData = {
-            specificationPath: readModConfig()?.lastSpecificationPath || '',
-            lastAnalysis: new Date(),
-            analyzedFiles,
-            coverageResults: {
-                totalRequirements: totalSpecComments,
-                implementedRequirements: [...new Set(specReferences)],
-                unimplementedRequirements: untracedFiles.map(f => f.path),
-                coveragePercentage
-            },
-            unspecifiedFiles: untracedFiles.map(f => f.path)
-        };
-        fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2));
-    }
-    catch (error) {
-        console.error('Failed to analyze coverage:', error);
-        process.exit(1);
-    }
-}
-async function scanWorkingDirectoryForCodeFiles() {
-    const files = [];
-    const cwd = process.cwd();
-    try {
-        const scanDir = (dir) => {
-            const items = fs.readdirSync(dir);
-            for (const item of items) {
-                const fullPath = path.join(dir, item);
-                const relativePath = path.relative(cwd, fullPath);
-                // Skip node_modules, .git, and other common excludes
-                if (item.startsWith('.') || item === 'node_modules')
-                    continue;
-                const stat = fs.statSync(fullPath);
-                if (stat.isDirectory()) {
-                    scanDir(fullPath);
-                }
-                else if (isCodeFile(item)) {
-                    files.push({
-                        name: item,
-                        path: relativePath,
-                        fullPath
-                    });
-                }
-            }
-        };
-        scanDir(cwd);
-    }
-    catch (error) {
-        console.warn('Error scanning working directory:', error);
-    }
-    return files;
-}
-function isCodeFile(fileName) {
-    const fileFilter = new FileFilter();
-    return fileFilter.isSourceFile(fileName);
-}
-async function getFileContent(workspaceHandle, file, filePath) {
-    try {
-        // Try to get from workspace first
-        if (file.id) {
-            const docHandle = await workspaceHandle.file.get(file.id);
-            if (docHandle?.head?.content) {
-                return docHandle.head.content;
-            }
-        }
-        // Fallback to filesystem
-        if (file.fullPath && fs.existsSync(file.fullPath)) {
-            return fs.readFileSync(file.fullPath, 'utf8');
-        }
-        // Try relative path from cwd
-        const fullPath = path.resolve(process.cwd(), filePath);
-        if (fs.existsSync(fullPath)) {
-            return fs.readFileSync(fullPath, 'utf8');
-        }
-        // Try searching for the file in common locations
-        const commonPaths = [
-            path.resolve(process.cwd(), `packages/mod-cli/source/commands/${file.name}`),
-            path.resolve(process.cwd(), `packages/mod-cli/source/${file.name}`),
-            path.resolve(process.cwd(), `packages/mod-cli/${file.name}`),
-            path.resolve(process.cwd(), `src/${file.name}`),
-            path.resolve(process.cwd(), `source/${file.name}`)
-        ];
-        for (const tryPath of commonPaths) {
-            if (fs.existsSync(tryPath)) {
-                return fs.readFileSync(tryPath, 'utf8');
-            }
-        }
-        return null;
-    }
-    catch (error) {
-        return null;
-    }
-}
-function analyzeFileForSpecComments(content, filePath) {
-    const lines = content.split('\n');
-    const specComments = [];
-    const invalidRefs = [];
-    let hasCode = false;
-    const specCommentRegex = /\/\/\s*@spec\s+([^\s]+)\s+(.+)/i;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Check if line has actual code (not just comments/whitespace)
-        if (line && !line.startsWith('//') && !line.startsWith('/*') && !line.startsWith('*')) {
-            hasCode = true;
-        }
-        const match = line.match(specCommentRegex);
-        if (match) {
-            const [, requirementId, description] = match;
-            const isValid = validateSpecReference(requirementId);
-            if (isValid) {
-                specComments.push({
-                    requirementId,
-                    lineNumber: i + 1,
-                    description: description.trim(),
-                    valid: true
-                });
-            }
-            else {
-                invalidRefs.push(`${filePath}:${i + 1} - Invalid ref: ${requirementId}`);
-                specComments.push({
-                    requirementId,
-                    lineNumber: i + 1,
-                    description: description.trim(),
-                    valid: false
-                });
-            }
-        }
-    }
-    return {
-        specComments,
-        invalidRefs,
-        hasCode
-    };
-}
-function analyzeCodeStructure(content) {
-    const lines = content.split('\n');
-    let functions = 0;
-    let classes = 0;
-    for (const line of lines) {
-        const trimmedLine = line.trim();
-        // Skip comments
-        if (trimmedLine.startsWith('//') || trimmedLine.startsWith('/*') || trimmedLine.startsWith('*')) {
-            continue;
-        }
-        // Count function declarations (various patterns)
-        if (/^(export\s+)?(async\s+)?function\s+\w+/.test(trimmedLine) ||
-            /^\w+\s*:\s*(async\s+)?\([^)]*\)\s*=>/.test(trimmedLine) ||
-            /^(async\s+)?\w+\s*\([^)]*\)\s*\{/.test(trimmedLine) ||
-            /^\w+\s*=\s*(async\s+)?\([^)]*\)\s*=>/.test(trimmedLine)) {
-            functions++;
-        }
-        // Count class declarations
-        if (/^(export\s+)?(abstract\s+)?class\s+\w+/.test(trimmedLine)) {
-            classes++;
-        }
-        // Count interface declarations (treat as classes for traceability purposes)
-        if (/^(export\s+)?interface\s+\w+/.test(trimmedLine)) {
-            classes++;
-        }
-    }
-    return { functions, classes };
-}
-function validateSpecReference(requirementId) {
-    // Basic validation - should be in format: spec-name/REQ-CATEGORY-NUMBER or spec-name.spec.md/REQ-CATEGORY-NUMBER
-    const specRefPattern = /^[a-zA-Z0-9\-_]+(\.spec\.md)?\/REQ-[A-Z]+-\d+(\.\d+)*$/;
-    return specRefPattern.test(requirementId);
-}
-async function handleAutoTrack(workspaceHandle, args, repo) {
-    const [action] = args;
-    if (!action || !['start', 'stop', 'status'].includes(action)) {
-        console.error('Usage: mod branch auto-track <start|stop|status>');
-        console.error('  start  - Enable automatic file tracking');
-        console.error('  stop   - Disable automatic file tracking');
-        console.error('  status - Show tracking status');
-        process.exit(1);
-    }
-    try {
-        const cfg = readModConfig();
-        if (!cfg?.workspaceId) {
-            throw new Error('No workspace configured');
-        }
-        const tracker = new AutomaticFileTracker(repo);
-        switch (action) {
-            case 'start':
-                console.log('🚀 Starting automatic file tracking...');
-                await tracker.enableAutoTracking({
-                    workspaceId: cfg.workspaceId,
-                    workspaceHandle: workspaceHandle,
-                    watchDirectory: process.cwd(),
-                    debounceMs: 500,
-                    verbose: true
-                });
-                console.log('✅ Automatic file tracking is now active!');
-                console.log('💡 Edit any file in this directory and it will be automatically tracked.');
-                console.log('💡 Run "mod branch status" to see changes.');
-                console.log('💡 Press Ctrl+C to stop tracking and exit.');
-                // Keep the process running to maintain file watching
-                process.on('SIGINT', async () => {
-                    console.log('\n🛑 Stopping automatic file tracking...');
-                    await tracker.disableAutoTracking();
-                    process.exit(0);
-                });
-                // Don't exit the process - keep watching
-                await new Promise(() => { }); // Wait indefinitely
-                break;
-            case 'stop':
-                await tracker.disableAutoTracking();
-                console.log('🛑 Automatic file tracking stopped');
-                break;
-            case 'status':
-                const status = tracker.getTrackingStatus();
-                console.log(`Tracking status: ${status.isTracking ? '🟢 Active' : '🔴 Inactive'}`);
-                console.log(`Tracked files: ${status.trackedFiles}`);
-                break;
-        }
-    }
-    catch (error) {
-        console.error('Failed to manage auto-tracking:', error);
-        process.exit(1);
-    }
-}
-async function openExistingWorkspace(modWorkspace, workspaceId) {
-    // This function provides a proper way to open existing workspaces until openWorkspace is added to ModWorkspace
-    // We temporarily access the internal method to create a handle, but this maintains the interface boundary
-    const repo = modWorkspace.repo;
-    const wsHandle = await repo.find(workspaceId);
-    const workspace = await wsHandle.doc();
-    if (!workspace || !workspace.branchesDocId) {
-        throw new Error('Invalid workspace: missing branchesDocId');
-    }
-    const handle = modWorkspace.createWorkspaceHandle(workspaceId, workspace.title || 'Workspace', workspace.branchesDocId);
-    const cfg = readModConfig();
-    if (cfg?.activeBranchId) {
-        try {
-            await handle.branch.switchActive(cfg.activeBranchId);
-        }
-        catch (error) {
-            console.warn(`Could not restore saved active branch ${cfg.activeBranchId}:`, error);
-        }
-    }
-    return handle;
-}
-export function generateBranchNameForSpec(specTitle, packageName) {
-    const baseName = generateBranchName(specTitle);
-    if (packageName) {
-        const packageSlug = generateBranchName(packageName);
-        return `feature-${packageSlug}-${baseName}`;
-    }
-    return `feature-${baseName}`;
-}
-export async function createBranchForSpec(repo, specTitle) {
-    const branchName = generateBranchNameForSpec(specTitle);
-    // Use existing branch creation logic
-    await branchCommand(['create', branchName, '--spec', `.mod/specs/${specTitle}.spec.md`], repo);
-    return { branchName, branchId: branchName }; // Simplified return
-}
-export function getActiveBranchSpec() {
-    const cfg = readModConfig();
-    return cfg?.lastSpecificationPath || null;
-}
-export async function switchToSpecBranch(repo, specFileName) {
-    const baseSpecName = specFileName.replace(/\.spec\.md$/, '');
-    // Extract package name from path like "mod-cli/branching-cli.spec.md" 
-    let packageName;
-    let specTitle = baseSpecName;
-    if (baseSpecName.includes('/')) {
-        const parts = baseSpecName.split('/');
-        packageName = parts[0];
-        specTitle = parts[1] || parts[0];
-    }
-    const expectedBranchName = generateBranchNameForSpec(specTitle, packageName);
-    try {
-        // Use existing branch switch logic
-        await branchCommand(['switch', expectedBranchName], repo);
-        return { success: true, branchName: expectedBranchName };
-    }
-    catch (error) {
-        // Branch doesn't exist, create it
-        try {
-            await branchCommand(['create', expectedBranchName, '--spec', `.mod/specs/${specFileName}`], repo);
-            return { success: true, branchName: expectedBranchName };
-        }
-        catch (createError) {
-            console.error(`Failed to create/switch to branch for ${specFileName}:`, createError);
-            return { success: false, branchName: expectedBranchName };
-        }
-    }
-}
-async function handleTreeView(workspaceHandle, args) {
-    try {
-        const options = parseTreeCommandOptions(args);
-        const activeBranch = await workspaceHandle.branch.getActive();
-        if (!activeBranch) {
-            console.error('No active branch. Run \'mod branch list\' to see available branches');
-            process.exit(1);
-        }
-        const files = await workspaceHandle.file.list();
-        const filteredFiles = filterSystemFiles(files);
-        if (filteredFiles.length === 0) {
-            console.log(`Branch '${activeBranch.name}': 0 files`);
-            console.log('(empty branch)');
-            return;
-        }
-        const changesSummary = await getFileChangesSummary(workspaceHandle, activeBranch);
-        let displayFiles = filteredFiles;
-        if (options.changesOnly) {
-            const changedFilePaths = new Set([
-                ...changesSummary.newFiles.map(f => f.path),
-                ...changesSummary.modifiedFiles.map(f => f.path),
-                ...changesSummary.deletedFiles.map(f => f.path)
-            ]);
-            displayFiles = filteredFiles.filter(file => changedFilePaths.has(file.path || file.name));
-            if (displayFiles.length === 0) {
-                console.log(`Branch '${activeBranch.name}': no changes to display`);
-                return;
-            }
-        }
-        const rootNode = await buildTreeStructure(displayFiles, workspaceHandle, changesSummary, options);
-        const context = await createDisplayContext(activeBranch, workspaceHandle, rootNode, changesSummary);
-        displayTreeHeader(context, options);
-        displayTreeNodes(rootNode.children, '', options, context);
-    }
-    catch (error) {
-        if (error.message?.includes('Branch not found')) {
-            console.error('Branch not found. Run \'mod branch list\' to see available branches');
-        }
-        else if (error.message?.includes('timeout')) {
-            console.error('Tree generation timed out. Try using --depth or --filter to limit scope');
-        }
-        else {
-            console.error('Failed to generate tree view:', error.message);
-        }
-        process.exit(1);
-    }
-}
-function parseTreeCommandOptions(args) {
-    const options = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        switch (arg) {
-            case '--depth':
-                if (i + 1 < args.length) {
-                    const depthValue = parseInt(args[i + 1]);
-                    if (!isNaN(depthValue) && depthValue > 0) {
-                        options.depth = depthValue;
-                        i++; // Skip next argument
-                    }
-                    else {
-                        console.error('Invalid depth value. Must be a positive number.');
-                        process.exit(1);
-                    }
-                }
-                break;
-            case '--dirs-only':
-                options.dirsOnly = true;
-                break;
-            case '--filter':
-                if (i + 1 < args.length) {
-                    options.filter = args[i + 1];
-                    i++; // Skip next argument
-                }
-                break;
-            case '--size':
-                options.showSize = true;
-                break;
-            case '--changes-only':
-                options.changesOnly = true;
-                break;
-            case '--stat':
-                options.showStats = true;
-                break;
-            case '--no-color':
-                options.noColor = true;
-                break;
-            case '--help':
-                displayTreeHelp();
-                process.exit(0);
-                break;
-            default:
-                if (arg.startsWith('--')) {
-                    console.error(`Unknown option: ${arg}`);
-                    console.error('Use --help for usage information');
-                    process.exit(1);
-                }
-        }
-    }
-    if (options.dirsOnly && options.showStats) {
-        console.error('Cannot use --dirs-only with --stat (directories have no line counts)');
-        process.exit(1);
-    }
-    if (options.filter) {
-        try {
-            // Simple validation - ensure no invalid regex characters
-            new RegExp(options.filter.replace(/\*/g, '.*').replace(/\?/g, '.'));
-        }
-        catch {
-            console.error(`Invalid filter pattern: ${options.filter}`);
-            console.error('Use standard glob patterns like "*.ts" or "src/**"');
-            process.exit(1);
-        }
-    }
-    return options;
-}
-function displayTreeHelp() {
-    console.log('Usage: mod branch tree [options]');
-    console.log('');
-    console.log('Display directory tree of current branch');
-    console.log('');
-    console.log('Options:');
-    console.log('  --depth <N>        Limit tree depth to N levels');
-    console.log('  --dirs-only        Show only directory structure, no files');
-    console.log('  --filter <pattern> Show only paths matching glob pattern');
-    console.log('  --size             Include file sizes in human-readable format');
-    console.log('  --changes-only     Show only files with changes in current branch');
-    console.log('  --stat             Include line change counts (+N/-M) for modified files');
-    console.log('  --filesystem       Show filesystem files instead of workspace files');
-    console.log('  --no-color         Disable color output');
-    console.log('  --help             Show this help message');
-    console.log('');
-    console.log('Examples:');
-    console.log('  mod branch tree --depth 3');
-    console.log('  mod branch tree --filter "*.ts"');
-    console.log('  mod branch tree --changes-only --stat');
-    console.log('  mod branch tree --filesystem  # Show all files in current directory');
-}
-function filterSystemFiles(files) {
-    return files.filter(file => {
-        const fileName = file.name || '';
-        // Skip automerge internal files
-        if (fileName.startsWith('automerge-') || fileName.includes('.automerge')) {
-            return false;
-        }
-        // Skip system files  
-        if (fileName.startsWith('.') && fileName !== '.gitignore' && fileName !== '.modignore') {
-            return false;
-        }
-        // For workspace files, use simpler extension-based filtering since we don't have filesystem context
-        const ext = path.extname(fileName).toLowerCase();
-        const allowedExtensions = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.py', '.go', '.rs', '.java', '.cpp', '.c', '.h', '.hpp', '.md', '.yaml', '.yml', '.json', '.txt'];
-        return allowedExtensions.includes(ext) || fileName === '.gitignore' || fileName === '.modignore';
-    });
-}
-async function buildTreeStructure(files, workspaceHandle, changesSummary, options) {
-    // Create root node
-    const root = {
-        name: '',
-        path: '',
-        type: 'directory',
-        children: [],
-        metadata: {}
-    };
-    let filteredFiles = files;
-    if (options.filter) {
-        const pattern = options.filter.replace(/\*/g, '.*').replace(/\?/g, '.');
-        const regex = new RegExp(pattern, 'i');
-        filteredFiles = files.filter(file => regex.test(file.path || file.name));
-    }
-    // Create change status lookup for efficient access
-    const changeStatusMap = new Map();
-    [...changesSummary.newFiles, ...changesSummary.modifiedFiles, ...changesSummary.deletedFiles].forEach(change => {
-        changeStatusMap.set(change.path, {
-            status: change.status,
-            stats: { additions: change.linesAdded, deletions: change.linesRemoved }
-        });
-    });
-    // Get folder information to reconstruct paths for hierarchical files
-    const folderMap = new Map();
-    try {
-        const folders = await workspaceHandle.folder.list();
-        folders.forEach((folder) => {
-            if (folder.folderId) {
-                // Map logical folder ID to folder data
-                folderMap.set(folder.folderId, folder);
-            }
-        });
-    }
-    catch (error) {
-        // Silently continue if folder list fails - fallback will handle path reconstruction
-    }
-    for (const file of filteredFiles) {
-        // For hierarchical files, reconstruct path from folder information
-        let filePath = file.path || file.name;
-        if (file.folderId && !file.path) {
-            // Look up folder info to reconstruct path
-            const folder = folderMap.get(file.folderId);
-            if (folder && folder.folderPath) {
-                filePath = folder.folderPath + '/' + file.name;
-            }
-            else {
-                // Fallback: parse folder ID to extract path
-                const folderIdMatch = file.folderId.match(/folder-(.+)-\d+$/);
-                if (folderIdMatch) {
-                    const folderPath = folderIdMatch[1].replace(/-/g, '/');
-                    filePath = folderPath + '/' + file.name;
-                }
-            }
-        }
-        const pathParts = filePath.split('/').filter(part => part.length > 0);
-        let currentNode = root;
-        // Create directory structure
-        for (let i = 0; i < pathParts.length - 1; i++) {
-            const dirName = pathParts[i];
-            const dirPath = pathParts.slice(0, i + 1).join('/');
-            let dirNode = currentNode.children.find(child => child.name === dirName && child.type === 'directory');
-            if (!dirNode) {
-                dirNode = {
-                    name: dirName,
-                    path: dirPath,
-                    type: 'directory',
-                    children: [],
-                    metadata: {}
-                };
-                currentNode.children.push(dirNode);
-            }
-            currentNode = dirNode;
-        }
-        if (!options.dirsOnly) {
-            // Add file node
-            const fileName = pathParts[pathParts.length - 1];
-            const changeInfo = changeStatusMap.get(filePath);
-            const fileNode = {
-                name: fileName,
-                path: filePath,
-                type: 'file',
-                children: [],
-                metadata: {
-                    fileId: file.id,
-                    changeStatus: changeInfo?.status,
-                    changeStats: changeInfo?.stats,
-                    mimeType: getMimeType(fileName)
-                }
-            };
-            if (options.showSize) {
-                fileNode.metadata.size = await getFileSize(workspaceHandle, file);
-            }
-            currentNode.children.push(fileNode);
-        }
-    }
-    sortTreeNodes(root);
-    return root;
-}
-function sortTreeNodes(node) {
-    node.children.sort((a, b) => {
-        // Files before directories at root level
-        if (a.type !== b.type) {
-            if (node.path === '') { // Root level
-                return a.type === 'file' ? -1 : 1;
-            }
-            else { // Nested levels - directories first
-                return a.type === 'directory' ? -1 : 1;
-            }
-        }
-        // Alphabetical within same type
-        return a.name.localeCompare(b.name);
-    });
-    // Recursively sort children
-    node.children.forEach(child => {
-        if (child.type === 'directory') {
-            sortTreeNodes(child);
-        }
-    });
-}
-async function createDisplayContext(branch, workspaceHandle, rootNode, changesSummary) {
-    // Count files and directories recursively
-    const counts = countFilesAndDirectories(rootNode);
-    return {
-        branchName: branch.name,
-        branchId: branch.id,
-        totalFiles: counts.files,
-        totalDirectories: counts.directories,
-        changeSummary: {
-            modified: changesSummary.modifiedFiles.length,
-            added: changesSummary.newFiles.length,
-            deleted: changesSummary.deletedFiles.length
-        },
-        workspaceName: 'Workspace', // Could be enhanced to get actual workspace name
-        specificationPath: detectBranchType(branch.name, false, false) === 'specification' ?
-            `${branch.name}.spec.md` : undefined
-    };
-}
-// Helper function to count files and directories
-function countFilesAndDirectories(node) {
-    let files = 0;
-    let directories = 0;
-    for (const child of node.children) {
-        if (child.type === 'file') {
-            files++;
-        }
-        else if (child.type === 'directory') {
-            directories++;
-            const childCounts = countFilesAndDirectories(child);
-            files += childCounts.files;
-            directories += childCounts.directories;
-        }
-    }
-    return { files, directories };
-}
-function displayTreeHeader(context, options) {
-    console.log(`Branch '${context.branchName}': ${context.totalFiles} files`);
-    if (context.specificationPath) {
-        console.log(`Specification: ${context.specificationPath}`);
-    }
-    if (context.changeSummary.added > 0 || context.changeSummary.modified > 0 || context.changeSummary.deleted > 0) {
-        const changes = [];
-        if (context.changeSummary.added > 0)
-            changes.push(`${context.changeSummary.added} added`);
-        if (context.changeSummary.modified > 0)
-            changes.push(`${context.changeSummary.modified} modified`);
-        if (context.changeSummary.deleted > 0)
-            changes.push(`${context.changeSummary.deleted} deleted`);
-        console.log(`Changes: ${changes.join(', ')}`);
-    }
-    console.log('');
-}
-function displayTreeNodes(nodes, prefix, options, context, currentDepth = 0) {
-    if (options.depth && currentDepth >= options.depth) {
-        return;
-    }
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        const isLast = i === nodes.length - 1;
-        const connector = isLast ? '└── ' : '├── ';
-        const newPrefix = prefix + (isLast ? '    ' : '│   ');
-        displaySingleNode(node, prefix + connector, options, context);
-        if (node.type === 'directory') {
-            if (node.children.length === 0) {
-                console.log(prefix + (isLast ? '    ' : '│   ') + '[empty]');
-            }
-            else {
-                displayTreeNodes(node.children, newPrefix, options, context, currentDepth + 1);
-            }
-        }
-    }
-}
-function displaySingleNode(node, prefix, options, context) {
-    let output = prefix;
-    if (node.metadata.changeStatus) {
-        const colorCode = !options.noColor ? getStatusColor(node.metadata.changeStatus) : '';
-        const resetCode = !options.noColor ? '\x1b[0m' : '';
-        output += `${colorCode}${node.metadata.changeStatus}${resetCode} `;
-    }
-    const nameColor = !options.noColor ? getFileTypeColor(node.metadata.mimeType) : '';
-    const resetColor = !options.noColor ? '\x1b[0m' : '';
-    const displayName = node.type === 'directory' ? `${node.name}/` : node.name;
-    output += `${nameColor}${displayName}${resetColor}`;
-    if (options.showSize && node.metadata.size && node.type === 'file') {
-        output += ` (${formatFileSize(node.metadata.size)})`;
-    }
-    if (options.showStats && node.metadata.changeStats && node.type === 'file') {
-        const stats = node.metadata.changeStats;
-        output += ` (+${stats.additions}/-${stats.deletions})`;
-    }
-    console.log(output);
-}
-function getStatusColor(status) {
-    switch (status) {
-        case 'A': return '\x1b[32m'; // Green for added
-        case 'M': return '\x1b[33m'; // Yellow for modified
-        case 'D': return '\x1b[31m'; // Red for deleted
-        default: return '';
-    }
-}
-function getFileTypeColor(mimeType) {
-    if (!mimeType)
-        return '';
-    if (mimeType.includes('code') || mimeType.includes('typescript') || mimeType.includes('javascript')) {
-        return '\x1b[34m'; // Blue for code
-    }
-    else if (mimeType.includes('text') || mimeType.includes('markdown')) {
-        return '\x1b[32m'; // Green for docs
-    }
-    else if (mimeType.includes('json') || mimeType.includes('yaml') || mimeType.includes('config')) {
-        return '\x1b[33m'; // Yellow for config
-    }
-    return '';
-}
-function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${Math.round(bytes / 1024)}KB`;
-    return `${Math.round(bytes / (1024 * 1024))}MB`;
-}
-// Simple MIME type detection for file type coloring
-function getMimeType(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    switch (ext) {
-        case '.ts':
-        case '.tsx': return 'code/typescript';
-        case '.js':
-        case '.jsx': return 'code/javascript';
-        case '.py': return 'code/python';
-        case '.go': return 'code/go';
-        case '.rs': return 'code/rust';
-        case '.java': return 'code/java';
-        case '.md': return 'text/markdown';
-        case '.json': return 'config/json';
-        case '.yaml':
-        case '.yml': return 'config/yaml';
-        case '.txt': return 'text/plain';
-        default: return 'application/octet-stream';
-    }
-}
-// Get file size from workspace handle or filesystem
-async function getFileSize(workspaceHandle, file) {
-    try {
-        if (file.id) {
-            const docHandle = await workspaceHandle.file.get(file.id);
-            if (docHandle?.head?.content) {
-                return Buffer.byteLength(docHandle.head.content, 'utf8');
-            }
-        }
-        // Fallback to filesystem if available
-        const filePath = file.fullPath || file.path;
-        if (filePath && fs.existsSync(filePath)) {
-            const stats = fs.statSync(filePath);
-            return stats.size;
-        }
-    }
-    catch (error) {
-        // Ignore errors, return 0
-    }
-    return 0;
-}