@mod-computer/cli 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,329 @@
+// @spec status-command.spec.md/REQ-INT-1.1 Import SpecificationParserService from mod-core
+// @spec status-command.spec.md/REQ-INT-1.3 Reuse RequirementCategory enum and interfaces from mod-core types
+import { SpecificationParserService, RequirementCategory } from '@mod/mod-core';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { log } from '../services/logger.js';
+// @spec status-command.spec.md/REQ-INT-2.2 Standard command signature
+// @spec status-command.spec.md/REQ-INFRA-2.1 Follow existing CLI command patterns from mod-cli package
+export async function statusCommand(args) {
+    try {
+        // @spec status-command.spec.md/REQ-BUS-2.1 Parse spec file argument
+        if (args.length === 0) {
+            console.error('Error: Specification file required');
+            console.error('Usage: mod status <spec-file>');
+            process.exit(1);
+        }
+        let specName = args[0];
+        // @spec status-command.spec.md/REQ-DATA-1.1 Auto-append .spec.md extension
+        if (!specName.endsWith('.spec.md')) {
+            specName += '.spec.md';
+        }
+        const workspaceRoot = process.cwd();
+        const analysis = await analyzeSpecification(workspaceRoot, specName);
+        // @spec status-command.spec.md/REQ-UX-1.1 TypeScript compiler-style output
+        printTscStyleOutput(analysis);
+        // Exit successfully
+        process.exit(0);
+    }
+    catch (error) {
+        // @spec status-command.spec.md/REQ-BUS-2.1 Handle different error types with appropriate exit codes
+        if (error instanceof Error) {
+            // @spec status-command.spec.md/REQ-UX-2.1 Clear error messages for file not found
+            if (error.message.includes('not found')) {
+                console.error(`Error: Specification file "${args[0]}" not found`);
+                process.exit(1);
+                // @spec status-command.spec.md/REQ-UX-2.1 Clear error messages for parse errors  
+            }
+            else if (error.message.includes('parse')) {
+                console.error(`Error: Failed to parse specification: ${error.message}`);
+                process.exit(2);
+                // @spec status-command.spec.md/REQ-UX-2.1 Clear error messages for scan failures
+            }
+            else if (error.message.includes('scan')) {
+                console.error(`Error: Failed to scan workspace: ${error.message}`);
+                process.exit(3);
+            }
+        }
+        console.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(3);
+    }
+}
+// @spec status-command.spec.md/REQ-DATA-1.1 Use SpecificationParserService for parsing and scanning
+async function analyzeSpecification(workspaceRoot, specName) {
+    // @spec status-command.spec.md/REQ-INT-1.1 Initialize SpecificationParserService
+    // @spec status-command.spec.md/REQ-BUS-2.2 Pure offline operation using local files only, no network or repo connections
+    const parser = new SpecificationParserService({
+        workspaceRoot,
+        specsDirectory: '.mod/specs',
+        cacheEnabled: false
+    });
+    // @spec status-command.spec.md/REQ-DATA-2.1 Scan workspace for @spec traces
+    // @spec status-command.spec.md/REQ-INFRA-2.2 Use existing logger service for debug output when MOD_CLI_DEBUG is set
+    log('[Status] Scanning workspace for @spec traces');
+    const startTime = Date.now();
+    const traceMap = await parser.scanWorkspaceForTraces();
+    const scanTime = Date.now() - startTime;
+    // @spec status-command.spec.md/REQ-INFRA-1.1 Process up to 1000 requirements in under 5 seconds
+    log(`[Status] Scan completed in ${scanTime}ms, found ${traceMap.size} requirement IDs`);
+    // @spec status-command.spec.md/REQ-DATA-1.1 Find and parse specification file
+    const specFilePath = await findSpecificationFile(workspaceRoot, specName);
+    const content = await fs.readFile(specFilePath, 'utf-8');
+    const parsed = await parser.parseSpecification(content, specFilePath);
+    // Calculate frontmatter offset for line number adjustment
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    const frontmatterOffset = frontmatterMatch ? frontmatterMatch[0].split('\n').length - 1 : 0;
+    // @spec status-command.spec.md/REQ-DATA-1.2 Extract nested requirements from bullet points
+    const allRequirements = extractNestedRequirements(content, parsed.requirements, frontmatterOffset);
+    // @spec status-command.spec.md/REQ-DATA-2.3 Filter traces by spec name
+    const filteredTraces = filterTracesBySpec(traceMap, specName);
+    // @spec status-command.spec.md/REQ-BUS-1.1 Calculate status for each requirement
+    const requirements = allRequirements.map(req => {
+        const traces = filteredTraces.get(req.id) || [];
+        const status = getRequirementStatus(traces.length);
+        return {
+            requirementId: req.id,
+            category: req.category,
+            title: req.title,
+            status,
+            traceCount: traces.length,
+            traces: traces.map(trace => ({
+                file: path.relative(workspaceRoot, trace.filePath),
+                line: trace.lineRange.start,
+                description: trace.description
+            })),
+            hierarchyLevel: calculateHierarchyLevel(req.id),
+            lineRange: req.lineRange
+        };
+    });
+    // @spec status-command.spec.md/REQ-BUS-1.2 Hierarchical aggregation: parent status reflects worst child status
+    applyHierarchicalAggregation(requirements);
+    // @spec status-command.spec.md/REQ-BUS-1.2 Calculate summary counts
+    const summary = {
+        traced: requirements.filter(r => r.status === 'traced').length,
+        todo: requirements.filter(r => r.status === 'todo').length,
+        totalTraces: requirements.reduce((sum, r) => sum + r.traceCount, 0)
+    };
+    return {
+        specFile: path.relative(workspaceRoot, specFilePath),
+        title: parsed.metadata.title,
+        requirements,
+        summary
+    };
+}
+// @spec status-command.spec.md/REQ-DATA-1.2 Extract nested requirements from bullet points
+function extractNestedRequirements(content, topLevelRequirements, frontmatterOffset) {
+    // Adjust line numbers for top-level requirements to account for frontmatter
+    const adjustedTopLevel = topLevelRequirements.map(req => ({
+        ...req,
+        lineRange: req.lineRange ? {
+            start: req.lineRange.start + frontmatterOffset,
+            end: req.lineRange.end + frontmatterOffset
+        } : undefined
+    }));
+    const allRequirements = [...adjustedTopLevel];
+    // @spec status-command.spec.md/REQ-BUS-1.3 Support all @spec comment patterns from spec-parser-utils.ts
+    // Regular expression to find nested requirements in bullet points
+    // Matches: - **REQ-CAT-N.N**: Description, - **REQ-CAT-N.N.N**: Description, etc.
+    const nestedReqRegex = /^\s*-\s*\*\*(?<id>REQ-[A-Z]+-\d+(?:\.\d+)*)\*\*:\s*(?<description>.*)/gm;
+    let match;
+    while ((match = nestedReqRegex.exec(content)) !== null) {
+        const groups = match.groups;
+        if (!groups)
+            continue;
+        const { id, description } = groups;
+        // Determine category from requirement ID
+        const categoryMatch = id.match(/REQ-([A-Z]+)/);
+        if (!categoryMatch)
+            continue;
+        const categoryStr = categoryMatch[1];
+        // @spec status-command.spec.md/REQ-DATA-1.3 Extract requirement categories UX, BUS, DATA, INT, INFRA, QUAL
+        const category = Object.values(RequirementCategory).find(cat => cat === categoryStr);
+        if (!category)
+            continue;
+        // Skip if it's already a top-level requirement (parsed by SpecificationParserService)
+        if (topLevelRequirements.some(req => req.id === id))
+            continue;
+        // @spec status-command.spec.md/REQ-DATA-1.2.1 Extract nested requirements from bullet points using regex pattern matching
+        // Add nested requirement with line number from match (1-based indexing)
+        const lineNumber = content.substring(0, match.index).split('\n').length;
+        allRequirements.push({
+            id,
+            category,
+            title: description.trim(),
+            description: description.trim(),
+            children: [],
+            lineRange: { start: lineNumber, end: lineNumber },
+            parent: determineParentRequirement(id)
+        });
+    }
+    return allRequirements;
+}
+// @spec status-command.spec.md/REQ-DATA-1.2 Determine parent requirement for hierarchy
+function determineParentRequirement(requirementId) {
+    const parts = requirementId.split('-');
+    if (parts.length < 3)
+        return undefined;
+    const [, category, numberPart] = parts;
+    const dotIndex = numberPart.indexOf('.');
+    if (dotIndex === -1)
+        return undefined; // Top-level requirement
+    const parentNumber = numberPart.substring(0, dotIndex);
+    return `REQ-${category}-${parentNumber}`;
+}
+// @spec status-command.spec.md/REQ-DATA-1.1 Find specification file in workspace
+async function findSpecificationFile(workspaceRoot, specName) {
+    const specsDir = path.join(workspaceRoot, '.mod/specs');
+    // @spec status-command.spec.md/REQ-DATA-1.1 Search recursively in .mod/specs
+    async function searchDir(dir) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    const result = await searchDir(fullPath);
+                    if (result)
+                        return result;
+                }
+                else if (entry.name === specName) {
+                    return fullPath;
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+        return null;
+    }
+    const found = await searchDir(specsDir);
+    if (!found) {
+        throw new Error(`Specification file "${specName}" not found in ${specsDir}`);
+    }
+    return found;
+}
+// @spec status-command.spec.md/REQ-DATA-2.3 Filter traces by specification name
+function filterTracesBySpec(traceMap, specName) {
+    const filtered = new Map();
+    const specBaseName = specName.replace('.spec.md', '');
+    for (const [requirementId, traces] of traceMap.entries()) {
+        // @spec status-command.spec.md/REQ-DATA-2.2 Support spec-prefixed traces
+        const relevantTraces = traces.filter(trace => {
+            if (!trace.specPath)
+                return true; // Legacy format without spec path
+            return trace.specPath.includes(specBaseName);
+        });
+        if (relevantTraces.length > 0) {
+            filtered.set(requirementId, relevantTraces);
+        }
+    }
+    return filtered;
+}
+// @spec status-command.spec.md/REQ-BUS-1.1 Status classification logic
+function getRequirementStatus(traceCount) {
+    return traceCount === 0 ? 'todo' : 'traced';
+}
+// @spec status-command.spec.md/REQ-DATA-1.2 Calculate hierarchy level from requirement ID
+function calculateHierarchyLevel(requirementId) {
+    const parts = requirementId.split('-');
+    if (parts.length < 3)
+        return 1; // REQ-CAT
+    const numberPart = parts[2]; // The part after REQ-CAT-
+    const dotCount = (numberPart.match(/\./g) || []).length;
+    // @spec status-command.spec.md/REQ-DATA-1.2.2 Calculate hierarchy levels for proper indentation in output display
+    return 2 + dotCount; // REQ-CAT-N = 2, REQ-CAT-N.N = 3, etc.
+}
+// @spec status-command.spec.md/REQ-BUS-1.2 Hierarchical aggregation: parent status reflects worst child status
+function applyHierarchicalAggregation(requirements) {
+    // Sort by hierarchy level (deepest first) to process children before parents
+    const sortedByHierarchy = [...requirements].sort((a, b) => b.hierarchyLevel - a.hierarchyLevel);
+    for (const requirement of sortedByHierarchy) {
+        // Find all child requirements
+        const children = requirements.filter(r => r.requirementId.startsWith(requirement.requirementId + '.') &&
+            r.hierarchyLevel === requirement.hierarchyLevel + 1);
+        if (children.length > 0) {
+            // If parent has no direct traces but all children are traced, mark parent as traced
+            if (requirement.traceCount === 0 && children.every(child => child.status === 'traced')) {
+                requirement.status = 'traced';
+            }
+            // If any child is todo, parent remains todo (current behavior is correct)
+        }
+    }
+}
+// @spec status-command.spec.md/REQ-UX-1.1 TypeScript compiler-style output formatting
+function printTscStyleOutput(analysis) {
+    // @spec status-command.spec.md/REQ-UX-1.2 Status indicator mapping with colors
+    const colors = {
+        traced: '\x1b[32m', // Green
+        todo: '\x1b[31m', // Red
+        reset: '\x1b[0m', // Reset
+        dim: '\x1b[90m', // Dim gray
+        count: '\x1b[36m' // Cyan for trace counts
+    };
+    // @spec status-command.spec.md/REQ-UX-1.3 Header with spec name and count
+    const totalReqs = analysis.requirements.length;
+    console.log(`${analysis.specFile} - ${totalReqs} requirements\n`);
+    // @spec status-command.spec.md/REQ-UX-1.1 Print requirements organized by top-level sections
+    const requirementsByCategory = groupRequirementsByCategory(analysis.requirements);
+    // @spec status-command.spec.md/REQ-BUS-1.2 Hierarchical aggregation: parent status reflects worst child status  
+    for (const [category, requirements] of requirementsByCategory.entries()) {
+        // @spec status-command.spec.md/REQ-UX-1.2.1 Section headers with color-coded category grouping for visual organization
+        // Print section header
+        console.log(`${colors.dim}## ${category} Requirements${colors.reset}\n`);
+        for (const req of requirements) {
+            const statusLabel = req.status === 'todo' ? 'todo' : 'traced';
+            const color = colors[statusLabel];
+            // @spec status-command.spec.md/REQ-UX-1.3 Truncate title to 60 chars
+            const truncatedTitle = req.title.length > 60 ?
+                req.title.substring(0, 57) + '...' : req.title;
+            // @spec status-command.spec.md/REQ-DATA-1.2 Add indentation based on hierarchy level
+            const indent = '  '.repeat(Math.max(0, req.hierarchyLevel - 2));
+            if (req.traces.length > 0) {
+                // @spec status-command.spec.md/REQ-UX-1.1 Show implementation location with trace count
+                const trace = req.traces[0]; // Show first trace
+                const traceCountDisplay = req.traceCount > 1 ? ` ${colors.count}(${req.traceCount})${colors.reset}` : '';
+                console.log(`${indent}${trace.file}:${trace.line}:1 - ${color}${statusLabel}${colors.reset}${traceCountDisplay} ${req.requirementId}: ${truncatedTitle}`);
+            }
+            else {
+                // @spec status-command.spec.md/REQ-UX-1.1 Show spec location with actual line number
+                const lineNumber = req.lineRange?.start || 1;
+                console.log(`${indent}${analysis.specFile}:${lineNumber}:1 - ${color}${statusLabel}${colors.reset} ${req.requirementId}: ${truncatedTitle}`);
+            }
+        }
+        console.log(); // Add spacing between sections
+    }
+    // @spec status-command.spec.md/REQ-UX-1.1 Color-coded summary line
+    // @spec status-command.spec.md/REQ-UX-1.3.1 Color-coded summary line with trace counts and requirement status
+    const tracedText = `${colors.traced}${analysis.summary.traced} traced${colors.reset}`;
+    const todoText = `${colors.todo}${analysis.summary.todo} todo${colors.reset}`;
+    const totalTracesText = `${colors.count}${analysis.summary.totalTraces} traces${colors.reset}`;
+    console.log(`Found ${tracedText}, ${todoText} (${totalTracesText} total).`);
+}
+// @spec status-command.spec.md/REQ-DATA-1.2 Group requirements by category to maintain spec order
+function groupRequirementsByCategory(requirements) {
+    const categoryOrder = ['UX', 'BUS', 'DATA', 'INT', 'INFRA', 'QUAL'];
+    const grouped = new Map();
+    // Initialize with empty arrays in correct order
+    for (const category of categoryOrder) {
+        grouped.set(category, []);
+    }
+    // Group requirements by category
+    for (const req of requirements) {
+        const category = req.category;
+        if (!grouped.has(category)) {
+            grouped.set(category, []);
+        }
+        grouped.get(category).push(req);
+    }
+    // Sort requirements within each category by ID
+    for (const [, reqs] of grouped.entries()) {
+        reqs.sort((a, b) => a.requirementId.localeCompare(b.requirementId));
+    }
+    // Remove empty categories
+    const result = new Map();
+    for (const [category, reqs] of grouped.entries()) {
+        if (reqs.length > 0) {
+            result.set(category, reqs);
+        }
+    }
+    return result;
+}

package/dist/commands/sync.js

@@ -0,0 +1,95 @@
+import { SyncDaemon } from '../services/sync-daemon.js';
+import { FileImportService } from '../services/file-import-service.js';
+export async function syncCommand(args, repo) {
+    const command = args[0] || 'start';
+    const daemon = new SyncDaemon();
+    try {
+        switch (command) {
+            case 'start':
+                await daemon.start({
+                    force: args.includes('--force'),
+                    verbose: args.includes('--verbose')
+                });
+                break;
+            case 'stop':
+                await daemon.stop({
+                    force: args.includes('--force')
+                });
+                break;
+            case 'restart':
+                await daemon.restart({
+                    force: args.includes('--force'),
+                    verbose: args.includes('--verbose')
+                });
+                break;
+            case 'status':
+                const status = await daemon.status();
+                if (!status) {
+                    console.log('❌ Daemon is not running');
+                    return;
+                }
+                console.log('📊 Sync Daemon Status:');
+                console.log(`   Status: ${status.status}`);
+                console.log(`   PID: ${status.pid}`);
+                console.log(`   Started: ${new Date(status.startedAt).toLocaleString()}`);
+                console.log(`   Last Activity: ${new Date(status.lastActivity).toLocaleString()}`);
+                console.log(`   Workspace: ${status.workspaceId}${status.workspaceName ? ` (${status.workspaceName})` : ''}`);
+                if (status.activeBranchId) {
+                    console.log(`   Active Branch: ${status.activeBranchId}`);
+                }
+                console.log(`   Watched Files: ${status.watchedFiles}`);
+                if (status.uptime) {
+                    const uptimeSeconds = Math.floor(status.uptime / 1000);
+                    const hours = Math.floor(uptimeSeconds / 3600);
+                    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+                    const seconds = uptimeSeconds % 60;
+                    console.log(`   Uptime: ${hours}h ${minutes}m ${seconds}s`);
+                }
+                if (status.crashCount > 0) {
+                    console.log(`   Crashes: ${status.crashCount}`);
+                }
+                if (status.lastError) {
+                    console.log(`   Last Error: ${status.lastError}`);
+                }
+                break;
+            case 'import':
+                const importService = new FileImportService(repo);
+                console.log('DEBUG: sync import args:', args);
+                const preview = args.includes('--preview');
+                console.log('DEBUG: preview flag:', preview);
+                const patterns = args.filter(arg => !arg.startsWith('--'));
+                if (preview) {
+                    console.log('DEBUG: Running preview mode only');
+                    await importService.previewImport({
+                        patterns: patterns.length > 1 ? patterns.slice(1) : undefined,
+                        verbose: args.includes('--verbose')
+                    });
+                    return; // Exit after preview
+                }
+                console.log('DEBUG: Running full import');
+                await importService.executeImport({
+                    patterns: patterns.length > 1 ? patterns.slice(1) : undefined,
+                    verbose: args.includes('--verbose')
+                });
+                break;
+            default:
+                console.log('Usage: mod sync <command>');
+                console.log('Commands:');
+                console.log('  start    Start the sync daemon in the background');
+                console.log('  stop     Stop the sync daemon gracefully');
+                console.log('  restart  Restart the sync daemon');
+                console.log('  status   Show daemon status and health information');
+                console.log('  import   Import existing project files to workspace');
+                console.log('');
+                console.log('Options:');
+                console.log('  --force    Force start/stop operations');
+                console.log('  --verbose  Enable verbose output');
+                console.log('  --preview  Preview files without importing (import only)');
+                break;
+        }
+    }
+    catch (error) {
+        console.error(`❌ Sync command failed:`, error);
+        process.exit(1);
+    }
+}