@kevinrabun/judges-cli 3.124.0

package/dist/commands/finding-code-smell.js

@@ -0,0 +1,113 @@
+/**
+ * Finding-code-smell — Detect code-smell indicators among findings.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Patterns ───────────────────────────────────────────────────────────────
+const SMELL_KEYWORDS = [
+    { keywords: ["duplicate", "copy", "clone", "repeated"], label: "duplication" },
+    { keywords: ["complex", "nested", "cyclomatic", "branch"], label: "complexity" },
+    { keywords: ["long", "large", "big", "oversized", "bloat"], label: "bloat" },
+    { keywords: ["magic", "hardcod", "literal", "constant"], label: "magic-values" },
+    { keywords: ["dead", "unused", "unreachable", "orphan"], label: "dead-code" },
+    { keywords: ["coupling", "depend", "import", "circular"], label: "coupling" },
+    { keywords: ["naming", "convention", "inconsistent", "style"], label: "naming" },
+    { keywords: ["comment", "todo", "fixme", "hack", "workaround"], label: "tech-debt" },
+];
+function detectSmell(title, desc) {
+    const combined = `${title} ${desc}`.toLowerCase();
+    for (const s of SMELL_KEYWORDS) {
+        const matches = s.keywords.filter((k) => combined.includes(k));
+        if (matches.length > 0) {
+            return { label: s.label, confidence: Math.min(1, 0.5 + matches.length * 0.2) };
+        }
+    }
+    return { label: "general", confidence: 0.3 };
+}
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function analyzeSmells(verdict) {
+    const results = [];
+    for (const f of verdict.findings) {
+        const { label, confidence } = detectSmell(f.title, f.description);
+        results.push({
+            ruleId: f.ruleId,
+            title: f.title,
+            severity: (f.severity || "medium").toLowerCase(),
+            smellType: label,
+            confidence,
+        });
+    }
+    return results;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingCodeSmell(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const formatIdx = argv.indexOf("--format");
+    const minIdx = argv.indexOf("--min-confidence");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    const minConf = minIdx >= 0 ? parseFloat(argv[minIdx + 1]) : 0;
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-code-smell — Detect code-smell indicators
+
+Usage:
+  judges finding-code-smell --file <verdict.json> [--format table|json]
+                            [--min-confidence <0-1>]
+
+Options:
+  --file <path>            Path to verdict JSON file (required)
+  --format <fmt>           Output format: table (default), json
+  --min-confidence <n>     Minimum confidence threshold (0-1)
+  --help, -h               Show this help
+`);
+        return;
+    }
+    if (!filePath) {
+        console.error("Error: --file required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(filePath)) {
+        console.error(`Error: not found: ${filePath}`);
+        process.exitCode = 1;
+        return;
+    }
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        console.error("Error: invalid JSON");
+        process.exitCode = 1;
+        return;
+    }
+    let results = analyzeSmells(verdict);
+    if (minConf > 0) {
+        results = results.filter((r) => r.confidence >= minConf);
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    // group by smell type
+    const byType = new Map();
+    for (const r of results) {
+        const arr = byType.get(r.smellType) || [];
+        arr.push(r);
+        byType.set(r.smellType, arr);
+    }
+    console.log(`\nCode Smell Analysis (${results.length} findings)`);
+    console.log("═".repeat(70));
+    console.log(`${"Type".padEnd(16)} ${"Count".padEnd(8)} ${"Severity".padEnd(10)} ${"Avg Conf".padEnd(10)}`);
+    console.log("─".repeat(70));
+    for (const [type, items] of byType) {
+        const avgConf = items.reduce((s, i) => s + i.confidence, 0) / items.length;
+        const topSev = items.some((i) => i.severity === "critical")
+            ? "critical"
+            : items.some((i) => i.severity === "high")
+                ? "high"
+                : "medium";
+        console.log(`${type.padEnd(16)} ${String(items.length).padEnd(8)} ${topSev.padEnd(10)} ${avgConf.toFixed(2).padEnd(10)}`);
+    }
+    console.log("═".repeat(70));
+}

package/dist/commands/finding-compare-runs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-compare-runs — Compare findings across different review runs.
+ */
+export declare function runFindingCompareRuns(argv: string[]): void;

package/dist/commands/finding-compare-runs.js

@@ -0,0 +1,105 @@
+/**
+ * Finding-compare-runs — Compare findings across different review runs.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function loadVerdict(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function compareRuns(before, after) {
+    const beforeKeys = new Set(before.findings.map((f) => `${f.ruleId}:${f.title}`));
+    const afterKeys = new Set(after.findings.map((f) => `${f.ruleId}:${f.title}`));
+    const newFindings = after.findings
+        .filter((f) => !beforeKeys.has(`${f.ruleId}:${f.title}`))
+        .map((f) => ({ ruleId: f.ruleId, title: f.title, severity: f.severity || "medium" }));
+    const resolvedFindings = before.findings
+        .filter((f) => !afterKeys.has(`${f.ruleId}:${f.title}`))
+        .map((f) => ({ ruleId: f.ruleId, title: f.title, severity: f.severity || "medium" }));
+    const persistentFindings = after.findings
+        .filter((f) => beforeKeys.has(`${f.ruleId}:${f.title}`))
+        .map((f) => ({ ruleId: f.ruleId, title: f.title, severity: f.severity || "medium" }));
+    return {
+        newFindings,
+        resolvedFindings,
+        persistentFindings,
+        scoreChange: after.overallScore - before.overallScore,
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingCompareRuns(argv) {
+    const beforeIdx = argv.indexOf("--before");
+    const afterIdx = argv.indexOf("--after");
+    const formatIdx = argv.indexOf("--format");
+    const beforePath = beforeIdx >= 0 ? argv[beforeIdx + 1] : undefined;
+    const afterPath = afterIdx >= 0 ? argv[afterIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-compare-runs — Compare findings across runs
+
+Usage:
+  judges finding-compare-runs --before <v1.json> --after <v2.json>
+                               [--format table|json]
+
+Options:
+  --before <path>    Earlier verdict JSON file (required)
+  --after <path>     Later verdict JSON file (required)
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+`);
+        return;
+    }
+    if (!beforePath || !afterPath) {
+        console.error("Error: --before and --after required");
+        process.exitCode = 1;
+        return;
+    }
+    const before = loadVerdict(beforePath);
+    const after = loadVerdict(afterPath);
+    if (!before) {
+        console.error(`Error: cannot load ${beforePath}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!after) {
+        console.error(`Error: cannot load ${afterPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = compareRuns(before, after);
+    if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log("\nRun Comparison");
+    console.log("═".repeat(60));
+    const scoreDir = result.scoreChange >= 0 ? "+" : "";
+    console.log(`Score change: ${scoreDir}${result.scoreChange}`);
+    console.log(`Before: ${before.findings.length} findings | After: ${after.findings.length} findings`);
+    console.log("─".repeat(60));
+    if (result.newFindings.length > 0) {
+        console.log(`\nNew (${result.newFindings.length}):`);
+        for (const f of result.newFindings)
+            console.log(`  + [${f.severity}] ${f.title}`);
+    }
+    if (result.resolvedFindings.length > 0) {
+        console.log(`\nResolved (${result.resolvedFindings.length}):`);
+        for (const f of result.resolvedFindings)
+            console.log(`  - [${f.severity}] ${f.title}`);
+    }
+    if (result.persistentFindings.length > 0) {
+        console.log(`\nPersistent (${result.persistentFindings.length}):`);
+        for (const f of result.persistentFindings.slice(0, 10))
+            console.log(`  = [${f.severity}] ${f.title}`);
+        if (result.persistentFindings.length > 10)
+            console.log(`  ... and ${result.persistentFindings.length - 10} more`);
+    }
+    console.log("\n" + "═".repeat(60));
+}

package/dist/commands/finding-compliance-tag.d.ts

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

package/dist/commands/finding-compliance-tag.js

@@ -0,0 +1,106 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+const DEFAULT_MAPPINGS = [
+    {
+        framework: "SOC2",
+        controls: [
+            { pattern: "auth", controlId: "CC6.1", description: "Logical access security" },
+            { pattern: "crypto", controlId: "CC6.7", description: "Encryption of data" },
+            { pattern: "injection", controlId: "CC7.1", description: "System monitoring" },
+            { pattern: "secret", controlId: "CC6.1", description: "Credential management" },
+        ],
+    },
+    {
+        framework: "PCI-DSS",
+        controls: [
+            { pattern: "injection", controlId: "6.5.1", description: "Injection flaws" },
+            { pattern: "xss", controlId: "6.5.7", description: "Cross-site scripting" },
+            { pattern: "crypto", controlId: "3.4", description: "Render PAN unreadable" },
+            { pattern: "auth", controlId: "8.2", description: "Authentication management" },
+        ],
+    },
+    {
+        framework: "GDPR",
+        controls: [
+            { pattern: "pii", controlId: "Art.25", description: "Data protection by design" },
+            { pattern: "log", controlId: "Art.30", description: "Records of processing" },
+            { pattern: "crypto", controlId: "Art.32", description: "Security of processing" },
+        ],
+    },
+];
+function loadMappings(mappingPath) {
+    if (mappingPath && existsSync(mappingPath)) {
+        try {
+            return JSON.parse(readFileSync(mappingPath, "utf-8"));
+        }
+        catch {
+            console.log("Warning: could not parse mapping file, using defaults");
+        }
+    }
+    return DEFAULT_MAPPINGS;
+}
+function tagFindings(verdict, mappings) {
+    const results = [];
+    for (const f of verdict.findings ?? []) {
+        const tags = [];
+        const ruleIdLower = f.ruleId.toLowerCase();
+        const titleLower = f.title.toLowerCase();
+        for (const mapping of mappings) {
+            for (const ctrl of mapping.controls) {
+                if (ruleIdLower.includes(ctrl.pattern) || titleLower.includes(ctrl.pattern)) {
+                    tags.push({ framework: mapping.framework, controlId: ctrl.controlId, description: ctrl.description });
+                }
+            }
+        }
+        results.push({ ruleId: f.ruleId, title: f.title, severity: f.severity, tags });
+    }
+    results.sort((a, b) => b.tags.length - a.tags.length);
+    return results;
+}
+export function runFindingComplianceTag(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-compliance-tag [options]
+
+Tag findings with compliance framework identifiers.
+
+Options:
+  --report <path>      Path to verdict JSON
+  --mapping <path>     Path to custom compliance mapping 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 mappingIdx = argv.indexOf("--mapping");
+    const mappingPath = mappingIdx !== -1 && argv[mappingIdx + 1] ? join(process.cwd(), argv[mappingIdx + 1]) : undefined;
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const mappings = loadMappings(mappingPath);
+    const tagged = tagFindings(data, mappings);
+    if (format === "json") {
+        console.log(JSON.stringify(tagged, null, 2));
+        return;
+    }
+    const withTags = tagged.filter((t) => t.tags.length > 0);
+    console.log(`\n=== Compliance Tags (${withTags.length} tagged of ${tagged.length} findings) ===\n`);
+    if (withTags.length === 0) {
+        console.log("No findings matched compliance patterns.");
+        return;
+    }
+    for (const entry of withTags) {
+        console.log(`  ${entry.severity.toUpperCase().padEnd(9)} ${entry.ruleId}`);
+        console.log(`           ${entry.title}`);
+        for (const tag of entry.tags) {
+            console.log(`           [${tag.framework}] ${tag.controlId} — ${tag.description}`);
+        }
+        console.log();
+    }
+}

package/dist/commands/finding-confidence-boost.d.ts

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

package/dist/commands/finding-confidence-boost.js

@@ -0,0 +1,88 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function boostConfidence(findings) {
+    // Build a map of rule occurrences for corroboration
+    const ruleCounts = new Map();
+    for (const f of findings) {
+        const prefix = f.ruleId.split("-")[0];
+        ruleCounts.set(prefix, (ruleCounts.get(prefix) ?? 0) + 1);
+    }
+    const boosts = [];
+    for (const f of findings) {
+        const original = f.confidence ?? 0.5;
+        let boosted = original;
+        const reasons = [];
+        // Multiple findings from same domain = corroboration
+        const prefix = f.ruleId.split("-")[0];
+        const domainCount = ruleCounts.get(prefix) ?? 0;
+        if (domainCount >= 3) {
+            boosted = Math.min(1, boosted + 0.1);
+            reasons.push(`${domainCount} corroborating findings in domain`);
+        }
+        // Has patch = higher confidence the issue is real
+        if (f.patch !== undefined && f.patch !== null) {
+            boosted = Math.min(1, boosted + 0.05);
+            reasons.push("patch available confirms issue");
+        }
+        // High severity + evidence = boost
+        if ((f.severity === "critical" || f.severity === "high") && f.evidenceBasis) {
+            boosted = Math.min(1, boosted + 0.05);
+            reasons.push("evidence-backed high severity");
+        }
+        if (reasons.length > 0) {
+            boosts.push({
+                ruleId: f.ruleId,
+                title: f.title,
+                originalConfidence: Math.round(original * 100),
+                boostedConfidence: Math.round(boosted * 100),
+                boostReasons: reasons,
+            });
+        }
+    }
+    boosts.sort((a, b) => b.boostedConfidence - b.originalConfidence - (a.boostedConfidence - a.originalConfidence));
+    return boosts;
+}
+export function runFindingConfidenceBoost(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges finding-confidence-boost [options]
+
+Identify findings eligible for confidence boost.
+
+Options:
+  --report <path>      Path to verdict JSON file
+  --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");
+    if (!existsSync(reportPath)) {
+        console.log(`No report found at: ${reportPath}`);
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    if (findings.length === 0) {
+        console.log("No findings to analyze.");
+        return;
+    }
+    const boosts = boostConfidence(findings);
+    if (format === "json") {
+        console.log(JSON.stringify(boosts, null, 2));
+        return;
+    }
+    console.log(`\n=== Confidence Boost Analysis (${boosts.length} eligible) ===\n`);
+    for (const b of boosts) {
+        const delta = b.boostedConfidence - b.originalConfidence;
+        console.log(`${b.ruleId}: ${b.title}`);
+        console.log(`  ${b.originalConfidence}% → ${b.boostedConfidence}% (+${delta}%)`);
+        for (const r of b.boostReasons) {
+            console.log(`    • ${r}`);
+        }
+        console.log();
+    }
+}

package/dist/commands/finding-confidence-calibrate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-confidence-calibrate — Calibrate finding confidence thresholds.
+ */
+export declare function runFindingConfidenceCalibrate(argv: string[]): void;

package/dist/commands/finding-confidence-calibrate.js

@@ -0,0 +1,111 @@
+/**
+ * Finding-confidence-calibrate — Calibrate finding confidence thresholds.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingConfidenceCalibrate(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const thresholdIdx = argv.indexOf("--threshold");
+    const outputIdx = argv.indexOf("--output");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const threshold = thresholdIdx >= 0 ? parseFloat(argv[thresholdIdx + 1]) : 0.7;
+    const outputPath = outputIdx >= 0 ? argv[outputIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-confidence-calibrate — Calibrate confidence thresholds
+
+Usage:
+  judges finding-confidence-calibrate --file <review.json>
+                                      [--threshold <0.0-1.0>] [--output <file>]
+                                      [--format table|json]
+
+Options:
+  --file <path>       Review result JSON file
+  --threshold <n>     Confidence threshold (default: 0.7)
+  --output <path>     Write calibration results to file
+  --format <fmt>      Output format: table (default), json
+  --help, -h          Show this help
+`);
+        return;
+    }
+    if (!filePath) {
+        console.error("Error: --file is required");
+        process.exitCode = 1;
+        return;
+    }
+    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;
+    }
+    const confidences = verdict.findings.filter((f) => f.confidence !== undefined).map((f) => f.confidence);
+    if (confidences.length === 0) {
+        console.log("No findings with confidence scores found.");
+        return;
+    }
+    // Build distribution
+    const ranges = [
+        { range: "0.0-0.2", min: 0.0, max: 0.2, count: 0 },
+        { range: "0.2-0.4", min: 0.2, max: 0.4, count: 0 },
+        { range: "0.4-0.6", min: 0.4, max: 0.6, count: 0 },
+        { range: "0.6-0.8", min: 0.6, max: 0.8, count: 0 },
+        { range: "0.8-1.0", min: 0.8, max: 1.01, count: 0 },
+    ];
+    for (const c of confidences) {
+        for (const r of ranges) {
+            if (c >= r.min && c < r.max) {
+                r.count++;
+                break;
+            }
+        }
+    }
+    const below = confidences.filter((c) => c < threshold).length;
+    const above = confidences.length - below;
+    // Suggest threshold at median
+    const sorted = [...confidences].sort((a, b) => a - b);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    const suggestedThreshold = Math.round(median * 100) / 100;
+    const result = {
+        totalFindings: confidences.length,
+        distribution: ranges.map((r) => ({
+            range: r.range,
+            count: r.count,
+            percentage: Math.round((r.count / confidences.length) * 100),
+        })),
+        suggestedThreshold,
+        belowThreshold: below,
+        aboveThreshold: above,
+    };
+    if (outputPath) {
+        writeFileSync(outputPath, JSON.stringify(result, null, 2));
+        console.log(`Calibration results written to ${outputPath}`);
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`\nConfidence Calibration`);
+    console.log("═".repeat(55));
+    console.log(`  Findings with confidence: ${result.totalFindings}`);
+    console.log(`  Current threshold: ${threshold}`);
+    console.log(`  Suggested threshold: ${result.suggestedThreshold}`);
+    console.log(`  Below threshold: ${result.belowThreshold}  Above: ${result.aboveThreshold}`);
+    console.log(`\n  Distribution:`);
+    for (const d of result.distribution) {
+        const bar = "█".repeat(Math.min(d.count, 30));
+        console.log(`    ${d.range}  ${String(d.count).padStart(4)} (${String(d.percentage).padStart(3)}%)  ${bar}`);
+    }
+    console.log("═".repeat(55));
+}

package/dist/commands/finding-confidence-filter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-confidence-filter — Filter findings by confidence level.
+ */
+export declare function runFindingConfidenceFilter(argv: string[]): void;

package/dist/commands/finding-confidence-filter.js

@@ -0,0 +1,77 @@
+/**
+ * Finding-confidence-filter — Filter findings by confidence level.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingConfidenceFilter(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-confidence-filter — Filter findings by confidence level
+
+Usage:
+  judges finding-confidence-filter --file results.json --min 0.8
+  judges finding-confidence-filter --file results.json --tier high
+  judges finding-confidence-filter --file results.json --min 0.5 --max 0.9
+
+Options:
+  --file <path>         Path to review result JSON
+  --min <n>             Minimum confidence (0.0–1.0)
+  --max <n>             Maximum confidence (0.0–1.0)
+  --tier <level>        Filter by tier: high, medium, low
+  --format json         JSON output
+  --help, -h            Show this help
+
+Filters findings from a review result file based on confidence scores.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const filePath = argv.find((_a, i) => argv[i - 1] === "--file") || "";
+    const minConf = parseFloat(argv.find((_a, i) => argv[i - 1] === "--min") || "0");
+    const maxConf = parseFloat(argv.find((_a, i) => argv[i - 1] === "--max") || "1");
+    const tier = argv.find((_a, i) => argv[i - 1] === "--tier") || "";
+    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 filtered = findings.filter((f) => {
+        const finding = f;
+        const conf = typeof finding.confidence === "number" ? finding.confidence : 0.5;
+        if (tier) {
+            const fTier = typeof finding.confidenceTier === "string" ? finding.confidenceTier : "";
+            return fTier.toLowerCase() === tier.toLowerCase();
+        }
+        return conf >= minConf && conf <= maxConf;
+    });
+    if (format === "json") {
+        console.log(JSON.stringify({ total: findings.length, filtered: filtered.length, findings: filtered }, null, 2));
+        return;
+    }
+    console.log(`\nConfidence Filter: ${filtered.length} of ${findings.length} findings`);
+    if (tier)
+        console.log(`  Tier: ${tier}`);
+    else
+        console.log(`  Range: ${minConf.toFixed(1)} – ${maxConf.toFixed(1)}`);
+    console.log("─".repeat(60));
+    for (const f of filtered) {
+        const conf = typeof f.confidence === "number" ? f.confidence.toFixed(2) : "?";
+        console.log(`  [${String(f.severity || "?").toUpperCase()}] ${f.ruleId || ""} — ${f.title || "untitled"}  (conf=${conf})`);
+    }
+    if (filtered.length === 0) {
+        console.log("  No findings match the filter.");
+    }
+    console.log("─".repeat(60));
+}

package/dist/commands/finding-contest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finding contest — gamified challenge mode where developers compete
+ * to fix the most findings in a codebase within a time window.
+ *
+ * Results stored locally in `.judges-contests/`.
+ */
+export declare function runFindingContest(argv: string[]): void;