@rengler33/prov 0.1.1

package/dist/commands/trace.js

@@ -0,0 +1,847 @@
+/**
+ * prov trace commands implementation.
+ *
+ * Commands for managing artifact traces:
+ * - trace add: Link an artifact to a plan step
+ * - trace show: Show provenance for an artifact
+ * - trace why: Show implementations of a requirement
+ *
+ * @see req:cli:trace-add
+ * @see req:cli:trace-show
+ * @see req:cli:trace-why
+ */
+import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
+import { resolve, relative, join, extname } from 'node:path';
+import { isInitialized, loadGraph, saveGraph } from '../storage.js';
+import { addTraceToGraph } from '../graph.js';
+import { sha256 } from '../hash.js';
+import { output, error, success, resolveFormat } from '../output.js';
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+/**
+ * Validate step ID format: step:{plan}:{number}
+ */
+function isValidStepId(id) {
+    if (typeof id !== 'string')
+        return false;
+    return /^step:[a-z0-9-]+:\d+$/.test(id);
+}
+/**
+ * Validate requirement ID format.
+ */
+function isValidRequirementId(id) {
+    if (typeof id !== 'string')
+        return false;
+    return /^req:[a-z0-9-]+(:[a-z0-9-]+)?$/.test(id);
+}
+/**
+ * Compute hash for a file's content.
+ */
+function computeFileHash(filePath) {
+    const content = readFileSync(filePath, 'utf8');
+    const fullHash = sha256(content);
+    return `sha256:${fullHash.slice(0, 12)}`;
+}
+/**
+ * Generate a trace ID from artifact path and step.
+ */
+function generateTraceId(artifactPath, stepId) {
+    const combined = `${artifactPath}:${stepId}`;
+    const fullHash = sha256(combined);
+    return `trace:${fullHash.slice(0, 12)}`;
+}
+// ============================================================================
+// trace add Command
+// ============================================================================
+/**
+ * Execute the trace add command.
+ *
+ * Links an artifact (file) to a plan step, recording the current hash
+ * for staleness detection.
+ *
+ * @see req:cli:trace-add
+ */
+export function runTraceAdd(globalOpts, artifactPath, options) {
+    const projectRoot = globalOpts.dir ?? process.cwd();
+    const fmt = resolveFormat({ format: globalOpts.format });
+    // Check if prov is initialized
+    if (!isInitialized(projectRoot)) {
+        const result = {
+            success: false,
+            error: 'prov is not initialized. Run "prov init" first.',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Validate step ID
+    const stepId = options.to;
+    if (!isValidStepId(stepId)) {
+        const result = {
+            success: false,
+            error: `Invalid step ID format: ${stepId} (expected step:{plan}:{number})`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Resolve artifact path
+    const fullPath = resolve(projectRoot, artifactPath);
+    const relPath = relative(projectRoot, fullPath);
+    if (!existsSync(fullPath)) {
+        const result = {
+            success: false,
+            error: `Artifact not found: ${artifactPath}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Check if it's a file (not directory)
+    const stat = statSync(fullPath);
+    if (!stat.isFile()) {
+        const result = {
+            success: false,
+            error: `Path is not a file: ${artifactPath}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Load graph
+    const loadResult = loadGraph(projectRoot);
+    if (!loadResult.success || loadResult.data === undefined) {
+        const result = {
+            success: false,
+            error: loadResult.error ?? 'Failed to load graph',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const graph = loadResult.data;
+    // Verify step exists in graph
+    const stepNode = graph.getNode(stepId);
+    if (stepNode === undefined || stepNode.type !== 'step') {
+        const result = {
+            success: false,
+            error: `Step not found: ${stepId}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Compute artifact hash
+    const artifactHash = computeFileHash(fullPath);
+    // Generate trace ID
+    const traceId = generateTraceId(relPath, stepId);
+    // Check if trace already exists
+    const existingNode = graph.getNode(traceId);
+    if (existingNode !== undefined) {
+        const existingTrace = existingNode.data;
+        if (existingTrace.artifactHash === artifactHash) {
+            // Same artifact, same hash - no update needed
+            const result = {
+                success: true,
+                traceId,
+                artifactPath: relPath,
+                stepId,
+                artifactHash,
+            };
+            if (fmt === 'json') {
+                output({ ...result, unchanged: true }, { format: 'json' });
+            }
+            else if (fmt === 'yaml') {
+                output({ ...result, unchanged: true }, { format: 'yaml' });
+            }
+            else {
+                success(`Trace ${traceId} is already tracked (unchanged)`);
+            }
+            return;
+        }
+        // Different hash - remove old trace and add new one
+        graph.removeNode(traceId);
+    }
+    // Create trace
+    const trace = {
+        id: traceId,
+        artifact: {
+            path: relPath,
+        },
+        step: stepId,
+        artifactHash,
+        createdAt: new Date().toISOString(),
+    };
+    // Add trace to graph
+    addTraceToGraph(graph, trace);
+    // Save graph
+    const saveResult = saveGraph(graph, projectRoot);
+    if (!saveResult.success) {
+        const result = {
+            success: false,
+            error: saveResult.error ?? 'Failed to save graph',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const result = {
+        success: true,
+        traceId,
+        artifactPath: relPath,
+        stepId,
+        artifactHash,
+    };
+    if (fmt === 'json') {
+        output(result, { format: 'json' });
+    }
+    else if (fmt === 'yaml') {
+        output(result, { format: 'yaml' });
+    }
+    else {
+        success(`Added trace ${traceId} linking ${relPath} to ${stepId}`);
+    }
+}
+// ============================================================================
+// trace show Command
+// ============================================================================
+/**
+ * Execute the trace show command.
+ *
+ * Shows the provenance chain for an artifact: artifact -> step -> decision/requirement -> spec.
+ *
+ * @see req:cli:trace-show
+ */
+export function runTraceShow(globalOpts, artifactPath, _options) {
+    const projectRoot = globalOpts.dir ?? process.cwd();
+    const fmt = resolveFormat({ format: globalOpts.format });
+    // Check if prov is initialized
+    if (!isInitialized(projectRoot)) {
+        const result = {
+            success: false,
+            error: 'prov is not initialized. Run "prov init" first.',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Resolve artifact path
+    const fullPath = resolve(projectRoot, artifactPath);
+    const relPath = relative(projectRoot, fullPath);
+    // Load graph
+    const loadResult = loadGraph(projectRoot);
+    if (!loadResult.success || loadResult.data === undefined) {
+        const result = {
+            success: false,
+            error: loadResult.error ?? 'Failed to load graph',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const graph = loadResult.data;
+    // Find trace for this artifact path
+    const artifactNodes = graph.getNodesByType('artifact');
+    let foundTrace;
+    let foundTraceId;
+    for (const node of artifactNodes) {
+        const trace = node.data;
+        if (trace.artifact.path === relPath) {
+            foundTrace = trace;
+            foundTraceId = trace.id;
+            break;
+        }
+    }
+    if (foundTrace === undefined || foundTraceId === undefined) {
+        const result = {
+            success: false,
+            error: `No trace found for artifact: ${artifactPath}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Check if artifact is stale
+    let isStale = false;
+    let currentHash;
+    if (existsSync(fullPath)) {
+        currentHash = computeFileHash(fullPath);
+        isStale = currentHash !== foundTrace.artifactHash;
+    }
+    else {
+        isStale = true; // File deleted = stale
+    }
+    // Build provenance chain
+    const provenance = [];
+    // Start with artifact
+    provenance.push({
+        type: 'artifact',
+        id: relPath,
+        description: `Hash: ${currentHash ?? 'missing'}${isStale ? ' (stale)' : ''}`,
+    });
+    // Find step
+    const stepNode = graph.getNode(foundTrace.step);
+    if (stepNode !== undefined && stepNode.type === 'step') {
+        const step = stepNode.data;
+        provenance.push({
+            type: 'step',
+            id: step.id,
+            description: step.action,
+        });
+        // Find what the step traces to (decisions and requirements)
+        for (const targetId of step.tracesTo) {
+            const targetNode = graph.getNode(targetId);
+            if (targetNode !== undefined) {
+                if (targetNode.type === 'decision') {
+                    provenance.push({
+                        type: 'decision',
+                        id: targetId,
+                        description: targetNode.data.choice,
+                    });
+                }
+                else if (targetNode.type === 'requirement') {
+                    const req = targetNode.data;
+                    provenance.push({
+                        type: 'requirement',
+                        id: targetId,
+                        description: req.description,
+                    });
+                    // Find parent spec
+                    const incomingEdges = graph.getIncomingEdges(targetId, 'contains');
+                    for (const edge of incomingEdges) {
+                        const specNode = graph.getNode(edge.from);
+                        if (specNode !== undefined && specNode.type === 'spec') {
+                            const spec = specNode.data;
+                            provenance.push({
+                                type: 'spec',
+                                id: spec.id,
+                                description: spec.title,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const result = {
+        success: true,
+        artifact: {
+            path: relPath,
+            hash: currentHash ?? foundTrace.artifactHash,
+            stale: isStale,
+        },
+        trace: {
+            id: foundTraceId,
+            stepId: foundTrace.step,
+            createdAt: foundTrace.createdAt,
+        },
+        provenance,
+    };
+    if (fmt === 'json') {
+        output(result, { format: 'json' });
+    }
+    else if (fmt === 'yaml') {
+        output(result, { format: 'yaml' });
+    }
+    else {
+        // Display provenance chain
+        process.stdout.write(`\nProvenance for ${relPath}\n`);
+        process.stdout.write(`${'─'.repeat(40)}\n`);
+        if (isStale) {
+            process.stdout.write(`⚠ STALE: Artifact has changed since trace was created\n\n`);
+        }
+        for (let i = 0; i < provenance.length; i++) {
+            const entry = provenance[i];
+            const indent = '  '.repeat(i);
+            const prefix = i === 0 ? '📄' : i === 1 ? '📋' : entry.type === 'spec' ? '📜' : '→';
+            process.stdout.write(`${indent}${prefix} [${entry.type}] ${entry.id}\n`);
+            if (entry.description !== undefined) {
+                process.stdout.write(`${indent}   ${entry.description}\n`);
+            }
+        }
+        process.stdout.write('\n');
+    }
+}
+// ============================================================================
+// trace why Command
+// ============================================================================
+/**
+ * Execute the trace why command.
+ *
+ * Shows all artifacts that implement a requirement, traversing:
+ * requirement <- step <- artifact
+ *
+ * @see req:cli:trace-why
+ */
+export function runTraceWhy(globalOpts, reqIdStr, _options) {
+    const projectRoot = globalOpts.dir ?? process.cwd();
+    const fmt = resolveFormat({ format: globalOpts.format });
+    // Check if prov is initialized
+    if (!isInitialized(projectRoot)) {
+        const result = {
+            success: false,
+            error: 'prov is not initialized. Run "prov init" first.',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Validate requirement ID
+    if (!isValidRequirementId(reqIdStr)) {
+        const result = {
+            success: false,
+            error: `Invalid requirement ID format: ${reqIdStr}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const reqId = reqIdStr;
+    // Load graph
+    const loadResult = loadGraph(projectRoot);
+    if (!loadResult.success || loadResult.data === undefined) {
+        const result = {
+            success: false,
+            error: loadResult.error ?? 'Failed to load graph',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const graph = loadResult.data;
+    // Find the requirement
+    const reqNode = graph.getNode(reqId);
+    if (reqNode === undefined || reqNode.type !== 'requirement') {
+        const result = {
+            success: false,
+            error: `Requirement not found: ${reqIdStr}`,
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const requirement = reqNode.data;
+    // Find all steps that trace to this requirement
+    const implementations = [];
+    const stepNodes = graph.getNodesByType('step');
+    for (const stepNode of stepNodes) {
+        const step = stepNode.data;
+        // Check if step traces to this requirement
+        if (step.tracesTo.includes(reqId)) {
+            // Find artifacts that implement this step
+            const outgoingEdges = graph.getOutgoingEdges(step.id, 'implements');
+            for (const edge of outgoingEdges) {
+                const artifactNode = graph.getNode(edge.to);
+                if (artifactNode !== undefined && artifactNode.type === 'artifact') {
+                    const trace = artifactNode.data;
+                    // Check if artifact is stale
+                    let isStale = false;
+                    const fullPath = resolve(projectRoot, trace.artifact.path);
+                    if (existsSync(fullPath)) {
+                        const currentHash = computeFileHash(fullPath);
+                        isStale = currentHash !== trace.artifactHash;
+                    }
+                    else {
+                        isStale = true;
+                    }
+                    implementations.push({
+                        artifactPath: trace.artifact.path,
+                        stepId: step.id,
+                        stepAction: step.action,
+                        traceId: trace.id,
+                        stale: isStale,
+                    });
+                }
+            }
+        }
+    }
+    const result = {
+        success: true,
+        requirementId: reqId,
+        requirement: {
+            id: reqId,
+            description: requirement.description,
+        },
+        implementations,
+    };
+    if (fmt === 'json') {
+        output(result, { format: 'json' });
+    }
+    else if (fmt === 'yaml') {
+        output(result, { format: 'yaml' });
+    }
+    else {
+        // Display implementations
+        process.stdout.write(`\nImplementations of ${reqId}\n`);
+        process.stdout.write(`${'─'.repeat(40)}\n`);
+        process.stdout.write(`${requirement.description}\n\n`);
+        if (implementations.length === 0) {
+            process.stdout.write(`No implementations found.\n`);
+        }
+        else {
+            const columns = [
+                { header: 'Artifact', key: 'artifactPath', maxWidth: 40 },
+                { header: 'Step', key: 'stepId', minWidth: 20 },
+                { header: 'Action', key: 'stepAction', maxWidth: 30 },
+                { header: 'Status', key: 'status', minWidth: 8 },
+            ];
+            const rows = implementations.map((impl) => ({
+                artifactPath: impl.artifactPath,
+                stepId: impl.stepId,
+                stepAction: impl.stepAction,
+                status: impl.stale ? 'stale' : 'current',
+            }));
+            output(rows, { format: 'table', columns });
+        }
+        process.stdout.write('\n');
+    }
+}
+/**
+ * Pattern to match prov trace comments.
+ * Matches: // prov:step:xxx or # prov:step:xxx
+ */
+const TRACE_PATTERN = /(?:\/\/|#)\s*prov:(step:[a-z0-9-]+:\d+)/gi;
+/**
+ * File extensions to scan for trace markers.
+ */
+const SCANNABLE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.rb', '.go', '.rs', '.java', '.kt',
+    '.c', '.cpp', '.h', '.hpp', '.cs',
+    '.sh', '.bash', '.zsh',
+    '.yaml', '.yml', '.json', '.toml',
+]);
+/**
+ * Scan a single file for prov trace markers.
+ */
+function scanFileForTraces(filePath, projectRoot) {
+    const traces = [];
+    const relPath = relative(projectRoot, filePath);
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            let match;
+            // Reset regex lastIndex for each line
+            TRACE_PATTERN.lastIndex = 0;
+            while ((match = TRACE_PATTERN.exec(line)) !== null) {
+                const stepId = match[1];
+                traces.push({
+                    file: relPath,
+                    line: i + 1, // 1-indexed
+                    stepId,
+                    comment: line.trim(),
+                });
+            }
+        }
+    }
+    catch {
+        // Skip files we can't read
+    }
+    return traces;
+}
+/**
+ * Recursively find all scannable files in a directory.
+ */
+function findScannableFiles(dir, files = []) {
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            // Skip hidden directories and node_modules
+            if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist') {
+                continue;
+            }
+            const fullPath = join(dir, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                findScannableFiles(fullPath, files);
+            }
+            else if (stat.isFile()) {
+                const ext = extname(entry).toLowerCase();
+                if (SCANNABLE_EXTENSIONS.has(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Skip directories we can't read
+    }
+    return files;
+}
+/**
+ * Execute the trace scan command.
+ *
+ * Scans source files for inline trace markers (// prov:step:xxx)
+ * and creates/updates traces automatically.
+ *
+ * @see req:agent:inline-tracing
+ */
+export function runTraceScan(globalOpts, options) {
+    const projectRoot = globalOpts.dir ?? process.cwd();
+    const fmt = resolveFormat({ format: globalOpts.format });
+    // Check if prov is initialized
+    if (!isInitialized(projectRoot)) {
+        const result = {
+            success: false,
+            error: 'prov is not initialized. Run "prov init" first.',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    // Load graph
+    const loadResult = loadGraph(projectRoot);
+    if (!loadResult.success || loadResult.data === undefined) {
+        const result = {
+            success: false,
+            error: loadResult.error ?? 'Failed to load graph',
+        };
+        if (fmt === 'json') {
+            output(result, { format: 'json' });
+        }
+        else if (fmt === 'yaml') {
+            output(result, { format: 'yaml' });
+        }
+        else {
+            error(result.error);
+        }
+        process.exit(1);
+    }
+    const graph = loadResult.data;
+    // Determine directories to scan
+    const dirsToScan = options.dirs !== undefined && options.dirs.length > 0
+        ? options.dirs.map((d) => resolve(projectRoot, d))
+        : [projectRoot];
+    // Find all scannable files
+    const allFiles = [];
+    for (const dir of dirsToScan) {
+        if (existsSync(dir)) {
+            const files = findScannableFiles(dir);
+            allFiles.push(...files);
+        }
+    }
+    // Scan all files for trace markers
+    const allTraces = [];
+    for (const file of allFiles) {
+        const traces = scanFileForTraces(file, projectRoot);
+        allTraces.push(...traces);
+    }
+    // Group traces by file (we'll create one trace per file-step combination)
+    const tracesByKey = new Map();
+    for (const trace of allTraces) {
+        const key = `${trace.file}:${trace.stepId}`;
+        // Keep the first occurrence (lowest line number)
+        if (!tracesByKey.has(key)) {
+            tracesByKey.set(key, trace);
+        }
+    }
+    // Create/update traces
+    let tracesAdded = 0;
+    let tracesUpdated = 0;
+    for (const trace of tracesByKey.values()) {
+        const fullPath = resolve(projectRoot, trace.file);
+        // Verify step exists
+        const stepNode = graph.getNode(trace.stepId);
+        if (stepNode === undefined || stepNode.type !== 'step') {
+            // Skip traces to non-existent steps
+            continue;
+        }
+        // Compute artifact hash
+        const artifactHash = computeFileHash(fullPath);
+        // Generate trace ID
+        const traceId = generateTraceId(trace.file, trace.stepId);
+        // Check if trace already exists
+        const existingNode = graph.getNode(traceId);
+        if (existingNode !== undefined) {
+            const existingTrace = existingNode.data;
+            if (existingTrace.artifactHash === artifactHash) {
+                // No update needed
+                continue;
+            }
+            // Remove old trace
+            graph.removeNode(traceId);
+            tracesUpdated++;
+        }
+        else {
+            tracesAdded++;
+        }
+        // Create new trace
+        const newTrace = {
+            id: traceId,
+            artifact: {
+                path: trace.file,
+                startLine: trace.line,
+            },
+            step: trace.stepId,
+            artifactHash,
+            createdAt: new Date().toISOString(),
+        };
+        addTraceToGraph(graph, newTrace);
+    }
+    // Save graph if we made changes
+    if (tracesAdded > 0 || tracesUpdated > 0) {
+        const saveResult = saveGraph(graph, projectRoot);
+        if (!saveResult.success) {
+            const result = {
+                success: false,
+                error: saveResult.error ?? 'Failed to save graph',
+            };
+            if (fmt === 'json') {
+                output(result, { format: 'json' });
+            }
+            else if (fmt === 'yaml') {
+                output(result, { format: 'yaml' });
+            }
+            else {
+                error(result.error);
+            }
+            process.exit(1);
+        }
+    }
+    const result = {
+        success: true,
+        scannedFiles: allFiles.length,
+        tracesFound: tracesByKey.size,
+        tracesAdded,
+        tracesUpdated,
+        traces: Array.from(tracesByKey.values()),
+    };
+    if (fmt === 'json') {
+        output(result, { format: 'json' });
+    }
+    else if (fmt === 'yaml') {
+        output(result, { format: 'yaml' });
+    }
+    else {
+        process.stdout.write(`\nTrace Scan Results\n`);
+        process.stdout.write(`${'─'.repeat(40)}\n`);
+        process.stdout.write(`Files scanned: ${allFiles.length}\n`);
+        process.stdout.write(`Traces found:  ${tracesByKey.size}\n`);
+        process.stdout.write(`Traces added:  ${tracesAdded}\n`);
+        process.stdout.write(`Traces updated: ${tracesUpdated}\n`);
+        if (tracesByKey.size > 0) {
+            process.stdout.write(`\nFound traces:\n`);
+            const columns = [
+                { header: 'File', key: 'file', maxWidth: 40 },
+                { header: 'Line', key: 'line', minWidth: 6, align: 'right' },
+                { header: 'Step', key: 'stepId', minWidth: 20 },
+            ];
+            const rows = Array.from(tracesByKey.values()).map((t) => ({
+                file: t.file,
+                line: t.line,
+                stepId: t.stepId,
+            }));
+            output(rows, { format: 'table', columns });
+        }
+        process.stdout.write('\n');
+    }
+}
+//# sourceMappingURL=trace.js.map