@mod-computer/cli 0.1.0

package/dist/commands/spec.js

@@ -0,0 +1,386 @@
+import { SpecificationParserService, RequirementCategory } from '@mod/mod-core';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { log } from '../services/logger.js';
+import { readModConfig } from '../services/mod-config.js';
+import { createModWorkspace } from '@mod/mod-core';
+export async function specCommand(args, repo) {
+    const subcommand = args[0] || 'status';
+    const remainingArgs = args.slice(1);
+    switch (subcommand) {
+        case 'status':
+            await specStatusCommand(remainingArgs, repo);
+            break;
+        case 'list':
+            await specListCommand(remainingArgs);
+            break;
+        default:
+            // If no valid subcommand, assume it's a spec file for status
+            await specStatusCommand([subcommand, ...remainingArgs], repo);
+    }
+}
+async function specStatusCommand(args, repo) {
+    try {
+        let specName = args[0];
+        if (!specName && repo) {
+            const activeBranchSpec = await getActiveBranchSpec(repo);
+            if (activeBranchSpec) {
+                specName = activeBranchSpec;
+                console.log(`Using active branch specification: ${specName}`);
+            }
+        }
+        if (!specName) {
+            console.error('Error: Specification file required');
+            console.error('Usage: mod spec status [spec-file]');
+            console.error('       mod spec status   (uses active branch spec if available)');
+            process.exit(1);
+        }
+        if (!specName.endsWith('.spec.md')) {
+            specName += '.spec.md';
+        }
+        const workspaceRoot = process.cwd();
+        const analysis = await analyzeSpecification(workspaceRoot, specName);
+        printTscStyleOutput(analysis);
+        process.exit(0);
+    }
+    catch (error) {
+        handleError(error, args[0]);
+    }
+}
+async function specListCommand(args) {
+    try {
+        const workspaceRoot = process.cwd();
+        const specsDir = path.join(workspaceRoot, '.mod/specs');
+        const specs = await findAllSpecifications(specsDir);
+        if (specs.length === 0) {
+            console.log('No specification files found in .mod/specs');
+            return;
+        }
+        console.log('Available specifications:\n');
+        // Group by directory
+        const grouped = new Map();
+        for (const spec of specs) {
+            const dir = path.dirname(spec);
+            if (!grouped.has(dir)) {
+                grouped.set(dir, []);
+            }
+            grouped.get(dir).push(path.basename(spec));
+        }
+        // Display grouped specs
+        for (const [dir, files] of grouped) {
+            const relDir = dir === '.' ? '' : `${dir}/`;
+            for (const file of files) {
+                console.log(`  ${relDir}${file}`);
+            }
+        }
+        console.log(`\nTotal: ${specs.length} specification files`);
+    }
+    catch (error) {
+        console.error('Failed to list specifications:', error);
+        process.exit(1);
+    }
+}
+async function getActiveBranchSpec(repo) {
+    try {
+        const cfg = readModConfig();
+        if (!cfg?.workspaceId || !cfg?.activeBranchId) {
+            return undefined;
+        }
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandles = await modWorkspace.listWorkspaces();
+        const workspaceHandle = workspaceHandles.find(wh => wh.id === cfg.workspaceId);
+        if (!workspaceHandle)
+            return undefined;
+        const branches = await workspaceHandle.branch.list();
+        const activeBranch = branches.find(b => b.id === cfg.activeBranchId);
+        if (!activeBranch?.metadata?.linkedSpec)
+            return undefined;
+        return activeBranch.metadata.linkedSpec;
+    }
+    catch (error) {
+        log('[Spec] Failed to get active branch spec:', error);
+        return undefined;
+    }
+}
+async function analyzeSpecification(workspaceRoot, specName) {
+    const parser = new SpecificationParserService({
+        workspaceRoot,
+        specsDirectory: '.mod/specs',
+        cacheEnabled: false
+    });
+    log('[Spec] Scanning workspace for @spec traces');
+    const startTime = Date.now();
+    const traceMap = await parser.scanWorkspaceForTraces();
+    const scanTime = Date.now() - startTime;
+    log(`[Spec] Scan completed in ${scanTime}ms, found ${traceMap.size} requirement IDs`);
+    const specFilePath = await findSpecificationFile(workspaceRoot, specName);
+    const content = await fs.readFile(specFilePath, 'utf-8');
+    const parsed = await parser.parseSpecification(content, specFilePath);
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    const frontmatterOffset = frontmatterMatch ? frontmatterMatch[0].split('\n').length - 1 : 0;
+    const allRequirements = extractNestedRequirements(content, parsed.requirements, frontmatterOffset);
+    const filteredTraces = filterTracesBySpec(traceMap, specName);
+    const requirements = allRequirements.map(req => {
+        const traces = filteredTraces.get(req.id) || [];
+        const status = traces.length === 0 ? 'todo' : 'traced';
+        return {
+            requirementId: req.id,
+            category: req.category,
+            title: req.title,
+            status: 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
+        };
+    });
+    applyHierarchicalAggregation(requirements);
+    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
+    };
+}
+async function findSpecificationFile(workspaceRoot, specName) {
+    const specsDir = path.join(workspaceRoot, '.mod/specs');
+    const matches = [];
+    async function searchDir(dir, relativePath = '') {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relPath = path.join(relativePath, entry.name);
+                if (entry.isDirectory()) {
+                    await searchDir(fullPath, relPath);
+                }
+                else if (entry.name.endsWith('.spec.md')) {
+                    // Check exact match with path or just filename
+                    if (relPath === specName || entry.name === specName) {
+                        matches.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+    }
+    await searchDir(specsDir);
+    if (matches.length === 0) {
+        throw new Error(`Specification file "${specName}" not found in ${specsDir}`);
+    }
+    if (matches.length > 1) {
+        const errorMsg = [`Multiple specifications found with name "${specName}":`];
+        const sortedPaths = matches.map(m => path.relative(specsDir, m)).sort();
+        for (const specPath of sortedPaths) {
+            errorMsg.push(`  - ${specPath}`);
+        }
+        errorMsg.push('');
+        errorMsg.push('Please specify the full path from .mod/specs/');
+        errorMsg.push(`Example: mod spec status ${sortedPaths[0]}`);
+        throw new Error(errorMsg.join('\n'));
+    }
+    return matches[0];
+}
+// Helper function to find all specifications
+async function findAllSpecifications(specsDir) {
+    const specs = [];
+    async function searchDir(dir, relativePath = '') {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relPath = path.join(relativePath, entry.name);
+                if (entry.isDirectory()) {
+                    await searchDir(fullPath, relPath);
+                }
+                else if (entry.name.endsWith('.spec.md')) {
+                    specs.push(relPath);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+    }
+    await searchDir(specsDir);
+    return specs.sort();
+}
+// Extract nested requirements (reused from status.ts)
+function extractNestedRequirements(content, topLevelRequirements, frontmatterOffset) {
+    const adjustedTopLevel = topLevelRequirements.map(req => ({
+        ...req,
+        lineRange: req.lineRange ? {
+            start: req.lineRange.start + frontmatterOffset,
+            end: req.lineRange.end + frontmatterOffset
+        } : undefined
+    }));
+    const allRequirements = [...adjustedTopLevel];
+    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;
+        const categoryMatch = id.match(/REQ-([A-Z]+)/);
+        if (!categoryMatch)
+            continue;
+        const categoryStr = categoryMatch[1];
+        const category = Object.values(RequirementCategory).find(cat => cat === categoryStr);
+        if (!category)
+            continue;
+        if (topLevelRequirements.some(req => req.id === id))
+            continue;
+        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;
+}
+function filterTracesBySpec(traceMap, specName) {
+    const filtered = new Map();
+    const specBaseName = specName.replace('.spec.md', '');
+    for (const [requirementId, traces] of traceMap.entries()) {
+        const relevantTraces = traces.filter(trace => {
+            if (!trace.specPath)
+                return true;
+            return trace.specPath.includes(specBaseName);
+        });
+        if (relevantTraces.length > 0) {
+            filtered.set(requirementId, relevantTraces);
+        }
+    }
+    return filtered;
+}
+// Helper functions
+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;
+    const parentNumber = numberPart.substring(0, dotIndex);
+    return `REQ-${category}-${parentNumber}`;
+}
+function calculateHierarchyLevel(requirementId) {
+    const parts = requirementId.split('-');
+    if (parts.length < 3)
+        return 1;
+    const numberPart = parts[2];
+    const dotCount = (numberPart.match(/\./g) || []).length;
+    return 2 + dotCount;
+}
+function applyHierarchicalAggregation(requirements) {
+    const sortedByHierarchy = [...requirements].sort((a, b) => b.hierarchyLevel - a.hierarchyLevel);
+    for (const requirement of sortedByHierarchy) {
+        const children = requirements.filter(r => r.requirementId.startsWith(requirement.requirementId + '.') &&
+            r.hierarchyLevel === requirement.hierarchyLevel + 1);
+        if (children.length > 0) {
+            if (requirement.traceCount === 0 && children.every(child => child.status === 'traced')) {
+                requirement.status = 'traced';
+            }
+        }
+    }
+}
+function printTscStyleOutput(analysis) {
+    const colors = {
+        traced: '\x1b[32m', // Green
+        todo: '\x1b[31m', // Red
+        reset: '\x1b[0m',
+        dim: '\x1b[90m', // Dim gray
+        count: '\x1b[36m' // Cyan for trace counts
+    };
+    const totalReqs = analysis.requirements.length;
+    console.log(`${analysis.specFile} - ${totalReqs} requirements\n`);
+    const requirementsByCategory = groupRequirementsByCategory(analysis.requirements);
+    for (const [category, requirements] of requirementsByCategory.entries()) {
+        console.log(`${colors.dim}## ${category} Requirements${colors.reset}\n`);
+        for (const req of requirements) {
+            const statusLabel = req.status;
+            const color = colors[statusLabel];
+            const truncatedTitle = req.title.length > 60 ?
+                req.title.substring(0, 57) + '...' : req.title;
+            const indent = '  '.repeat(Math.max(0, req.hierarchyLevel - 2));
+            if (req.traces.length > 0) {
+                const trace = req.traces[0];
+                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 {
+                const lineNumber = req.lineRange?.start || 1;
+                console.log(`${indent}${analysis.specFile}:${lineNumber}:1 - ${color}${statusLabel}${colors.reset} ${req.requirementId}: ${truncatedTitle}`);
+            }
+        }
+        console.log();
+    }
+    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).`);
+}
+function groupRequirementsByCategory(requirements) {
+    const categoryOrder = ['UX', 'BUS', 'DATA', 'INT', 'INFRA', 'QUAL'];
+    const grouped = new Map();
+    for (const category of categoryOrder) {
+        grouped.set(category, []);
+    }
+    for (const req of requirements) {
+        const category = req.category;
+        if (!grouped.has(category)) {
+            grouped.set(category, []);
+        }
+        grouped.get(category).push(req);
+    }
+    for (const [, reqs] of grouped.entries()) {
+        reqs.sort((a, b) => a.requirementId.localeCompare(b.requirementId));
+    }
+    const result = new Map();
+    for (const [category, reqs] of grouped.entries()) {
+        if (reqs.length > 0) {
+            result.set(category, reqs);
+        }
+    }
+    return result;
+}
+function handleError(error, specName) {
+    if (error instanceof Error) {
+        if (error.message.includes('not found')) {
+            console.error(`Error: Specification file "${specName}" not found`);
+            process.exit(1);
+        }
+        else if (error.message.includes('parse')) {
+            console.error(`Error: Failed to parse specification: ${error.message}`);
+            process.exit(2);
+        }
+        else if (error.message.includes('scan')) {
+            console.error(`Error: Failed to scan workspace: ${error.message}`);
+            process.exit(3);
+        }
+        else if (error.message.includes('Multiple specifications found')) {
+            console.error(error.message);
+            process.exit(1);
+        }
+    }
+    console.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(3);
+}