@kevinrabun/judges-cli 3.124.0

package/dist/commands/finding-fix-verify.js

@@ -0,0 +1,198 @@
+/**
+ * Finding-fix-verify — Verify that applied fixes actually resolve findings.
+ */
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingFixVerify(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        console.log(`
+judges finding-fix-verify — Verify fixes resolve findings
+
+Usage:
+  judges finding-fix-verify compare --before <f1> --after <f2> [--format json]
+  judges finding-fix-verify check   --file <results.json> --rule <ruleId>
+  judges finding-fix-verify history [--format json]
+
+Subcommands:
+  compare         Compare before/after results to verify fixes
+  check           Check if a specific rule's findings are resolved
+  history         Show verification history
+
+Options:
+  --before <path>  Result file before fixes
+  --after <path>   Result file after fixes
+  --file <path>    Result file to check
+  --rule <ruleId>  Specific rule to verify
+  --format json    JSON output
+  --help, -h       Show this help
+`);
+        return;
+    }
+    const args = argv.slice(1);
+    if (sub === "compare") {
+        const before = args.find((_a, i) => args[i - 1] === "--before");
+        const after = args.find((_a, i) => args[i - 1] === "--after");
+        const format = args.find((_a, i) => args[i - 1] === "--format") || "text";
+        if (!before || !after) {
+            console.error("Error: --before and --after required");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(before)) {
+            console.error(`Error: file not found: ${before}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(after)) {
+            console.error(`Error: file not found: ${after}`);
+            process.exitCode = 1;
+            return;
+        }
+        let vBefore;
+        let vAfter;
+        try {
+            vBefore = JSON.parse(readFileSync(before, "utf-8"));
+        }
+        catch {
+            console.error("Error: could not parse before file");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            vAfter = JSON.parse(readFileSync(after, "utf-8"));
+        }
+        catch {
+            console.error("Error: could not parse after file");
+            process.exitCode = 1;
+            return;
+        }
+        const beforeRules = new Set((vBefore.findings || []).map((f) => f.ruleId));
+        const afterRules = new Set((vAfter.findings || []).map((f) => f.ruleId));
+        const records = [];
+        const now = new Date().toISOString();
+        for (const f of vBefore.findings || []) {
+            if (!afterRules.has(f.ruleId)) {
+                records.push({ ruleId: f.ruleId, title: f.title, status: "resolved", verifiedAt: now });
+            }
+            else {
+                records.push({ ruleId: f.ruleId, title: f.title, status: "unresolved", verifiedAt: now });
+            }
+        }
+        for (const f of vAfter.findings || []) {
+            if (!beforeRules.has(f.ruleId)) {
+                records.push({ ruleId: f.ruleId, title: f.title, status: "new", verifiedAt: now });
+            }
+        }
+        // Save history
+        const histFile = join(process.cwd(), ".judges", "fix-verify-history.json");
+        const hd = dirname(histFile);
+        if (!existsSync(hd))
+            mkdirSync(hd, { recursive: true });
+        const existing = existsSync(histFile)
+            ? (() => {
+                try {
+                    return JSON.parse(readFileSync(histFile, "utf-8"));
+                }
+                catch {
+                    return [];
+                }
+            })()
+            : [];
+        const history = [...existing, ...records];
+        writeFileSync(histFile, JSON.stringify(history.slice(-500), null, 2));
+        const resolved = records.filter((r) => r.status === "resolved");
+        const unresolved = records.filter((r) => r.status === "unresolved");
+        const newFindings = records.filter((r) => r.status === "new");
+        if (format === "json") {
+            console.log(JSON.stringify({ resolved: resolved.length, unresolved: unresolved.length, new: newFindings.length, records }, null, 2));
+            return;
+        }
+        console.log(`\nFix Verification:`);
+        console.log("═".repeat(65));
+        console.log(`  ✓ Resolved:   ${resolved.length}`);
+        console.log(`  ✗ Unresolved: ${unresolved.length}`);
+        console.log(`  ★ New:        ${newFindings.length}`);
+        console.log("─".repeat(65));
+        if (resolved.length > 0) {
+            console.log("\n  Resolved:");
+            for (const r of resolved.slice(0, 10))
+                console.log(`    ✓ ${r.ruleId} — ${r.title}`);
+        }
+        if (unresolved.length > 0) {
+            console.log("\n  Still Open:");
+            for (const r of unresolved.slice(0, 10))
+                console.log(`    ✗ ${r.ruleId} — ${r.title}`);
+        }
+        if (newFindings.length > 0) {
+            console.log("\n  New (regressions?):");
+            for (const r of newFindings.slice(0, 10))
+                console.log(`    ★ ${r.ruleId} — ${r.title}`);
+        }
+        console.log("═".repeat(65));
+    }
+    else if (sub === "check") {
+        const file = args.find((_a, i) => args[i - 1] === "--file");
+        const rule = args.find((_a, i) => args[i - 1] === "--rule");
+        if (!file || !rule) {
+            console.error("Error: --file and --rule required");
+            process.exitCode = 1;
+            return;
+        }
+        if (!existsSync(file)) {
+            console.error(`Error: file not found: ${file}`);
+            process.exitCode = 1;
+            return;
+        }
+        let verdict;
+        try {
+            verdict = JSON.parse(readFileSync(file, "utf-8"));
+        }
+        catch {
+            console.error("Error: could not parse file");
+            process.exitCode = 1;
+            return;
+        }
+        const matches = (verdict.findings || []).filter((f) => f.ruleId === rule);
+        if (matches.length === 0) {
+            console.log(`✓ Rule "${rule}" has no findings — fix verified!`);
+        }
+        else {
+            console.log(`✗ Rule "${rule}" still has ${matches.length} finding(s):`);
+            for (const m of matches.slice(0, 5))
+                console.log(`  - ${m.title} [${m.severity}]`);
+        }
+    }
+    else if (sub === "history") {
+        const format = args.find((_a, i) => args[i - 1] === "--format") || "text";
+        const histFile = join(process.cwd(), ".judges", "fix-verify-history.json");
+        if (!existsSync(histFile)) {
+            console.log("No verification history found.");
+            return;
+        }
+        let history;
+        try {
+            history = JSON.parse(readFileSync(histFile, "utf-8"));
+        }
+        catch {
+            console.log("Could not parse history.");
+            return;
+        }
+        if (format === "json") {
+            console.log(JSON.stringify(history, null, 2));
+            return;
+        }
+        console.log(`\nVerification History: ${history.length} records`);
+        console.log("═".repeat(55));
+        for (const h of history.slice(-15)) {
+            const icon = h.status === "resolved" ? "✓" : h.status === "new" ? "★" : "✗";
+            console.log(`  ${icon} ${h.ruleId.padEnd(22)} ${h.status.padEnd(12)} ${h.verifiedAt.slice(0, 10)}`);
+        }
+        console.log("═".repeat(55));
+    }
+    else {
+        console.error(`Unknown subcommand: ${sub}. Use --help for usage.`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/finding-group-by.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-group-by — Group findings by a specified field for better organization.
+ */
+export declare function runFindingGroupBy(argv: string[]): void;

package/dist/commands/finding-group-by.js

@@ -0,0 +1,86 @@
+/**
+ * Finding-group-by — Group findings by a specified field for better organization.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingGroupBy(argv) {
+    if (argv.includes("--help") || argv.includes("-h") || argv.length === 0) {
+        console.log(`
+judges finding-group-by — Group findings by a field
+
+Usage:
+  judges finding-group-by --file <results.json> [options]
+
+Options:
+  --file <path>      Result file to analyze (required)
+  --by <field>       Group by: severity, ruleId, confidence, category (default: severity)
+  --sort count|name  Sort groups by count or name (default: count)
+  --format json      JSON output
+  --help, -h         Show this help
+`);
+        return;
+    }
+    const file = argv.find((_a, i) => argv[i - 1] === "--file");
+    if (!file) {
+        console.error("Error: --file required");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(file)) {
+        console.error(`Error: file not found: ${file}`);
+        process.exitCode = 1;
+        return;
+    }
+    const by = argv.find((_a, i) => argv[i - 1] === "--by") || "severity";
+    const sort = argv.find((_a, i) => argv[i - 1] === "--sort") || "count";
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    let verdict;
+    try {
+        verdict = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        console.error("Error: could not parse file");
+        process.exitCode = 1;
+        return;
+    }
+    const findings = verdict.findings || [];
+    const groups = new Map();
+    for (const f of findings) {
+        let key;
+        if (by === "ruleId")
+            key = f.ruleId || "unknown";
+        else if (by === "confidence")
+            key = f.confidence !== undefined && f.confidence !== null ? String(f.confidence) : "unset";
+        else if (by === "category")
+            key = f.ruleId ? f.ruleId.split("-")[0] : "unknown";
+        else
+            key = f.severity || "unknown";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(f);
+    }
+    const sorted = [...groups.entries()];
+    if (sort === "name")
+        sorted.sort((a, b) => a[0].localeCompare(b[0]));
+    else
+        sorted.sort((a, b) => b[1].length - a[1].length);
+    if (format === "json") {
+        const result = sorted.map(([key, items]) => ({ group: key, count: items.length, findings: items }));
+        console.log(JSON.stringify({ totalFindings: findings.length, groupCount: sorted.length, groupBy: by, groups: result }, null, 2));
+        return;
+    }
+    console.log(`\nFindings Grouped by ${by}:`);
+    console.log("═".repeat(65));
+    console.log(`  Total: ${findings.length} findings in ${sorted.length} groups`);
+    console.log("─".repeat(65));
+    for (const [key, items] of sorted) {
+        const bar = "█".repeat(Math.min(items.length, 30));
+        console.log(`  ${key.padEnd(20)} ${String(items.length).padStart(4)}  ${bar}`);
+        for (const f of items.slice(0, 3)) {
+            console.log(`    └─ ${f.title || f.ruleId || "untitled"}`);
+        }
+        if (items.length > 3)
+            console.log(`    └─ ... and ${items.length - 3} more`);
+    }
+    console.log("═".repeat(65));
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Finding-group — Group related findings into actionable clusters.
+ */
+import type { Finding } from "../types.js";
+export interface FindingCluster {
+    id: string;
+    label: string;
+    pattern: string;
+    count: number;
+    severities: Record<string, number>;
+    findings: Finding[];
+    files: string[];
+    recommendation: string;
+}
+export declare function runFindingGroup(argv: string[]): void;

package/dist/commands/finding-group.js

@@ -0,0 +1,164 @@
+/**
+ * Finding-group — Group related findings into actionable clusters.
+ */
+import { readFileSync } from "fs";
+// ─── Grouping strategies ────────────────────────────────────────────────────
+function groupByRule(findings) {
+    const groups = new Map();
+    for (const f of findings) {
+        const key = f.ruleId || "unknown";
+        const existing = groups.get(key) || [];
+        existing.push(f);
+        groups.set(key, existing);
+    }
+    return groups;
+}
+function groupBySeverity(findings) {
+    const groups = new Map();
+    for (const f of findings) {
+        const key = f.severity || "unknown";
+        const existing = groups.get(key) || [];
+        existing.push(f);
+        groups.set(key, existing);
+    }
+    return groups;
+}
+function groupByCategory(findings) {
+    const groups = new Map();
+    for (const f of findings) {
+        const ruleId = f.ruleId || "";
+        let category = "other";
+        if (/sql|inject|xss|csrf|traversal|auth|secret|crypt/i.test(ruleId))
+            category = "security";
+        else if (/perf|cache|memory|leak|optim/i.test(ruleId))
+            category = "performance";
+        else if (/error|exception|throw|catch/i.test(ruleId))
+            category = "error-handling";
+        else if (/doc|comment|jsdoc|readme/i.test(ruleId))
+            category = "documentation";
+        else if (/test|assert|mock|coverage/i.test(ruleId))
+            category = "testing";
+        else if (/lint|format|naming|style/i.test(ruleId))
+            category = "code-style";
+        const existing = groups.get(category) || [];
+        existing.push(f);
+        groups.set(category, existing);
+    }
+    return groups;
+}
+// ─── Build clusters ─────────────────────────────────────────────────────────
+function buildClusters(groups, strategy) {
+    const clusters = [];
+    let idx = 0;
+    for (const [key, findings] of groups) {
+        idx++;
+        const severities = {};
+        for (const f of findings) {
+            const s = f.severity || "unknown";
+            severities[s] = (severities[s] || 0) + 1;
+        }
+        const topFinding = findings.sort((a, b) => {
+            const order = { critical: 0, high: 1, medium: 2, low: 3 };
+            return (order[a.severity] ?? 4) - (order[b.severity] ?? 4);
+        })[0];
+        clusters.push({
+            id: `${strategy}-${idx}`,
+            label: key,
+            pattern: strategy,
+            count: findings.length,
+            severities,
+            findings,
+            files: [],
+            recommendation: topFinding?.recommendation || "Review grouped findings",
+        });
+    }
+    return clusters.sort((a, b) => b.count - a.count);
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingGroup(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-group — Group related findings into actionable clusters
+
+Usage:
+  judges finding-group --input findings.json
+  judges finding-group --input findings.json --strategy severity
+  judges finding-group --input findings.json --format json
+
+Options:
+  --input <file>       JSON file with findings array (required)
+  --strategy <type>    Grouping strategy: rule, severity, category (default: rule)
+  --format json        JSON output
+  --min-count <n>      Minimum findings to form a cluster (default: 1)
+  --help, -h           Show this help
+
+Strategies:
+  rule                 Group by rule ID (most specific)
+  severity             Group by severity level
+  category             Group by inferred category (security, performance, etc.)
+
+Groups related findings to help you fix issues systematically rather
+than one by one.
+`);
+        return;
+    }
+    const inputPath = argv.find((_a, i) => argv[i - 1] === "--input");
+    const strategy = argv.find((_a, i) => argv[i - 1] === "--strategy") || "rule";
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const minCountStr = argv.find((_a, i) => argv[i - 1] === "--min-count");
+    const minCount = minCountStr ? parseInt(minCountStr, 10) : 1;
+    if (!inputPath) {
+        console.error("Error: --input is required. Provide a JSON file with findings.");
+        process.exitCode = 1;
+        return;
+    }
+    let findings;
+    try {
+        const raw = readFileSync(inputPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        findings = Array.isArray(parsed) ? parsed : parsed.findings || [];
+    }
+    catch {
+        console.error(`Error: Cannot read or parse ${inputPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (findings.length === 0) {
+        console.log("No findings to group.");
+        return;
+    }
+    let groups;
+    switch (strategy) {
+        case "severity":
+            groups = groupBySeverity(findings);
+            break;
+        case "category":
+            groups = groupByCategory(findings);
+            break;
+        default:
+            groups = groupByRule(findings);
+    }
+    let clusters = buildClusters(groups, strategy);
+    clusters = clusters.filter((c) => c.count >= minCount);
+    if (format === "json") {
+        console.log(JSON.stringify({
+            strategy,
+            totalFindings: findings.length,
+            clusterCount: clusters.length,
+            clusters: clusters.map((c) => ({ ...c, findings: undefined })),
+        }, null, 2));
+        return;
+    }
+    console.log(`\n  Finding Groups (strategy: ${strategy})\n  ─────────────────────────────`);
+    console.log(`    Total findings: ${findings.length}`);
+    console.log(`    Clusters: ${clusters.length}\n`);
+    for (const cluster of clusters) {
+        const severitySummary = Object.entries(cluster.severities)
+            .map(([s, n]) => `${n} ${s}`)
+            .join(", ");
+        console.log(`    [${cluster.id}] ${cluster.label} — ${cluster.count} finding(s)`);
+        console.log(`      Severities: ${severitySummary}`);
+        console.log(`      Recommendation: ${cluster.recommendation}`);
+        console.log();
+    }
+}

package/dist/commands/finding-groupby-file.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Finding-groupby-file — Group findings by source file path.
+ */
+export declare function runFindingGroupbyFile(argv: string[]): void;

package/dist/commands/finding-groupby-file.js

@@ -0,0 +1,94 @@
+/**
+ * Finding-groupby-file — Group findings by source file path.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function inferFile(f) {
+    // Use provenance if available, otherwise group by rule prefix
+    if (f.provenance !== undefined && typeof f.provenance === "string" && f.provenance.length > 0) {
+        return f.provenance;
+    }
+    const prefix = f.ruleId.split("-")[0];
+    return `[${prefix}]`;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runFindingGroupbyFile(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const formatIdx = argv.indexOf("--format");
+    const sortIdx = argv.indexOf("--sort");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    const sortBy = sortIdx >= 0 ? argv[sortIdx + 1] : "count";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges finding-groupby-file — Group findings by source file
+
+Usage:
+  judges finding-groupby-file --file <review.json> [--sort count|name]
+                              [--format table|json]
+
+Options:
+  --file <path>    Review result JSON file
+  --sort <by>      Sort by: count (default), name
+  --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 groupMap = new Map();
+    for (const f of verdict.findings) {
+        const fileName = inferFile(f);
+        let group = groupMap.get(fileName);
+        if (group === undefined) {
+            group = { file: fileName, findings: [], count: 0 };
+            groupMap.set(fileName, group);
+        }
+        group.findings.push({
+            ruleId: f.ruleId,
+            severity: f.severity,
+            title: f.title,
+            lineNumbers: f.lineNumbers !== undefined ? f.lineNumbers : [],
+        });
+        group.count++;
+    }
+    const groups = [...groupMap.values()];
+    if (sortBy === "name") {
+        groups.sort((a, b) => a.file.localeCompare(b.file));
+    }
+    else {
+        groups.sort((a, b) => b.count - a.count);
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(groups, null, 2));
+        return;
+    }
+    console.log(`\nFindings by File: ${groups.length} group(s), ${verdict.findings.length} total`);
+    console.log("═".repeat(65));
+    for (const g of groups) {
+        console.log(`\n  ${g.file} (${g.count} finding${g.count !== 1 ? "s" : ""})`);
+        for (const f of g.findings) {
+            const lines = f.lineNumbers.length > 0 ? ` L${f.lineNumbers.join(",")}` : "";
+            console.log(`    [${f.severity}] ${f.ruleId}${lines}: ${f.title}`);
+        }
+    }
+    console.log("\n" + "═".repeat(65));
+}

package/dist/commands/finding-hotfix-suggest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finding-hotfix-suggest — Suggest quick hotfixes for common findings.
+ *
+ * Provides targeted one-liner or small code snippets to address
+ * frequently-encountered security and quality issues.
+ */
+export declare function runFindingHotfixSuggest(argv: string[]): void;