@mod-computer/cli 0.1.1 → 0.2.1

package/dist/lib/trace-formatters.js

@@ -0,0 +1,314 @@
+/**
+ * Trace Formatters
+ * Formatting utilities for trace CLI output
+ *
+ * spec: packages/mod-cli/specs/traces-cli.md
+ */
+// =============================================================================
+// List Formatters
+// =============================================================================
+// glassware[type="implementation", id="impl-trace-list-table--58311354", specifications="specification-spec-traces-cli-list-output--46cf3c8e"]
+/**
+ * Format traces as a table
+ */
+export function formatTracesTable(traces) {
+    if (traces.length === 0) {
+        return 'No traces found.';
+    }
+    const lines = [];
+    lines.push('Traces');
+    lines.push('═'.repeat(70));
+    lines.push('');
+    // Group by node type
+    const byType = new Map();
+    for (const trace of traces) {
+        const list = byType.get(trace.nodeType) || [];
+        list.push(trace);
+        byType.set(trace.nodeType, list);
+    }
+    for (const [nodeType, typeTraces] of byType) {
+        lines.push(`${nodeType} (${typeTraces.length})`);
+        lines.push('─'.repeat(40));
+        for (const trace of typeTraces) {
+            const location = trace.location.type === 'inline'
+                ? `${trace.location.file}:${trace.location.line}`
+                : `mod:${trace.location.docId}`;
+            const status = trace.status === 'orphaned' ? ' [orphaned]' : '';
+            const linkCount = trace.links.length > 0 ? ` (${trace.links.length} links)` : '';
+            lines.push(`  ${trace.id}${status}${linkCount}`);
+            lines.push(`    └─ ${location}`);
+            if (trace.text && trace.text !== trace.id) {
+                const truncatedText = trace.text.length > 50
+                    ? trace.text.slice(0, 47) + '...'
+                    : trace.text;
+                lines.push(`       "${truncatedText}"`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push(`Total: ${traces.length} traces`);
+    return lines.join('\n');
+}
+// glassware[type="implementation", id="impl-trace-list-json--fc16c20a", specifications="specification-spec-traces-cli-json--abf2b82f"]
+/**
+ * Format traces as JSON
+ */
+export function formatTracesJson(traces) {
+    return JSON.stringify({
+        traces: traces.map(t => ({
+            id: t.id,
+            nodeType: t.nodeType,
+            storage: t.storage,
+            location: t.location,
+            text: t.text,
+            status: t.status,
+            links: t.links,
+        })),
+        total: traces.length,
+    }, null, 2);
+}
+// =============================================================================
+// Report Formatters
+// =============================================================================
+// glassware[type="implementation", id="impl-trace-report-text--5ba186be", specifications="specification-spec-traces-cli-report--2af325ed,specification-spec-traces-cli-report-content--8971542e"]
+/**
+ * Format trace report as text
+ * @param allTests - Optional array of all tests in workspace for test coverage checking
+ */
+export function formatTraceReport(report, allTests = []) {
+    const lines = [];
+    const fileName = report.file.split('/').pop() || report.file;
+    lines.push(`${fileName} - Trace Report`);
+    lines.push('═'.repeat(55));
+    lines.push('');
+    if (report.traces.length === 0) {
+        lines.push('No traces found in this file.');
+        return lines.join('\n');
+    }
+    for (const item of report.traces) {
+        const trace = item.trace;
+        const statusIcon = getStatusIcon(item.status);
+        const implStatus = getImplStatus(item);
+        const testStatus = getTestStatus(item, allTests);
+        // Main trace line
+        const shortId = trace.id.split('--')[0];
+        const title = trace.text && trace.text !== trace.id
+            ? trace.text.slice(0, 40)
+            : shortId;
+        lines.push(`${statusIcon} ${shortId}: ${title}`);
+        lines.push(`   ${implStatus} ${testStatus}`);
+        // Show implementations (implementations point TO specs, so check incoming)
+        const implementations = item.incoming['implements'] || [];
+        for (const impl of implementations) {
+            const implLoc = impl.location.type === 'inline'
+                ? `${impl.location.file}:${impl.location.line}`
+                : `mod:${impl.location.docId}`;
+            lines.push(`   └─ impl: ${implLoc}`);
+            // Show tests for this implementation
+            const tests = getTestsForImpl(impl, allTests);
+            for (const test of tests) {
+                const testLoc = test.location.type === 'inline'
+                    ? `${test.location.file}:${test.location.line}`
+                    : `mod:${test.location.docId}`;
+                lines.push(`        └─ test: ${testLoc}`);
+            }
+        }
+        lines.push('');
+    }
+    // Recalculate summary based on incoming edges (since implementations point TO specs)
+    let fullyLinked = 0;
+    let partiallyLinked = 0;
+    let unlinked = 0;
+    for (const item of report.traces) {
+        const impls = item.incoming['implements'] || [];
+        const hasImpl = impls.length > 0;
+        const hasTests = impls.some(impl => allTests.some(test => test.links.some(l => stripTypePrefix(l.targetId) === impl.id)));
+        if (hasImpl && hasTests) {
+            fullyLinked++;
+        }
+        else if (hasImpl) {
+            partiallyLinked++;
+        }
+        else {
+            unlinked++;
+        }
+    }
+    lines.push('─'.repeat(55));
+    lines.push(`Summary: ${fullyLinked}/${report.traces.length} fully linked, ` +
+        `${partiallyLinked} partial, ${unlinked} unlinked`);
+    return lines.join('\n');
+}
+function getStatusIcon(status) {
+    switch (status) {
+        case 'fully-linked': return '✓';
+        case 'partially-linked': return '⚠';
+        case 'unlinked': return '✗';
+    }
+}
+function getImplStatus(item) {
+    // Implementations point TO specs, so check incoming edges
+    const hasImpl = (item.incoming['implements'] || []).length > 0;
+    return hasImpl ? '✓ Implemented' : '✗ Not implemented';
+}
+// Strip type prefix from link target IDs (e.g., "implementation-impl-foo--abc" -> "impl-foo--abc")
+function stripTypePrefix(targetId) {
+    const prefixes = ['implementation-', 'specification-', 'requirement-', 'test-'];
+    for (const prefix of prefixes) {
+        if (targetId.startsWith(prefix)) {
+            return targetId.slice(prefix.length);
+        }
+    }
+    return targetId;
+}
+function getTestStatus(item, allTests) {
+    // Check if any incoming implementations have tests pointing TO them
+    const impls = item.incoming['implements'] || [];
+    for (const impl of impls) {
+        // Find tests that link to this implementation (strip type prefix from targetId)
+        const hasTest = allTests.some(test => test.links.some(l => stripTypePrefix(l.targetId) === impl.id));
+        if (hasTest) {
+            return '✓ Tested';
+        }
+    }
+    return impls.length > 0 ? '✗ No tests' : '';
+}
+function getTestsForImpl(impl, allTests) {
+    // Find tests that link to this implementation (strip type prefix from targetId)
+    return allTests.filter(test => test.links.some(l => stripTypePrefix(l.targetId) === impl.id));
+}
+// glassware[type="implementation", id="impl-trace-report-json--10381dca", specifications="specification-spec-traces-cli-report-json--0a0ddd0d"]
+/**
+ * Format trace report as JSON
+ * @param allTests - Optional array of all tests in workspace for test coverage checking
+ */
+export function formatTraceReportJson(report, allTests = []) {
+    // TODO: Could enhance JSON output with test coverage info from allTests
+    return JSON.stringify(report, null, 2);
+}
+// =============================================================================
+// Coverage Formatters
+// =============================================================================
+// glassware[type="implementation", id="impl-trace-coverage-text--45e4276a", specifications="specification-spec-traces-cli-coverage--571a6cbb,specification-spec-traces-cli-coverage-visual--d06a6e97"]
+/**
+ * Format coverage report as text with progress bars
+ */
+export function formatCoverageReport(coverage) {
+    const lines = [];
+    lines.push('Trace Coverage');
+    lines.push('═'.repeat(55));
+    lines.push('');
+    // Per node type stats
+    for (const [nodeType, stats] of Object.entries(coverage.byNodeType)) {
+        if (stats.total === 0)
+            continue;
+        const linkedCount = stats.fullyLinked + stats.partiallyLinked;
+        const percentage = Math.round((linkedCount / stats.total) * 100);
+        const bar = createProgressBar(percentage);
+        lines.push(`${nodeType}:`);
+        lines.push(`  ${bar}  ${percentage}%  (${linkedCount}/${stats.total} linked)`);
+    }
+    lines.push('');
+    lines.push('─'.repeat(55));
+    // Summary
+    const { summary } = coverage;
+    lines.push(`Total traces: ${summary.totalTraces}`);
+    lines.push(`Fully linked: ${summary.fullyLinked}`);
+    lines.push(`Coverage: ${summary.coveragePercentage.toFixed(1)}%`);
+    // Gaps
+    if (coverage.orphaned.length > 0) {
+        lines.push('');
+        lines.push(`⚠ Orphaned traces: ${coverage.orphaned.length}`);
+    }
+    const missingCount = Object.values(coverage.missingEdges).reduce((sum, arr) => sum + arr.length, 0);
+    if (missingCount > 0) {
+        lines.push(`⚠ Missing edges: ${missingCount}`);
+    }
+    return lines.join('\n');
+}
+function createProgressBar(percentage, width = 16) {
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    return '█'.repeat(filled) + '░'.repeat(empty);
+}
+// glassware[type="implementation", id="impl-trace-coverage-json--f30dd68a", specifications="specification-spec-traces-cli-coverage-json--f23ec095"]
+/**
+ * Format coverage report as JSON
+ */
+export function formatCoverageJson(coverage) {
+    // Transform to agent-friendly format
+    const requirements = coverage.byNodeType['requirement'] || { total: 0, fullyLinked: 0, partiallyLinked: 0, unlinked: 0 };
+    const implementations = coverage.byNodeType['implementation'] || { total: 0, fullyLinked: 0, partiallyLinked: 0, unlinked: 0 };
+    return JSON.stringify({
+        coverage: {
+            requirements: {
+                total: requirements.total,
+                implemented: requirements.fullyLinked + requirements.partiallyLinked,
+            },
+            implementations: {
+                total: implementations.total,
+                tested: implementations.fullyLinked,
+            },
+        },
+        byNodeType: coverage.byNodeType,
+        summary: coverage.summary,
+        orphaned: coverage.orphaned.map(t => ({
+            id: t.id,
+            nodeType: t.nodeType,
+            file: t.location.type === 'inline' ? t.location.file : undefined,
+            line: t.location.type === 'inline' ? t.location.line : undefined,
+        })),
+        missingEdges: Object.fromEntries(Object.entries(coverage.missingEdges).map(([edge, traces]) => [
+            edge,
+            traces.map(t => ({
+                id: t.id,
+                nodeType: t.nodeType,
+                file: t.location.type === 'inline' ? t.location.file : undefined,
+            })),
+        ])),
+    }, null, 2);
+}
+// =============================================================================
+// Unmet Requirements Formatter
+// =============================================================================
+// glassware[type="implementation", id="impl-trace-unmet-text--fc495826", specifications="specification-spec-traces-cli-unmet--1c11203e,specification-spec-traces-cli-unmet-output--623dd824"]
+/**
+ * Format unmet requirements list
+ */
+export function formatUnmetRequirements(traces) {
+    if (traces.length === 0) {
+        return 'All requirements have implementations! 🎉';
+    }
+    const lines = [];
+    lines.push('Unmet Requirements');
+    lines.push('═'.repeat(55));
+    lines.push('');
+    for (const trace of traces) {
+        const location = trace.location.type === 'inline'
+            ? `${trace.location.file}:${trace.location.line}`
+            : `mod:${trace.location.docId}`;
+        const title = trace.text && trace.text !== trace.id
+            ? trace.text.slice(0, 50)
+            : trace.id.split('--')[0];
+        lines.push(`✗ ${trace.id}`);
+        lines.push(`  "${title}"`);
+        lines.push(`  └─ ${location}`);
+        lines.push('');
+    }
+    lines.push(`Total: ${traces.length} unmet requirements`);
+    return lines.join('\n');
+}
+// glassware[type="implementation", id="impl-trace-unmet-json--aa05049d", specifications="specification-spec-traces-cli-json--abf2b82f"]
+/**
+ * Format unmet requirements as JSON
+ */
+export function formatUnmetJson(traces) {
+    return JSON.stringify({
+        unmet: traces.map(t => ({
+            id: t.id,
+            title: t.text || t.id.split('--')[0],
+            file: t.location.type === 'inline' ? t.location.file : undefined,
+            line: t.location.type === 'inline' ? t.location.line : undefined,
+        })),
+        total: traces.length,
+    }, null, 2);
+}