@weldr/runr 0.4.0 → 0.7.2

package/dist/commands/audit.js

@@ -0,0 +1,259 @@
+/**
+ * runr audit - View project history classified by provenance
+ *
+ * Shows the timeline of commits classified as:
+ * - CHECKPOINT: Runr checkpoint commits with receipts
+ * - INTERVENTION: Manual work recorded via runr intervene
+ * - ATTRIBUTED: Has Runr trailers but no receipt
+ * - GAP: No Runr attribution (audit gap)
+ *
+ * Usage:
+ *   runr audit                           # Last 50 commits on current branch
+ *   runr audit --range main~80..main     # Custom range
+ *   runr audit --run <run_id>            # Commits for specific run
+ *   runr audit --json                    # JSON output
+ */
+import { execSync } from 'node:child_process';
+import { parseGitLog, classifyCommits, generateSummary, formatClassification, getClassificationIcon } from '../audit/classifier.js';
+/**
+ * Get the default branch for range.
+ */
+function getDefaultBranch(repoPath) {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd: repoPath,
+            encoding: 'utf-8'
+        }).trim();
+    }
+    catch {
+        return 'main';
+    }
+}
+/**
+ * Build the git range string.
+ */
+function buildRange(options) {
+    if (options.range) {
+        return options.range;
+    }
+    const branch = getDefaultBranch(options.repo);
+    const limit = options.limit || 50;
+    return `${branch}~${limit}..${branch}`;
+}
+/**
+ * Print table of classified commits.
+ */
+function printTable(commits) {
+    // Column headers
+    const headers = ['', 'SHA', 'TYPE', 'RUN ID', 'SUBJECT'];
+    // Calculate column widths (fixed for readability)
+    const widths = [2, 7, 12, 14, 50];
+    // Print header
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    console.log(headerLine);
+    console.log('-'.repeat(headerLine.length));
+    // Print rows (most recent first)
+    for (const commit of commits) {
+        const icon = getClassificationIcon(commit.classification);
+        const type = formatClassification(commit.classification);
+        const runId = commit.runId || '-';
+        const subject = commit.subject.length > widths[4]
+            ? commit.subject.slice(0, widths[4] - 3) + '...'
+            : commit.subject;
+        const row = [
+            icon.padEnd(widths[0]),
+            commit.shortSha.padEnd(widths[1]),
+            type.padEnd(widths[2]),
+            runId.padEnd(widths[3]),
+            subject.padEnd(widths[4])
+        ];
+        console.log(row.join('  '));
+    }
+}
+/**
+ * Print summary section.
+ */
+function printSummary(summary, strict = false) {
+    const { counts, gaps, runsReferenced, explicitCoverage, inferredCoverage, fullCoverage } = summary;
+    console.log('');
+    console.log('Summary');
+    console.log('-------');
+    console.log(`Total commits: ${counts.total}`);
+    console.log(`  ✓ Checkpoints:    ${counts.runr_checkpoint}`);
+    console.log(`  ⚡ Interventions:  ${counts.runr_intervention}`);
+    console.log(`  ~ Inferred:       ${counts.runr_inferred}`);
+    console.log(`  ○ Attributed:     ${counts.manual_attributed}`);
+    console.log(`  ? Gaps:           ${counts.gap}`);
+    if (runsReferenced.length > 0) {
+        console.log('');
+        console.log(`Runs referenced: ${runsReferenced.length}`);
+        const displayRuns = runsReferenced.slice(0, 5);
+        for (const runId of displayRuns) {
+            console.log(`  ${runId}`);
+        }
+        if (runsReferenced.length > 5) {
+            console.log(`  ...${runsReferenced.length - 5} more`);
+        }
+    }
+    // Audit health indicator with coverage numbers
+    console.log('');
+    // Show coverage differently based on strict mode
+    const coverageDisplay = strict
+        ? `${explicitCoverage}% coverage (strict mode)`
+        : `${explicitCoverage}% (explicit) / ${inferredCoverage}% (with inferred)`;
+    if (gaps.length === 0) {
+        console.log(`Audit status: ✓ CLEAN (${coverageDisplay})`);
+    }
+    else if (gaps.length <= 3) {
+        console.log(`Audit status: ⚠ ${gaps.length} gap${gaps.length === 1 ? '' : 's'} (${coverageDisplay})`);
+    }
+    else {
+        console.log(`Audit status: ✗ ${gaps.length} gaps (${coverageDisplay})`);
+    }
+    // Show top gaps if any
+    if (gaps.length > 0) {
+        console.log('');
+        const gapLabel = strict ? 'Top gaps (unattributed commits + inferred):' : 'Top gaps (unattributed commits):';
+        console.log(gapLabel);
+        const displayGaps = gaps.slice(0, 5);
+        for (const gap of displayGaps) {
+            console.log(`  ${gap.shortSha} ${gap.subject.slice(0, 50)}`);
+        }
+        if (gaps.length > 5) {
+            console.log(`  ...${gaps.length - 5} more`);
+        }
+    }
+}
+/**
+ * Print coverage report in human-readable format.
+ */
+function printCoverageReport(summary, options) {
+    const { counts, explicitCoverage, inferredCoverage, fullCoverage } = summary;
+    const explicitCount = counts.runr_checkpoint + counts.runr_intervention;
+    const inferredCount = explicitCount + counts.runr_inferred;
+    const fullCount = inferredCount + counts.manual_attributed;
+    console.log('Coverage Report');
+    console.log('---------------');
+    console.log(`Explicit coverage:      ${explicitCoverage}% (${explicitCount}/${counts.total})`);
+    console.log(`With inferred:          ${inferredCoverage}% (${inferredCount}/${counts.total})`);
+    console.log(`Full (with attributed): ${fullCoverage}% (${fullCount}/${counts.total})`);
+    // Show threshold status if specified
+    if (options.failUnder !== undefined || options.failUnderWithInferred !== undefined) {
+        console.log('');
+        if (options.failUnder !== undefined) {
+            const status = explicitCoverage >= options.failUnder ? 'PASS' : 'FAIL';
+            console.log(`Threshold: ${options.failUnder}% (explicit)`);
+            console.log(`Status: ${status} (explicit coverage ${explicitCoverage}% ${status === 'PASS' ? '>=' : '<'} ${options.failUnder}%)`);
+        }
+        if (options.failUnderWithInferred !== undefined) {
+            const status = inferredCoverage >= options.failUnderWithInferred ? 'PASS' : 'FAIL';
+            console.log(`Threshold: ${options.failUnderWithInferred}% (with inferred)`);
+            console.log(`Status: ${status} (inferred coverage ${inferredCoverage}% ${status === 'PASS' ? '>=' : '<'} ${options.failUnderWithInferred}%)`);
+        }
+    }
+}
+/**
+ * Generate coverage JSON report.
+ */
+function generateCoverageJson(summary) {
+    const { counts, gaps, runsReferenced, explicitCoverage, inferredCoverage, fullCoverage } = summary;
+    return {
+        range: summary.range,
+        timestamp: new Date().toISOString(),
+        total_commits: counts.total,
+        classifications: {
+            runr_checkpoint: counts.runr_checkpoint,
+            runr_intervention: counts.runr_intervention,
+            runr_inferred: counts.runr_inferred,
+            manual_attributed: counts.manual_attributed,
+            gap: counts.gap
+        },
+        coverage: {
+            explicit: explicitCoverage / 100,
+            with_inferred: inferredCoverage / 100,
+            with_attributed: fullCoverage / 100
+        },
+        gaps: gaps.map(g => ({ sha: g.sha, subject: g.subject })),
+        runs_referenced: runsReferenced
+    };
+}
+/**
+ * Filter commits for a specific run.
+ */
+function filterByRun(commits, runId) {
+    return commits.filter(c => c.runId === runId);
+}
+/**
+ * Audit command: View project history by provenance.
+ */
+export async function auditCommand(options) {
+    const range = buildRange(options);
+    // Parse git log
+    let commits = parseGitLog(options.repo, range);
+    if (commits.length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: 'no_commits', range }, null, 2));
+        }
+        else {
+            console.log(`No commits found in range: ${range}`);
+        }
+        return;
+    }
+    // Classify commits
+    commits = classifyCommits(commits, options.repo);
+    // Filter by run if specified
+    if (options.runId) {
+        commits = filterByRun(commits, options.runId);
+        if (commits.length === 0) {
+            if (options.json) {
+                console.log(JSON.stringify({ error: 'no_commits_for_run', runId: options.runId }, null, 2));
+            }
+            else {
+                console.log(`No commits found for run: ${options.runId}`);
+            }
+            return;
+        }
+    }
+    // Generate summary (strict mode treats inferred as gaps)
+    const summary = generateSummary(commits, range, options.strict);
+    // Output
+    if (options.coverage) {
+        // Coverage report mode
+        if (options.json) {
+            console.log(JSON.stringify(generateCoverageJson(summary), null, 2));
+        }
+        else {
+            console.log(`Audit: ${range}`);
+            console.log('');
+            printCoverageReport(summary, options);
+            console.log('');
+        }
+    }
+    else if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+    }
+    else {
+        console.log(`Audit: ${range}`);
+        if (options.runId) {
+            console.log(`Filtered by run: ${options.runId}`);
+        }
+        if (options.strict) {
+            console.log('(strict mode: inferred attribution treated as gaps)');
+        }
+        console.log('');
+        printTable(commits);
+        printSummary(summary, options.strict);
+        console.log('');
+    }
+    // Check threshold and set exit code if specified
+    if (options.failUnder !== undefined) {
+        if (summary.explicitCoverage < options.failUnder) {
+            process.exitCode = 1;
+        }
+    }
+    if (options.failUnderWithInferred !== undefined) {
+        if (summary.inferredCoverage < options.failUnderWithInferred) {
+            process.exitCode = 1;
+        }
+    }
+}

package/dist/commands/bundle.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execa } from 'execa';
+import { RunStore } from '../store/run-store.js';
+/**
+ * Get verification status display from run state.
+ */
+function getVerificationStatus(state) {
+    const evidence = state.last_verification_evidence;
+    if (!evidence) {
+        return {
+            status: 'UNVERIFIED',
+            tier: 'none',
+            commands: 'none',
+            resultLine: '⚠ UNVERIFIED'
+        };
+    }
+    const tier = evidence.tiers_run?.[0] || 'none';
+    const commands = evidence.commands_run?.map(c => c.command).join(', ') || 'none';
+    // If evidence exists, assume PASSED (adjust if you track explicit pass/fail)
+    return {
+        status: 'PASSED',
+        tier,
+        commands,
+        resultLine: '✓ PASSED'
+    };
+}
+/**
+ * Render milestone checklist.
+ */
+function renderMilestones(state) {
+    const milestones = state.milestones || [];
+    const currentIndex = state.milestone_index ?? -1;
+    const completed = currentIndex >= 0 ? Math.min(currentIndex + 1, milestones.length) : 0;
+    const total = milestones.length;
+    const lines = [];
+    lines.push(`## Milestones (${completed}/${total})`);
+    if (milestones.length === 0) {
+        lines.push('- (none)');
+    }
+    else {
+        for (let i = 0; i < milestones.length; i++) {
+            const goal = milestones[i]?.goal || '';
+            const checked = i <= currentIndex ? 'x' : ' ';
+            lines.push(`- [${checked}] M${i}: ${goal}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Get git diffstat for checkpoint.
+ */
+async function getCheckpointDiffstat(repoPath, sha) {
+    try {
+        const result = await execa('git', ['show', '--stat', '--oneline', '--no-color', sha], {
+            cwd: repoPath
+        });
+        return result.stdout.trim();
+    }
+    catch {
+        return `Error: unable to compute git stat for checkpoint ${sha}`;
+    }
+}
+/**
+ * Get timeline event summary (all event types, sorted alphabetically).
+ */
+async function getTimelineSummary(runDir) {
+    const timelinePath = path.join(runDir, 'timeline.jsonl');
+    try {
+        const content = await fs.readFile(timelinePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        const counts = new Map();
+        for (const line of lines) {
+            try {
+                const event = JSON.parse(line);
+                if (event.type) {
+                    counts.set(event.type, (counts.get(event.type) ?? 0) + 1);
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        // Deterministic: all event types, sorted alphabetically
+        return [...counts.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([type, count]) => `- ${type}: ${count}`);
+    }
+    catch {
+        return ['- (none)'];
+    }
+}
+/**
+ * Check if artifact file exists.
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Bundle command: Generate deterministic markdown evidence packet.
+ */
+export async function bundleCommand(options) {
+    const runStore = RunStore.init(options.runId, options.repo);
+    let state;
+    try {
+        state = runStore.readState();
+    }
+    catch {
+        console.error(`Error: run state not found for ${options.runId}`);
+        process.exitCode = 1;
+        return;
+    }
+    const checkpoint = state.checkpoint_commit_sha || 'none';
+    const created = state.started_at || '';
+    const phase = state.phase || '';
+    const stopReason = state.stop_reason || '';
+    const verification = getVerificationStatus(state);
+    const milestoneLines = renderMilestones(state);
+    // Get checkpoint diffstat
+    let diffstat = 'none';
+    if (checkpoint !== 'none') {
+        diffstat = await getCheckpointDiffstat(options.repo, checkpoint);
+    }
+    // Get timeline summary
+    const timelineLines = await getTimelineSummary(runStore.path);
+    // Artifact paths (relative, no absolute paths)
+    const artifacts = [
+        `- Timeline: .runr/runs/${options.runId}/timeline.jsonl`,
+        `- Journal: .runr/runs/${options.runId}/journal.md`,
+        `- State: .runr/runs/${options.runId}/state.json`
+    ];
+    // Check if review digest exists
+    const reviewPath = path.join(runStore.path, 'review_digest.md');
+    if (await fileExists(reviewPath)) {
+        artifacts.push(`- Review: .runr/runs/${options.runId}/review_digest.md`);
+    }
+    // Build output (deterministic markdown)
+    const lines = [
+        `# Run ${options.runId}`,
+        '',
+        `**Created:** ${created}`,
+        `**Checkpoint:** ${checkpoint}`,
+        `**Status:** ${phase}${stopReason ? ` (${stopReason})` : ''}`,
+        '',
+        ...milestoneLines,
+        '',
+        '## Verification Evidence',
+        `**Status:** ${verification.status}`,
+        `**Tier:** ${verification.tier}`,
+        `**Commands:** ${verification.commands}`,
+        `**Result:** ${verification.resultLine}`,
+        '',
+        '## Checkpoint Diffstat',
+        diffstat,
+        '',
+        '## Timeline Event Summary',
+        ...timelineLines,
+        '',
+        '## Artifacts',
+        ...artifacts,
+        '',
+        '---',
+        '🤖 Generated with Runr'
+    ];
+    const output = lines.join('\n');
+    // Write to file or stdout
+    if (options.output) {
+        await fs.writeFile(options.output, output, 'utf-8');
+        console.log(`Wrote bundle to ${options.output}`);
+    }
+    else {
+        console.log(output);
+    }
+}