progmune-runtime 2.1.5 → 3.2.0

package/dist/precision-label.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Precision Labeling Tool
+ *
+ * Interactive CLI for hand-labeling call sequences as "clean" or "violation".
+ * This is the human-in-the-loop step that makes precision measurement possible.
+ *
+ * Usage:
+ *   npx ts-node src/precision-label.ts <repoPath>
+ *   npx ts-node src/precision-label.ts . --max 50
+ *
+ * Output: .progmune_labels.json in the repo root
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const extract_ir_1 = require("./extract-ir");
+function loadLabels(repoPath) {
+    const labelPath = path.join(repoPath, ".progmune_labels.json");
+    if (fs.existsSync(labelPath)) {
+        return JSON.parse(fs.readFileSync(labelPath, "utf-8"));
+    }
+    return { repo: repoPath, labeledAt: "", total: 0, labels: {}, sequences: {} };
+}
+function saveLabels(repoPath, data) {
+    data.labeledAt = new Date().toISOString();
+    data.total = Object.keys(data.labels).length;
+    const labelPath = path.join(repoPath, ".progmune_labels.json");
+    fs.writeFileSync(labelPath, JSON.stringify(data, null, 2), "utf-8");
+}
+function extractSequences(repoPath) {
+    const ir = (0, extract_ir_1.extractIR)(repoPath);
+    const seqs = [];
+    // Strategy 1: Functions with protocol annotations
+    for (const fn of ir) {
+        if (fn.protocol) {
+            const calls = [];
+            if (fn.protocol.pre_states)
+                calls.push(...fn.protocol.pre_states);
+            calls.push(fn.name);
+            if (fn.protocol.post_states)
+                calls.push(...fn.protocol.post_states);
+            if (calls.length >= 2) {
+                seqs.push({ index: seqs.length, calls, source: `protocol:${fn.name}` });
+            }
+        }
+    }
+    // Strategy 2: Group functions by file, extract call pairs
+    if (seqs.length < 20) {
+        const byFile = {};
+        for (const fn of ir) {
+            const file = fn.file || "unknown";
+            if (!byFile[file])
+                byFile[file] = [];
+            byFile[file].push(fn.name);
+        }
+        for (const [file, fns] of Object.entries(byFile)) {
+            if (fns.length >= 2) {
+                seqs.push({ index: seqs.length, calls: fns.slice(0, 8), source: `file:${path.basename(file)}` });
+            }
+        }
+    }
+    // Strategy 3: Extract call adjacency pairs from function bodies
+    if (seqs.length < 20) {
+        for (const fn of ir) {
+            if (fn.calls && fn.calls.length >= 2) {
+                const relevantCalls = fn.calls.filter((c) => ir.some((f) => f.name === c));
+                if (relevantCalls.length >= 2) {
+                    seqs.push({
+                        index: seqs.length,
+                        calls: relevantCalls.slice(0, 8),
+                        source: `calls:${fn.name}`,
+                    });
+                }
+            }
+        }
+    }
+    return seqs;
+}
+// ═══════════════════════════════════════════════════════════════
+// Interactive CLI
+// ═══════════════════════════════════════════════════════════════
+const C = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+};
+async function main() {
+    const args = process.argv.slice(2);
+    const repoPath = path.resolve(args.find(a => !a.startsWith("--")) || ".");
+    const maxSeq = parseInt(args.includes("--max") ? args[args.indexOf("--max") + 1] : "50", 10);
+    if (!fs.existsSync(repoPath)) {
+        console.error(`❌ Path not found: ${repoPath}`);
+        process.exit(1);
+    }
+    console.error(`\n${C.bold}${C.cyan}Precision Labeling Tool${C.reset}`);
+    console.error(`  Repo: ${repoPath}`);
+    console.error(`  Extracting sequences...`);
+    // 1. Extract sequences
+    const sequences = extractSequences(repoPath).slice(0, maxSeq);
+    if (sequences.length === 0) {
+        console.error(`  ❌ No call sequences found. Add protocol annotations (@protocol) or function calls with 2+ steps.`);
+        process.exit(1);
+    }
+    console.error(`  Found: ${sequences.length} sequences to label`);
+    console.error(`  Commands: ${C.green}c${C.reset}=clean  ${C.red}v${C.reset}=violation  ${C.yellow}s${C.reset}=skip  q=quit\n`);
+    // 2. Load existing labels
+    const data = loadLabels(repoPath);
+    const alreadyLabeled = Object.keys(data.labels).length;
+    if (alreadyLabeled > 0) {
+        console.error(`  ${C.yellow}Resuming: ${alreadyLabeled} already labeled${C.reset}\n`);
+    }
+    // 3. Interactive labeling loop
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    let labeled = 0;
+    let skipped = 0;
+    for (const seq of sequences) {
+        // Skip already labeled
+        if (data.labels[seq.index] !== undefined)
+            continue;
+        // Show sequence
+        console.error(`${C.bold}[${seq.index + 1}/${sequences.length}]${C.reset} ${C.dim}${seq.source}${C.reset}`);
+        console.error(`  ${seq.calls.map((c, i) => `${i > 0 ? "→ " : ""}${C.cyan}${c}${C.reset}`).join(" ")}`);
+        const answer = await ask(`  ${C.green}[c]lean${C.reset} ${C.red}[v]iolation${C.reset} ${C.yellow}[s]kip${C.reset} [q]uit: `);
+        if (answer === "q") {
+            console.error(`\n  Quit. Saving ${labeled} new labels...`);
+            break;
+        }
+        if (answer === "s") {
+            skipped++;
+            console.error(`  ${C.yellow}↻ skipped${C.reset}\n`);
+            continue;
+        }
+        if (answer === "c") {
+            data.labels[seq.index] = "clean";
+            data.sequences[seq.index] = seq.calls;
+            labeled++;
+            console.error(`  ${C.green}✓ clean${C.reset}\n`);
+        }
+        else if (answer === "v") {
+            data.labels[seq.index] = "violation";
+            data.sequences[seq.index] = seq.calls;
+            labeled++;
+            console.error(`  ${C.red}✗ violation${C.reset}\n`);
+        }
+        else {
+            console.error(`  ${C.yellow}? unknown — use c/v/s/q${C.reset}\n`);
+        }
+    }
+    rl.close();
+    // 4. Save
+    saveLabels(repoPath, data);
+    console.error(`\n${C.bold}Saved:${C.reset} ${labeled} new + ${alreadyLabeled} existing labels → ${path.join(repoPath, ".progmune_labels.json")}`);
+    console.error(`  Clean:     ${Object.values(data.labels).filter(l => l === "clean").length}`);
+    console.error(`  Violation: ${Object.values(data.labels).filter(l => l === "violation").length}`);
+    console.error(`  Skipped:   ${skipped}`);
+    console.error(`\n  Next: npx ts-node src/precision-report.ts ${repoPath}\n`);
+}
+main().catch(e => { console.error(e); process.exit(1); });

package/dist/precision-report-c.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Precision Report Generator for C/C++ projects
+ *
+ * Reads labeled data and runs SSG precision measurement.
+ *
+ * Usage:
+ *   npx ts-node src/precision-report-c.ts benchmarks/curl
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ssg_precision_1 = require("./ssg-precision");
+const C = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+};
+function main() {
+    const args = process.argv.slice(2);
+    const repoPath = path.resolve(args.find(a => !a.startsWith("--")) || ".");
+    // Labels stored in benchmarks/ directory, not inside the repo
+    const labelFile = path.join(path.dirname(repoPath), `${path.basename(repoPath)}-labels.json`);
+    if (!fs.existsSync(labelFile)) {
+        // Fallback: try inside the repo directory
+        const altFile = path.join(repoPath, `${path.basename(repoPath)}-labels.json`);
+        if (fs.existsSync(altFile))
+            return altFile;
+    }
+    if (!fs.existsSync(labelFile)) {
+        console.error(`❌ Labels not found: ${labelFile}`);
+        console.error(`   Run: npx ts-node src/precision-label-c.ts ${repoPath}`);
+        process.exit(1);
+    }
+    const data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    const labels = data.labels || {};
+    const sequences = data.sequences || {};
+    const labeledIndices = Object.keys(labels).map(Number);
+    if (labeledIndices.length === 0) {
+        console.error("❌ No labeled sequences found.");
+        process.exit(1);
+    }
+    // Build clean sequences for rule discovery
+    const cleanSeqs = [];
+    for (const idx of labeledIndices) {
+        if (labels[idx] === "clean" && sequences[idx]) {
+            cleanSeqs.push(sequences[idx]);
+        }
+    }
+    if (cleanSeqs.length === 0) {
+        console.error("❌ No clean sequences for rule discovery. Label some sequences as 'clean' first.");
+        process.exit(1);
+    }
+    // Discover SSG rules
+    const { rules, nsInit } = (0, ssg_precision_1.discoverRulesFromSequences)(cleanSeqs);
+    // Validate all labeled sequences
+    let tp = 0, fp = 0, tn = 0, fn = 0;
+    const details = [];
+    for (const idx of labeledIndices) {
+        const expected = labels[idx];
+        const calls = sequences[idx] || [];
+        const result = (0, ssg_precision_1.validateSequenceWithSSG)(calls, rules, nsInit);
+        const detected = result.valid ? "clean" : "violation";
+        if (expected === "violation" && detected === "violation")
+            tp++;
+        else if (expected === "clean" && detected === "violation")
+            fp++;
+        else if (expected === "clean" && detected === "clean")
+            tn++;
+        else if (expected === "violation" && detected === "clean")
+            fn++;
+        if (expected !== detected) {
+            details.push({
+                index: idx,
+                expected, detected,
+                reason: result.reason || "",
+                calls: calls.slice(0, 6),
+            });
+        }
+    }
+    const total = tp + fp + tn + fn;
+    const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+    const recall = tp + fn > 0 ? tp / (tp + fn) : 0;
+    const f1 = precision + recall > 0 ? 2 * precision * recall / (precision + recall) : 0;
+    // Print report
+    const pct = (v) => `${(v * 100).toFixed(0)}%`;
+    const color = (v) => v >= 0.7 ? C.green : v >= 0.5 ? C.yellow : C.red;
+    console.log(`\n${C.bold}${C.cyan}╔══════════════════════════════════════════════╗${C.reset}`);
+    console.log(`${C.bold}${C.cyan}║${C.reset}  ${C.bold}SSG Precision Report — curl${C.reset}                          ${C.bold}${C.cyan}║${C.reset}`);
+    console.log(`${C.bold}${C.cyan}╚══════════════════════════════════════════════╝${C.reset}`);
+    console.log("");
+    console.log(`  Samples:    ${total}`);
+    console.log(`  Rules:      ${rules.size} discovered from ${cleanSeqs.length} clean sequences`);
+    console.log(`  TP: ${C.green}${tp}${C.reset}  FP: ${C.red}${fp}${C.reset}  TN: ${C.green}${tn}${C.reset}  FN: ${C.red}${fn}${C.reset}`);
+    console.log("");
+    console.log(`  Precision:  ${color(precision)}${pct(precision)}${C.reset}`);
+    console.log(`  Recall:     ${color(recall)}${pct(recall)}${C.reset}`);
+    console.log(`  F1:         ${color(f1)}${pct(f1)}${C.reset}`);
+    console.log("");
+    if (details.length > 0) {
+        console.log(`  ${C.yellow}Mismatches (${details.length}):${C.reset}`);
+        for (const d of details.slice(0, 10)) {
+            const icon = d.expected === "violation" ? `${C.red}FN${C.reset}` : `${C.yellow}FP${C.reset}`;
+            console.log(`    ${icon} [${d.index}] expected ${d.expected}, got ${d.detected}`);
+            console.log(`       ${C.dim}${d.calls.join(" → ")}${C.reset}`);
+        }
+        console.log("");
+    }
+    const rating = f1 >= 0.85 ? `${C.green}EXCELLENT${C.reset}` : f1 >= 0.7 ? `${C.yellow}GOOD${C.reset}` : f1 >= 0.5 ? `${C.yellow}FAIR${C.reset}` : `${C.red}NEEDS IMPROVEMENT${C.reset}`;
+    console.log(`  Rating: ${rating}`);
+    // Save
+    const report = { repo: "curl", total, tp, fp, tn, fn, precision, recall, f1, rulesDiscovered: rules.size, timestamp: new Date().toISOString(), details };
+    const reportPath = path.join(path.dirname(repoPath), `${path.basename(repoPath)}-precision.json`);
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+    console.log(`\n📁 Saved: ${reportPath}\n`);
+}
+main();

package/dist/precision-report.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Precision Report Generator
+ *
+ * Takes hand-labeled ground truth + SSG validation results,
+ * generates TP/FP/TN/FN matrix with precision/recall/F1.
+ *
+ * Usage:
+ *   npx ts-node src/precision-report.ts <repoPath>
+ *   npx ts-node src/precision-report.ts . --output precision.md
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrecision = runPrecision;
+exports.formatPrecisionTerminal = formatPrecisionTerminal;
+exports.formatPrecisionMarkdown = formatPrecisionMarkdown;
+exports.formatMultiRepoTable = formatMultiRepoTable;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ssg_precision_1 = require("./ssg-precision");
+function loadLabels(repoPath) {
+    const labelPath = path.join(repoPath, ".progmune_labels.json");
+    if (!fs.existsSync(labelPath)) {
+        throw new Error(`No labels found. Run 'npx ts-node src/precision-label.ts ${repoPath}' first.`);
+    }
+    const data = JSON.parse(fs.readFileSync(labelPath, "utf-8"));
+    return { labels: data.labels || {}, sequences: data.sequences || {} };
+}
+function runPrecision(repoPath) {
+    const { labels, sequences } = loadLabels(repoPath);
+    // Get all labeled sequences
+    const labeledIndices = Object.keys(labels).map(Number);
+    if (labeledIndices.length === 0) {
+        throw new Error("No labeled sequences found.");
+    }
+    // Build clean-labeled sequences for rule discovery
+    const cleanSeqs = [];
+    for (const idx of labeledIndices) {
+        if (labels[idx] === "clean" && sequences[idx]) {
+            cleanSeqs.push(sequences[idx]);
+        }
+    }
+    // Discover rules from clean sequences
+    const { rules, nsInit } = (0, ssg_precision_1.discoverRulesFromSequences)(cleanSeqs);
+    // Validate all labeled sequences against discovered rules
+    const matrix = {
+        repo: path.basename(repoPath),
+        total: labeledIndices.length,
+        truePositive: 0,
+        falsePositive: 0,
+        trueNegative: 0,
+        falseNegative: 0,
+        precision: 0,
+        recall: 0,
+        f1: 0,
+        details: [],
+    };
+    for (const idx of labeledIndices) {
+        const expected = labels[idx];
+        const calls = sequences[idx] || [];
+        if (rules.size === 0) {
+            // No rules discovered — all sequences pass (can't detect anything)
+            const detected = "clean";
+            matrix.details.push({ index: idx, calls, expected, detected, correct: expected === detected });
+            if (expected === "clean" && detected === "clean")
+                matrix.trueNegative++;
+            else if (expected === "violation" && detected === "clean")
+                matrix.falseNegative++;
+            continue;
+        }
+        const result = (0, ssg_precision_1.validateSequenceWithSSG)(calls, rules, nsInit);
+        const detected = result.valid ? "clean" : "violation";
+        matrix.details.push({ index: idx, calls, expected, detected, correct: expected === detected });
+        if (expected === "violation" && detected === "violation")
+            matrix.truePositive++;
+        else if (expected === "clean" && detected === "violation")
+            matrix.falsePositive++;
+        else if (expected === "clean" && detected === "clean")
+            matrix.trueNegative++;
+        else if (expected === "violation" && detected === "clean")
+            matrix.falseNegative++;
+    }
+    // Compute metrics
+    const tp = matrix.truePositive;
+    const fp = matrix.falsePositive;
+    const fn = matrix.falseNegative;
+    matrix.precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+    matrix.recall = tp + fn > 0 ? tp / (tp + fn) : 0;
+    matrix.f1 = matrix.precision + matrix.recall > 0
+        ? 2 * (matrix.precision * matrix.recall) / (matrix.precision + matrix.recall)
+        : 0;
+    return matrix;
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatters
+// ═══════════════════════════════════════════════════════════════
+const C = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+};
+function formatPrecisionTerminal(m) {
+    const pct = (v) => `${(v * 100).toFixed(0)}%`;
+    const color = (v, threshold = 0.7) => v >= threshold ? C.green : v >= 0.5 ? C.yellow : C.red;
+    const lines = [];
+    lines.push("");
+    lines.push(`${C.bold}${C.cyan}╔══════════════════════════════════════════════╗${C.reset}`);
+    lines.push(`${C.bold}${C.cyan}║${C.reset}  ${C.bold}SSG Precision Report — ${m.repo}${C.reset}${" ".repeat(Math.max(0, 25 - m.repo.length))}${C.bold}${C.cyan}║${C.reset}`);
+    lines.push(`${C.bold}${C.cyan}╚══════════════════════════════════════════════╝${C.reset}`);
+    lines.push("");
+    lines.push(`  Samples:   ${m.total}`);
+    lines.push(`  TP: ${C.green}${m.truePositive}${C.reset}  FP: ${C.red}${m.falsePositive}${C.reset}  TN: ${C.green}${m.trueNegative}${C.reset}  FN: ${C.red}${m.falseNegative}${C.reset}`);
+    lines.push("");
+    lines.push(`  Precision: ${color(m.precision)}${pct(m.precision)}${C.reset}`);
+    lines.push(`  Recall:    ${color(m.recall)}${pct(m.recall)}${C.reset}`);
+    lines.push(`  F1:        ${color(m.f1)}${pct(m.f1)}${C.reset}`);
+    lines.push("");
+    // Mismatches
+    const mismatches = m.details.filter(d => !d.correct);
+    if (mismatches.length > 0) {
+        lines.push(`  ${C.yellow}Mismatches (${mismatches.length}):${C.reset}`);
+        for (const d of mismatches.slice(0, 10)) {
+            const icon = d.expected === "violation" ? `${C.red}FN${C.reset}` : `${C.yellow}FP${C.reset}`;
+            lines.push(`    ${icon} [${d.index}] expected ${d.expected}, got ${d.detected}`);
+            lines.push(`       ${C.dim}${d.calls.join(" → ")}${C.reset}`);
+        }
+        lines.push("");
+    }
+    // Rating
+    const rating = m.f1 >= 0.85 ? `${C.green}EXCELLENT${C.reset}`
+        : m.f1 >= 0.7 ? `${C.yellow}GOOD${C.reset}`
+            : m.f1 >= 0.5 ? `${C.yellow}FAIR${C.reset}`
+                : `${C.red}NEEDS IMPROVEMENT${C.reset}`;
+    lines.push(`  Rating: ${rating}`);
+    lines.push("");
+    return lines.join("\n");
+}
+function formatPrecisionMarkdown(m) {
+    const pct = (v) => `${(v * 100).toFixed(0)}%`;
+    const lines = [];
+    lines.push(`# SSG Precision Report — ${m.repo}`);
+    lines.push("");
+    lines.push(`| Metric | Value |`);
+    lines.push(`|--------|-------|`);
+    lines.push(`| Samples | ${m.total} |`);
+    lines.push(`| True Positive | ${m.truePositive} |`);
+    lines.push(`| False Positive | ${m.falsePositive} |`);
+    lines.push(`| True Negative | ${m.trueNegative} |`);
+    lines.push(`| False Negative | ${m.falseNegative} |`);
+    lines.push(`| **Precision** | **${pct(m.precision)}** |`);
+    lines.push(`| **Recall** | **${pct(m.recall)}** |`);
+    lines.push(`| **F1** | **${pct(m.f1)}** |`);
+    lines.push("");
+    const mismatches = m.details.filter(d => !d.correct);
+    if (mismatches.length > 0) {
+        lines.push("## Mismatches");
+        lines.push("");
+        lines.push(`| # | Expected | Detected | Sequence |`);
+        lines.push(`|---|----------|----------|----------|`);
+        for (const d of mismatches) {
+            lines.push(`| ${d.index} | ${d.expected} | ${d.detected} | \`${d.calls.join(" → ")}\` |`);
+        }
+        lines.push("");
+    }
+    const rating = m.f1 >= 0.85 ? "🟢 EXCELLENT"
+        : m.f1 >= 0.7 ? "🟡 GOOD"
+            : m.f1 >= 0.5 ? "🟠 FAIR"
+                : "🔴 NEEDS IMPROVEMENT";
+    lines.push(`**Rating:** ${rating}`);
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// Multi-Repo Aggregation
+// ═══════════════════════════════════════════════════════════════
+function formatMultiRepoTable(matrices) {
+    const pct = (v) => `${(v * 100).toFixed(0)}%`;
+    const lines = [];
+    lines.push("");
+    lines.push(`${C.bold}${C.cyan}Multi-Repo Precision Summary${C.reset}`);
+    lines.push("");
+    lines.push(`  ${C.dim}Repo          Samples  TP   FP   TN   FN   Precision  Recall  F1     Rating${C.reset}`);
+    lines.push(`  ${C.dim}────────────  ───────  ───  ───  ───  ───  ─────────  ──────  ─────  ──────${C.reset}`);
+    for (const m of matrices) {
+        const rating = m.f1 >= 0.85 ? `${C.green}★★★★${C.reset}`
+            : m.f1 >= 0.7 ? `${C.yellow}★★★${C.reset}`
+                : m.f1 >= 0.5 ? `${C.yellow}★★${C.reset}`
+                    : `${C.red}★${C.reset}`;
+        lines.push(`  ${m.repo.padEnd(12)}  ${String(m.total).padEnd(7)}  ${String(m.truePositive).padEnd(3)}  ${String(m.falsePositive).padEnd(3)}  ${String(m.trueNegative).padEnd(3)}  ${String(m.falseNegative).padEnd(3)}  ${pct(m.precision).padEnd(9)}  ${pct(m.recall).padEnd(6)}  ${pct(m.f1).padEnd(5)}  ${rating}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const repoPath = path.resolve(args.find(a => !a.startsWith("--")) || ".");
+    const outputIdx = args.indexOf("--output");
+    const outputPath = outputIdx >= 0 ? args[outputIdx + 1] : undefined;
+    try {
+        const matrix = runPrecision(repoPath);
+        console.log(formatPrecisionTerminal(matrix));
+        if (outputPath) {
+            const md = formatPrecisionMarkdown(matrix);
+            fs.writeFileSync(outputPath, md, "utf-8");
+            console.error(`📁 Report: ${outputPath}`);
+        }
+    }
+    catch (e) {
+        console.error(`\n${C.red}❌ ${e.message}${C.reset}\n`);
+        process.exit(1);
+    }
+}