@kevinrabun/judges-cli 3.124.0

package/dist/commands/review-filter.js

@@ -0,0 +1,161 @@
+/**
+ * Review-filter — Advanced multi-criteria finding filter.
+ */
+import { readFileSync, existsSync } from "fs";
+import { matchWildcardText } from "../tools/command-safety.js";
+function parseFilterCriteria(argv) {
+    const criteria = {
+        severity: [],
+        ruleIds: [],
+        minConfidence: 0,
+        maxConfidence: 1,
+        titlePattern: "",
+        hasRecommendation: null,
+        hasPatch: null,
+        minLine: 0,
+        maxLine: Number.MAX_SAFE_INTEGER,
+    };
+    const severityArg = argv.find((_a, i) => argv[i - 1] === "--severity");
+    if (severityArg)
+        criteria.severity = severityArg.split(",").map((s) => s.trim().toLowerCase());
+    const ruleArg = argv.find((_a, i) => argv[i - 1] === "--rule");
+    if (ruleArg)
+        criteria.ruleIds = ruleArg.split(",").map((s) => s.trim());
+    const minConf = argv.find((_a, i) => argv[i - 1] === "--min-confidence");
+    if (minConf)
+        criteria.minConfidence = parseFloat(minConf);
+    const maxConf = argv.find((_a, i) => argv[i - 1] === "--max-confidence");
+    if (maxConf)
+        criteria.maxConfidence = parseFloat(maxConf);
+    const title = argv.find((_a, i) => argv[i - 1] === "--title");
+    if (title)
+        criteria.titlePattern = title;
+    if (argv.includes("--has-recommendation"))
+        criteria.hasRecommendation = true;
+    if (argv.includes("--no-recommendation"))
+        criteria.hasRecommendation = false;
+    if (argv.includes("--has-patch"))
+        criteria.hasPatch = true;
+    if (argv.includes("--no-patch"))
+        criteria.hasPatch = false;
+    const minLine = argv.find((_a, i) => argv[i - 1] === "--min-line");
+    if (minLine)
+        criteria.minLine = parseInt(minLine, 10);
+    const maxLine = argv.find((_a, i) => argv[i - 1] === "--max-line");
+    if (maxLine)
+        criteria.maxLine = parseInt(maxLine, 10);
+    return criteria;
+}
+function matchesCriteria(f, c) {
+    if (c.severity.length > 0 && !c.severity.includes((f.severity || "").toLowerCase()))
+        return false;
+    if (c.ruleIds.length > 0 && !c.ruleIds.includes(f.ruleId || ""))
+        return false;
+    const conf = f.confidence ?? 0;
+    if (conf < c.minConfidence || conf > c.maxConfidence)
+        return false;
+    if (c.titlePattern) {
+        const title = (f.title || "").toLowerCase();
+        const pattern = c.titlePattern.toLowerCase();
+        if (!title.includes(pattern) && !matchWildcardText(title, pattern))
+            return false;
+    }
+    if (c.hasRecommendation === true && !f.recommendation)
+        return false;
+    if (c.hasRecommendation === false && f.recommendation)
+        return false;
+    if (c.hasPatch === true && !f.patch)
+        return false;
+    if (c.hasPatch === false && f.patch)
+        return false;
+    if (f.lineNumbers && f.lineNumbers.length > 0) {
+        const minL = Math.min(...f.lineNumbers);
+        const maxL = Math.max(...f.lineNumbers);
+        if (maxL < c.minLine || minL > c.maxLine)
+            return false;
+    }
+    return true;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewFilter(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-filter — Advanced multi-criteria finding filter
+
+Usage:
+  judges review-filter --file verdict.json --severity critical,high
+  judges review-filter --file verdict.json --rule SQLI,XSS --has-patch
+  judges review-filter --file verdict.json --min-confidence 0.8
+
+Options:
+  --file <path>            Verdict JSON to filter
+  --severity <list>        Filter by severity (comma-separated)
+  --rule <list>            Filter by rule ID (comma-separated)
+  --min-confidence <n>     Minimum confidence threshold (0-1)
+  --max-confidence <n>     Maximum confidence threshold (0-1)
+  --title <pattern>        Filter by title text or wildcard pattern
+  --has-recommendation     Only findings with recommendations
+  --no-recommendation      Only findings without recommendations
+  --has-patch              Only findings with patches
+  --no-patch               Only findings without patches
+  --min-line <n>           Minimum line number
+  --max-line <n>           Maximum line number
+  --format json            JSON output
+  --help, -h               Show this help
+
+Multiple criteria are combined with AND logic.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const file = argv.find((_a, i) => argv[i - 1] === "--file");
+    if (!file) {
+        console.error("Error: --file is 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 criteria = parseFilterCriteria(argv);
+    const allFindings = verdict.findings || [];
+    const matched = allFindings.filter((f) => matchesCriteria(f, criteria));
+    if (format === "json") {
+        console.log(JSON.stringify({ total: allFindings.length, matched: matched.length, criteria, findings: matched }, null, 2));
+        return;
+    }
+    console.log(`\n  Filtered Findings\n  ─────────────────────────────`);
+    console.log(`    Total: ${allFindings.length}`);
+    console.log(`    Matched: ${matched.length}`);
+    console.log(`    Excluded: ${allFindings.length - matched.length}`);
+    console.log();
+    if (criteria.severity.length > 0)
+        console.log(`    Filter — severity: ${criteria.severity.join(", ")}`);
+    if (criteria.ruleIds.length > 0)
+        console.log(`    Filter — rules: ${criteria.ruleIds.join(", ")}`);
+    if (criteria.minConfidence > 0)
+        console.log(`    Filter — min confidence: ${criteria.minConfidence}`);
+    if (criteria.titlePattern)
+        console.log(`    Filter — title pattern: ${criteria.titlePattern}`);
+    console.log();
+    for (const f of matched) {
+        const sev = f.severity || "unknown";
+        const line = f.lineNumbers && f.lineNumbers.length > 0 ? ` (L${f.lineNumbers[0]})` : "";
+        console.log(`    [${sev.toUpperCase()}] ${f.title || f.ruleId || "untitled"}${line}`);
+    }
+    if (matched.length === 0) {
+        console.log("    No findings match the specified criteria.");
+    }
+    console.log();
+}

package/dist/commands/review-finding-link.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Review-finding-link — Link related findings together.
+ *
+ * Identifies findings that share common patterns, lines, or rules
+ * and links them together for holistic remediation.
+ */
+export declare function runReviewFindingLink(argv: string[]): void;

package/dist/commands/review-finding-link.js

@@ -0,0 +1,115 @@
+/**
+ * Review-finding-link — Link related findings together.
+ *
+ * Identifies findings that share common patterns, lines, or rules
+ * and links them together for holistic remediation.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function findLinks(verdict) {
+    const links = [];
+    const findings = verdict.findings;
+    for (let i = 0; i < findings.length; i++) {
+        for (let j = i + 1; j < findings.length; j++) {
+            const a = findings[i];
+            const b = findings[j];
+            let strength = 0;
+            const linkTypes = [];
+            // Same rule
+            if (a.ruleId === b.ruleId) {
+                strength += 3;
+                linkTypes.push("same-rule");
+            }
+            // Shared line numbers
+            if (a.lineNumbers && b.lineNumbers) {
+                const shared = a.lineNumbers.filter((ln) => b.lineNumbers.includes(ln));
+                if (shared.length > 0) {
+                    strength += 2;
+                    linkTypes.push("shared-lines");
+                }
+            }
+            // Similar titles (word overlap)
+            const wordsA = new Set(a.title.toLowerCase().split(/\s+/));
+            const wordsB = new Set(b.title.toLowerCase().split(/\s+/));
+            const commonWords = [...wordsA].filter((w) => wordsB.has(w) && w.length > 3);
+            if (commonWords.length >= 2) {
+                strength += 1;
+                linkTypes.push("similar-title");
+            }
+            // Same severity
+            if ((a.severity || "medium") === (b.severity || "medium")) {
+                strength += 0.5;
+            }
+            if (strength >= 2) {
+                links.push({
+                    findingA: { ruleId: a.ruleId, title: a.title },
+                    findingB: { ruleId: b.ruleId, title: b.title },
+                    linkType: linkTypes.join(", "),
+                    strength,
+                });
+            }
+        }
+    }
+    return links.sort((a, b) => b.strength - a.strength);
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewFindingLink(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const formatIdx = argv.indexOf("--format");
+    const minIdx = argv.indexOf("--min-strength");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    const minStrength = minIdx >= 0 ? parseFloat(argv[minIdx + 1]) : 2;
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-finding-link — Link related findings
+
+Usage:
+  judges review-finding-link --file <verdict.json> [--format table|json]
+                              [--min-strength <n>]
+
+Options:
+  --file <path>           Path to verdict JSON file (required)
+  --format <fmt>          Output format: table (default), json
+  --min-strength <n>      Minimum link strength (default: 2)
+  --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;
+    }
+    const links = findLinks(verdict).filter((l) => l.strength >= minStrength);
+    if (format === "json") {
+        console.log(JSON.stringify(links, null, 2));
+        return;
+    }
+    if (links.length === 0) {
+        console.log("No linked findings detected.");
+        return;
+    }
+    console.log(`\nLinked Findings (${links.length} links)`);
+    console.log("═".repeat(70));
+    for (const l of links) {
+        console.log(`\n  [Strength: ${l.strength}] ${l.linkType}`);
+        console.log(`  A: ${l.findingA.title} (${l.findingA.ruleId})`);
+        console.log(`  B: ${l.findingB.title} (${l.findingB.ruleId})`);
+    }
+    console.log("\n" + "═".repeat(70));
+}

package/dist/commands/review-focus-area.d.ts

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

package/dist/commands/review-focus-area.js

@@ -0,0 +1,96 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function identifyFocusAreas(findings) {
+    const areas = [];
+    const rulesByDomain = new Map();
+    for (const f of findings) {
+        const domain = f.ruleId.split("-")[0];
+        const group = rulesByDomain.get(domain);
+        if (group !== undefined) {
+            group.push(f);
+        }
+        else {
+            rulesByDomain.set(domain, [f]);
+        }
+    }
+    for (const [domain, domainFindings] of rulesByDomain) {
+        const severities = domainFindings.map((f) => f.severity);
+        const hasCritical = severities.includes("critical");
+        const hasHigh = severities.includes("high");
+        let priority;
+        let description;
+        if (hasCritical) {
+            priority = "critical";
+            description = `Critical findings in ${domain} — immediate attention required`;
+        }
+        else if (hasHigh) {
+            priority = "high";
+            description = `High-severity issues in ${domain} — review carefully`;
+        }
+        else if (domainFindings.length >= 5) {
+            priority = "medium";
+            description = `Multiple ${domain} findings — pattern may indicate deeper issue`;
+        }
+        else {
+            priority = "low";
+            description = `Minor ${domain} findings — review when time permits`;
+        }
+        const topSeverity = hasCritical ? "critical" : hasHigh ? "high" : severities.includes("medium") ? "medium" : "low";
+        areas.push({
+            area: domain,
+            priority,
+            findingCount: domainFindings.length,
+            topSeverity,
+            description,
+        });
+    }
+    areas.sort((a, b) => {
+        const order = { critical: 0, high: 1, medium: 2, low: 3 };
+        return (order[a.priority] ?? 4) - (order[b.priority] ?? 4);
+    });
+    return areas;
+}
+export function runReviewFocusArea(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-focus-area [options]
+
+Identify focus areas for reviewers.
+
+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}`);
+        console.log("Run a review first or provide --report.");
+        return;
+    }
+    const data = JSON.parse(readFileSync(reportPath, "utf-8"));
+    const findings = data.findings ?? [];
+    if (findings.length === 0) {
+        console.log("No findings — no focus areas needed.");
+        return;
+    }
+    const areas = identifyFocusAreas(findings);
+    if (format === "json") {
+        console.log(JSON.stringify(areas, null, 2));
+        return;
+    }
+    console.log("\n=== Review Focus Areas ===\n");
+    console.log(`Total findings: ${findings.length}`);
+    console.log(`Focus areas: ${areas.length}\n`);
+    for (const area of areas) {
+        console.log(`[${area.priority.toUpperCase()}] ${area.area} — ${area.findingCount} finding(s)`);
+        console.log(`  Top severity: ${area.topSeverity}`);
+        console.log(`  ${area.description}`);
+        console.log();
+    }
+}

package/dist/commands/review-focus.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review focus — prioritize review attention for AI-generated changes.
+ */
+export declare function runReviewFocus(argv: string[]): void;

package/dist/commands/review-focus.js

@@ -0,0 +1,196 @@
+/**
+ * Review focus — prioritize review attention for AI-generated changes.
+ */
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join, extname, basename } from "path";
+// ─── File Collection ────────────────────────────────────────────────────────
+const CODE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", ".rs", ".cs"]);
+function collectFiles(dir, max = 300) {
+    const files = [];
+    function walk(d) {
+        if (files.length >= max)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (files.length >= max)
+                return;
+            if (e.startsWith(".") || e === "node_modules" || e === "dist" || e === "build")
+                continue;
+            const full = join(d, e);
+            try {
+                if (statSync(full).isDirectory())
+                    walk(full);
+                else if (CODE_EXTS.has(extname(full)))
+                    files.push(full);
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+// ─── Risk Analysis ──────────────────────────────────────────────────────────
+function analyzeFileRisk(filepath) {
+    let content;
+    try {
+        content = readFileSync(filepath, "utf-8");
+    }
+    catch {
+        return { file: filepath, priority: "low", score: 0, reasons: ["Could not read file"] };
+    }
+    const reasons = [];
+    let riskScore = 0;
+    const fname = basename(filepath).toLowerCase();
+    // Security-sensitive patterns
+    if (/(?:auth|login|session|token|jwt|oauth|password|credential|secret|crypto|encrypt|decrypt|hash)/i.test(fname)) {
+        riskScore += 30;
+        reasons.push("Security-sensitive filename");
+    }
+    if (/(?:sql|exec|spawn|eval|innerHTML|dangerouslySetInnerHTML)/.test(content)) {
+        riskScore += 25;
+        reasons.push("Contains dangerous operations (sql/exec/eval/innerHTML)");
+    }
+    // Data mutation
+    if (/(?:DELETE|INSERT|UPDATE|DROP|TRUNCATE)\s/i.test(content)) {
+        riskScore += 20;
+        reasons.push("Contains data mutation SQL statements");
+    }
+    // Payment/financial
+    if (/(?:payment|billing|invoice|charge|refund|stripe|paypal|transaction)/i.test(content)) {
+        riskScore += 25;
+        reasons.push("Payment/financial logic");
+    }
+    // External API calls
+    const apiCallCount = (content.match(/(?:fetch|axios|http\.(?:get|post|put|delete)|request\()/g) || []).length;
+    if (apiCallCount > 0) {
+        riskScore += apiCallCount * 5;
+        reasons.push(`${apiCallCount} external API calls`);
+    }
+    // Complexity indicators
+    const lines = content.split("\n");
+    const lineCount = lines.length;
+    if (lineCount > 300) {
+        riskScore += 10;
+        reasons.push(`Large file (${lineCount} lines)`);
+    }
+    // Deep nesting
+    let maxDepth = 0;
+    let depth = 0;
+    for (const line of lines) {
+        for (const ch of line) {
+            if (ch === "{")
+                depth++;
+            if (ch === "}")
+                depth--;
+            if (depth > maxDepth)
+                maxDepth = depth;
+        }
+    }
+    if (maxDepth > 5) {
+        riskScore += 10;
+        reasons.push(`Deep nesting (${maxDepth} levels)`);
+    }
+    // Error handling density
+    const tryCatchCount = (content.match(/try\s*\{/g) || []).length;
+    const funcCount = (content.match(/(?:function|=>)\s*[({]/g) || []).length;
+    if (funcCount > 3 && tryCatchCount < funcCount * 0.2) {
+        riskScore += 5;
+        reasons.push("Low error handling coverage");
+    }
+    // State management
+    if (/(?:useState|useReducer|createStore|createSlice|vuex|pinia)/i.test(content)) {
+        riskScore += 10;
+        reasons.push("Contains state management logic");
+    }
+    // Database operations
+    if (/(?:prisma|sequelize|typeorm|mongoose|knex|drizzle|\.query\(|\.execute\()/i.test(content)) {
+        riskScore += 15;
+        reasons.push("Database operations");
+    }
+    // Middleware / interceptors
+    if (/(?:middleware|interceptor|guard|pipe|filter)/i.test(fname)) {
+        riskScore += 15;
+        reasons.push("Middleware/interceptor (cross-cutting concern)");
+    }
+    // Route definitions
+    const routeCount = (content.match(/\.(get|post|put|patch|delete|use)\s*\(\s*['"]?\//g) || []).length;
+    if (routeCount > 0) {
+        riskScore += routeCount * 3;
+        reasons.push(`${routeCount} route definitions`);
+    }
+    // Configuration / environment
+    if (/(?:config|env|settings|options)/i.test(fname)) {
+        riskScore += 10;
+        reasons.push("Configuration file");
+    }
+    const priority = riskScore >= 50 ? "critical" : riskScore >= 30 ? "high" : riskScore >= 15 ? "medium" : "low";
+    return { file: filepath, priority, score: Math.min(100, riskScore), reasons };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewFocus(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-focus — Prioritize review attention for AI-generated changes
+
+Usage:
+  judges review-focus [dir]
+  judges review-focus src/ --format json
+
+Options:
+  [dir]                 Directory to scan (default: .)
+  --format json         JSON output
+  --top N               Show only top N files (default: 15)
+  --help, -h            Show this help
+
+Risk signals: security-sensitive files, dangerous operations, data mutation,
+payment logic, external APIs, deep nesting, state management, database ops,
+middleware, route definitions, configuration.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const dir = argv.find((a) => !a.startsWith("-") && argv.indexOf(a) > 0) || ".";
+    const topN = parseInt(argv.find((_a, i) => argv[i - 1] === "--top") || "15", 10);
+    const files = collectFiles(dir);
+    const allItems = files
+        .map((f) => analyzeFileRisk(f))
+        .filter((i) => i.score > 0)
+        .sort((a, b) => b.score - a.score);
+    if (format === "json") {
+        console.log(JSON.stringify({
+            items: allItems.slice(0, topN),
+            totalFiles: files.length,
+            scoredFiles: allItems.length,
+            timestamp: new Date().toISOString(),
+        }, null, 2));
+    }
+    else {
+        console.log(`\n  Review Focus — Top ${Math.min(topN, allItems.length)} of ${files.length} files\n  ─────────────────────────────`);
+        if (allItems.length === 0) {
+            console.log("    No high-risk files detected.\n");
+            return;
+        }
+        for (const item of allItems.slice(0, topN)) {
+            const icon = item.priority === "critical"
+                ? "🔴"
+                : item.priority === "high"
+                    ? "🟠"
+                    : item.priority === "medium"
+                        ? "🟡"
+                        : "🔵";
+            console.log(`    ${icon} [${item.score}] ${item.file}`);
+            console.log(`        ${item.reasons.join(" | ")}`);
+        }
+        const critCount = allItems.filter((i) => i.priority === "critical").length;
+        const highCount = allItems.filter((i) => i.priority === "high").length;
+        console.log(`\n    Critical: ${critCount} | High: ${highCount} | Total scored: ${allItems.length}/${files.length}\n`);
+    }
+}

package/dist/commands/review-gate-config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-gate-config — Configure quality gates for review pipelines.
+ */
+export declare function runReviewGateConfig(argv: string[]): void;