@kevinrabun/judges-cli 3.124.0

package/dist/commands/finding-remediation-plan.js

@@ -0,0 +1,107 @@
+/**
+ * Finding-remediation-plan — Generate remediation plans for findings.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function estimateEffort(severity) {
+    switch (severity.toLowerCase()) {
+        case "critical":
+            return "immediate";
+        case "high":
+            return "1-2 days";
+        case "medium":
+            return "3-5 days";
+        case "low":
+            return "backlog";
+        default:
+            return "unknown";
+    }
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingRemediationPlan(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-remediation-plan — Generate remediation plans
+
+Usage:
+  judges finding-remediation-plan --file results.json
+  judges finding-remediation-plan --file results.json --min-severity high
+
+Options:
+  --file <path>         Path to review result JSON
+  --min-severity <s>    Minimum severity to include (critical, high, medium, low)
+  --format json         JSON output
+  --help, -h            Show this help
+
+Generates a prioritized remediation plan from review findings.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const filePath = argv.find((_a, i) => argv[i - 1] === "--file") || "";
+    const minSeverity = argv.find((_a, i) => argv[i - 1] === "--min-severity") || "";
+    if (!filePath) {
+        console.log("Specify --file <path> to a review result JSON.");
+        return;
+    }
+    if (!existsSync(filePath)) {
+        console.log(`File not found: ${filePath}`);
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        console.log(`Failed to parse: ${filePath}`);
+        return;
+    }
+    const findings = Array.isArray(data.findings) ? data.findings : [];
+    const severityOrder = ["critical", "high", "medium", "low", "info"];
+    const minIdx = minSeverity ? severityOrder.indexOf(minSeverity.toLowerCase()) : severityOrder.length - 1;
+    const items = [];
+    for (const f of findings) {
+        if (typeof f !== "object" || !f)
+            continue;
+        const record = f;
+        const severity = typeof record.severity === "string" ? record.severity.toLowerCase() : "medium";
+        const sevIdx = severityOrder.indexOf(severity);
+        if (sevIdx > minIdx)
+            continue;
+        items.push({
+            ruleId: typeof record.ruleId === "string" ? record.ruleId : "",
+            severity,
+            title: typeof record.title === "string" ? record.title : "",
+            recommendation: typeof record.recommendation === "string" ? record.recommendation : "",
+            effort: estimateEffort(severity),
+        });
+    }
+    // Sort by severity
+    items.sort((a, b) => severityOrder.indexOf(a.severity) - severityOrder.indexOf(b.severity));
+    if (format === "json") {
+        console.log(JSON.stringify({ totalFindings: findings.length, planItems: items.length, items }, null, 2));
+        return;
+    }
+    if (items.length === 0) {
+        console.log("No findings match the criteria.");
+        return;
+    }
+    console.log("\nRemediation Plan:");
+    console.log("═".repeat(65));
+    let phase = 0;
+    let lastSeverity = "";
+    for (const item of items) {
+        if (item.severity !== lastSeverity) {
+            phase++;
+            lastSeverity = item.severity;
+            console.log(`\n  Phase ${phase}: ${item.severity.toUpperCase()} (${item.effort})`);
+            console.log("  " + "─".repeat(50));
+        }
+        console.log(`    ${item.ruleId}: ${item.title}`);
+        if (item.recommendation) {
+            console.log(`      → ${item.recommendation.slice(0, 80)}`);
+        }
+    }
+    console.log("\n═".repeat(65));
+    console.log(`${items.length} items across ${phase} phases.`);
+}

package/dist/commands/finding-reopen-detect.d.ts

@@ -0,0 +1 @@
+export declare function runFindingReopenDetect(argv: string[]): void;

package/dist/commands/finding-reopen-detect.js

@@ -0,0 +1,77 @@
+import { readFileSync, existsSync, writeFileSync } from "fs";
+import { join } from "path";
+function detectReopened(findings, suppressions) {
+    const suppressionMap = new Map();
+    for (const s of suppressions) {
+        suppressionMap.set(`${s.ruleId}::${s.title}`, s);
+    }
+    const reopened = [];
+    for (const f of findings) {
+        const key = `${f.ruleId}::${f.title}`;
+        const match = suppressionMap.get(key);
+        if (match) {
+            reopened.push({
+                ruleId: f.ruleId,
+                title: f.title,
+                severity: f.severity,
+                suppressedAt: match.suppressedAt,
+                recommendation: "Previously resolved — investigate regression",
+            });
+        }
+    }
+    return reopened;
+}
+export function runFindingReopenDetect(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-reopen-detect [options]
+
+Detect findings that reappear after suppression.
+
+Options:
+  --report <path>        Path to verdict JSON file
+  --suppressions <path>  Path to suppressions ledger JSON
+  --format <fmt>         Output format: table (default) or json
+  -h, --help             Show this help message`);
+        return;
+    }
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx !== -1 && argv[formatIdx + 1] ? argv[formatIdx + 1] : "table";
+    const reportIdx = argv.indexOf("--report");
+    const reportPath = reportIdx !== -1 && argv[reportIdx + 1]
+        ? join(process.cwd(), argv[reportIdx + 1])
+        : join(process.cwd(), ".judges", "last-verdict.json");
+    const suppIdx = argv.indexOf("--suppressions");
+    const suppPath = suppIdx !== -1 && argv[suppIdx + 1]
+        ? join(process.cwd(), argv[suppIdx + 1])
+        : join(process.cwd(), ".judges", "suppressions.json");
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    if (!existsSync(suppPath)) {
+        console.log("No suppressions ledger found. Creating template...");
+        writeFileSync(suppPath, JSON.stringify({ suppressions: [] }, null, 2), "utf-8");
+        console.log(`Created: ${suppPath}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    const suppData = JSON.parse(readFileSync(suppPath, "utf-8"));
+    const suppressions = suppData.suppressions ?? [];
+    const reopened = detectReopened(findings, suppressions);
+    if (format === "json") {
+        console.log(JSON.stringify(reopened, null, 2));
+        return;
+    }
+    if (reopened.length === 0) {
+        console.log("\nNo reopened findings detected.");
+        return;
+    }
+    console.log(`\n=== Reopened Findings (${reopened.length}) ===\n`);
+    for (const r of reopened) {
+        console.log(`[${r.severity.toUpperCase()}] ${r.ruleId}: ${r.title}`);
+        console.log(`  Suppressed: ${r.suppressedAt}`);
+        console.log(`  → ${r.recommendation}`);
+        console.log();
+    }
+}

package/dist/commands/finding-repeat-detect.d.ts

@@ -0,0 +1 @@
+export declare function runFindingRepeatDetect(argv: string[]): void;

package/dist/commands/finding-repeat-detect.js

@@ -0,0 +1,92 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+function detectRepeats(historyDir) {
+    if (!existsSync(historyDir)) {
+        return { totalRepeats: 0, uniqueRepeatingRules: 0, entries: [] };
+    }
+    const files = readdirSync(historyDir);
+    const jsonFiles = files.filter((f) => String(f).endsWith(".json")).sort();
+    const ruleData = {};
+    for (const file of jsonFiles) {
+        const raw = readFileSync(join(historyDir, String(file)), "utf-8");
+        let verdict;
+        try {
+            verdict = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const period = String(file).replace(/\.json$/, "");
+        const seenInFile = new Set();
+        for (const f of verdict.findings ?? []) {
+            if (seenInFile.has(f.ruleId))
+                continue;
+            seenInFile.add(f.ruleId);
+            if (!ruleData[f.ruleId]) {
+                ruleData[f.ruleId] = {
+                    occurrences: 0,
+                    firstSeen: period,
+                    lastSeen: period,
+                    severity: f.severity,
+                    title: f.title,
+                };
+            }
+            ruleData[f.ruleId].occurrences += 1;
+            ruleData[f.ruleId].lastSeen = period;
+        }
+    }
+    const entries = [];
+    for (const [ruleId, data] of Object.entries(ruleData)) {
+        if (data.occurrences > 1) {
+            entries.push({
+                ruleId,
+                occurrences: data.occurrences,
+                firstSeen: data.firstSeen,
+                lastSeen: data.lastSeen,
+                severity: data.severity,
+                sampleTitle: data.title,
+            });
+        }
+    }
+    entries.sort((a, b) => b.occurrences - a.occurrences);
+    return {
+        totalRepeats: entries.reduce((sum, e) => sum + e.occurrences, 0),
+        uniqueRepeatingRules: entries.length,
+        entries,
+    };
+}
+export function runFindingRepeatDetect(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-repeat-detect [options]
+
+Detect findings that repeat across multiple reviews.
+
+Options:
+  --history <dir>      Directory with verdict JSON files (default: .judges/history)
+  --format <fmt>       Output format: table (default) or json
+  -h, --help           Show this help message`);
+        return;
+    }
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx !== -1 && argv[formatIdx + 1] ? argv[formatIdx + 1] : "table";
+    const histIdx = argv.indexOf("--history");
+    const historyDir = histIdx !== -1 && argv[histIdx + 1]
+        ? join(process.cwd(), argv[histIdx + 1])
+        : join(process.cwd(), ".judges", "history");
+    const report = detectRepeats(historyDir);
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`\n=== Repeat Detection (${report.uniqueRepeatingRules} repeating rules, ${report.totalRepeats} total occurrences) ===\n`);
+    if (report.entries.length === 0) {
+        console.log("No repeating findings detected.");
+        return;
+    }
+    for (const e of report.entries) {
+        console.log(`  ${e.ruleId} — ${e.occurrences} occurrences [${e.severity}]`);
+        console.log(`       First: ${e.firstSeen}  Last: ${e.lastSeen}`);
+        console.log(`       ${e.sampleTitle}`);
+        console.log();
+    }
+}

package/dist/commands/finding-resolution-track.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-resolution-track — Track finding resolution status over time.
+ */
+export declare function runFindingResolutionTrack(argv: string[]): void;

package/dist/commands/finding-resolution-track.js

@@ -0,0 +1,150 @@
+/**
+ * Finding-resolution-track — Track finding resolution status over time.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingResolutionTrack(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const storeIdx = argv.indexOf("--store");
+    const resolveIdx = argv.indexOf("--resolve");
+    const deferIdx = argv.indexOf("--defer");
+    const wontfixIdx = argv.indexOf("--wontfix");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const storePath = storeIdx >= 0 ? argv[storeIdx + 1] : ".judges-resolutions.json";
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-resolution-track — Track finding resolution status
+
+Usage:
+  judges finding-resolution-track [--file <review.json>] [--store <path>]
+                                  [--resolve <ruleId>] [--defer <ruleId>]
+                                  [--wontfix <ruleId>] [--format table|json]
+
+Options:
+  --file <path>       Import findings from review result
+  --store <path>      Resolution store file (default: .judges-resolutions.json)
+  --resolve <ruleId>  Mark a rule as resolved
+  --defer <ruleId>    Mark a rule as deferred
+  --wontfix <ruleId>  Mark a rule as wontfix
+  --format <fmt>      Output format: table (default), json
+  --help, -h          Show this help
+`);
+        return;
+    }
+    // Load or init store
+    let store;
+    if (existsSync(storePath)) {
+        store = JSON.parse(readFileSync(storePath, "utf-8"));
+    }
+    else {
+        store = { entries: [], lastUpdated: new Date().toISOString().split("T")[0] };
+    }
+    const today = new Date().toISOString().split("T")[0];
+    // Mark resolved
+    if (resolveIdx >= 0) {
+        const ruleId = argv[resolveIdx + 1];
+        const entry = store.entries.find((e) => e.ruleId === ruleId && e.status === "open");
+        if (entry) {
+            entry.status = "resolved";
+            entry.resolvedAt = today;
+            store.lastUpdated = today;
+            writeFileSync(storePath, JSON.stringify(store, null, 2));
+            console.log(`Marked ${ruleId} as resolved.`);
+        }
+        else {
+            console.error(`No open entry found for ${ruleId}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    // Mark deferred
+    if (deferIdx >= 0) {
+        const ruleId = argv[deferIdx + 1];
+        const entry = store.entries.find((e) => e.ruleId === ruleId && e.status === "open");
+        if (entry) {
+            entry.status = "deferred";
+            store.lastUpdated = today;
+            writeFileSync(storePath, JSON.stringify(store, null, 2));
+            console.log(`Marked ${ruleId} as deferred.`);
+        }
+        else {
+            console.error(`No open entry found for ${ruleId}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    // Mark wontfix
+    if (wontfixIdx >= 0) {
+        const ruleId = argv[wontfixIdx + 1];
+        const entry = store.entries.find((e) => e.ruleId === ruleId && e.status === "open");
+        if (entry) {
+            entry.status = "wontfix";
+            store.lastUpdated = today;
+            writeFileSync(storePath, JSON.stringify(store, null, 2));
+            console.log(`Marked ${ruleId} as wontfix.`);
+        }
+        else {
+            console.error(`No open entry found for ${ruleId}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    // Import findings from review
+    if (filePath) {
+        if (!existsSync(filePath)) {
+            console.error(`Error: file not found: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+        let verdict;
+        try {
+            verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            console.error(`Error: failed to parse review file: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+        let added = 0;
+        for (const f of verdict.findings) {
+            const existing = store.entries.find((e) => e.ruleId === f.ruleId && e.title === f.title);
+            if (existing) {
+                existing.lastSeen = today;
+            }
+            else {
+                store.entries.push({
+                    ruleId: f.ruleId,
+                    severity: f.severity,
+                    title: f.title,
+                    status: "open",
+                    firstSeen: today,
+                    lastSeen: today,
+                });
+                added++;
+            }
+        }
+        store.lastUpdated = today;
+        writeFileSync(storePath, JSON.stringify(store, null, 2));
+        console.log(`Imported ${added} new finding(s), updated ${verdict.findings.length - added} existing.`);
+        return;
+    }
+    // Display current state
+    if (format === "json") {
+        console.log(JSON.stringify(store, null, 2));
+        return;
+    }
+    const open = store.entries.filter((e) => e.status === "open");
+    const resolved = store.entries.filter((e) => e.status === "resolved");
+    const deferred = store.entries.filter((e) => e.status === "deferred");
+    console.log(`\nResolution Tracking: ${store.entries.length} total`);
+    console.log(`  Open: ${open.length}  Resolved: ${resolved.length}  Deferred: ${deferred.length}`);
+    console.log("═".repeat(65));
+    for (const e of store.entries) {
+        const statusBadge = e.status === "open" ? "[ ]" : e.status === "resolved" ? "[✓]" : e.status === "deferred" ? "[~]" : "[x]";
+        console.log(`  ${statusBadge} ${e.ruleId.padEnd(20)} [${e.severity}] ${e.title}`);
+        console.log(`      First: ${e.firstSeen}  Last: ${e.lastSeen}${e.resolvedAt ? `  Resolved: ${e.resolvedAt}` : ""}`);
+    }
+    console.log("═".repeat(65));
+}

package/dist/commands/finding-resolution-tracker.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-resolution-tracker — Track finding resolution status over time.
+ */
+export declare function runFindingResolutionTracker(argv: string[]): void;

package/dist/commands/finding-resolution-tracker.js

@@ -0,0 +1,163 @@
+/**
+ * Finding-resolution-tracker — Track finding resolution status over time.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function loadLog(logPath) {
+    if (!existsSync(logPath)) {
+        return { version: 1, entries: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(logPath, "utf-8"));
+    }
+    catch {
+        return { version: 1, entries: [] };
+    }
+}
+function saveLog(logPath, log) {
+    const dir = dirname(logPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(logPath, JSON.stringify(log, null, 2));
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingResolutionTracker(argv) {
+    const actionIdx = argv.indexOf("--action");
+    const logIdx = argv.indexOf("--log");
+    const fileIdx = argv.indexOf("--file");
+    const ruleIdx = argv.indexOf("--rule");
+    const statusIdx = argv.indexOf("--status");
+    const formatIdx = argv.indexOf("--format");
+    const action = actionIdx >= 0 ? argv[actionIdx + 1] : "list";
+    const logPath = logIdx >= 0 ? argv[logIdx + 1] : ".judges-resolutions.json";
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const ruleId = ruleIdx >= 0 ? argv[ruleIdx + 1] : undefined;
+    const newStatus = statusIdx >= 0 ? argv[statusIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-resolution-tracker — Track finding resolutions
+
+Usage:
+  judges finding-resolution-tracker --action <action> [options]
+
+Actions:
+  list       List resolution entries (default)
+  sync       Sync with verdict file (updates open/resolved)
+  update     Update status of a specific rule
+  summary    Show resolution summary
+
+Options:
+  --action <act>     Action: list, sync, update, summary
+  --log <path>       Resolution log (default: .judges-resolutions.json)
+  --file <path>      Verdict JSON file (for sync)
+  --rule <id>        Rule ID (for update)
+  --status <s>       New status: resolved, wont-fix, false-positive (for update)
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    const log = loadLog(logPath);
+    const now = new Date().toISOString();
+    if (action === "sync") {
+        if (!filePath || !existsSync(filePath)) {
+            console.error("Error: --file required for sync");
+            process.exitCode = 1;
+            return;
+        }
+        let verdict;
+        try {
+            verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            console.error("Error: invalid JSON");
+            process.exitCode = 1;
+            return;
+        }
+        const currentRules = new Set(verdict.findings.map((f) => f.ruleId));
+        // mark resolved if no longer in findings
+        for (const entry of log.entries) {
+            if (entry.status === "open" && !currentRules.has(entry.ruleId)) {
+                entry.status = "resolved";
+                entry.resolvedAt = now;
+            }
+        }
+        // add new findings
+        for (const f of verdict.findings) {
+            const existing = log.entries.find((e) => e.ruleId === f.ruleId);
+            if (existing) {
+                existing.lastSeen = now;
+                if (existing.status === "resolved") {
+                    existing.status = "open";
+                    existing.resolvedAt = undefined;
+                }
+            }
+            else {
+                log.entries.push({
+                    ruleId: f.ruleId,
+                    title: f.title,
+                    status: "open",
+                    firstSeen: now,
+                    lastSeen: now,
+                });
+            }
+        }
+        saveLog(logPath, log);
+        console.log(`Synced ${verdict.findings.length} findings. Log: ${logPath}`);
+        return;
+    }
+    if (action === "update") {
+        if (!ruleId || !newStatus) {
+            console.error("Error: --rule and --status required for update");
+            process.exitCode = 1;
+            return;
+        }
+        const entry = log.entries.find((e) => e.ruleId === ruleId);
+        if (!entry) {
+            console.error(`Error: entry not found: ${ruleId}`);
+            process.exitCode = 1;
+            return;
+        }
+        entry.status = newStatus;
+        if (newStatus === "resolved")
+            entry.resolvedAt = now;
+        saveLog(logPath, log);
+        console.log(`Updated ${ruleId} → ${newStatus}`);
+        return;
+    }
+    if (action === "summary") {
+        const counts = { open: 0, resolved: 0, "wont-fix": 0, "false-positive": 0 };
+        for (const e of log.entries) {
+            counts[e.status]++;
+        }
+        if (format === "json") {
+            console.log(JSON.stringify(counts, null, 2));
+            return;
+        }
+        console.log(`\nResolution Summary`);
+        console.log("═".repeat(40));
+        for (const [status, count] of Object.entries(counts)) {
+            console.log(`  ${status.padEnd(20)} ${count}`);
+        }
+        console.log(`  ${"total".padEnd(20)} ${log.entries.length}`);
+        console.log("═".repeat(40));
+        return;
+    }
+    // list
+    if (format === "json") {
+        console.log(JSON.stringify(log, null, 2));
+        return;
+    }
+    console.log(`\nResolution Tracker (${log.entries.length} entries)`);
+    console.log("═".repeat(75));
+    console.log(`${"Rule".padEnd(22)} ${"Status".padEnd(16)} ${"First Seen".padEnd(22)} Last Seen`);
+    console.log("─".repeat(75));
+    for (const e of log.entries) {
+        const rule = e.ruleId.length > 20 ? e.ruleId.slice(0, 20) + "…" : e.ruleId;
+        console.log(`${rule.padEnd(22)} ${e.status.padEnd(16)} ${e.firstSeen.slice(0, 19).padEnd(22)} ${e.lastSeen.slice(0, 19)}`);
+    }
+    console.log("═".repeat(75));
+}

package/dist/commands/finding-resolution-workflow.d.ts

@@ -0,0 +1 @@
+export declare function runFindingResolutionWorkflow(argv: string[]): void;