@kevinrabun/judges-cli 3.124.0

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

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

package/dist/commands/review-dependency-review.js

@@ -0,0 +1,104 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+const DEP_KEYWORDS = [
+    "dependency",
+    "dep",
+    "import",
+    "require",
+    "package",
+    "module",
+    "library",
+    "npm",
+    "version",
+    "outdated",
+    "vulnerable",
+    "supply-chain",
+];
+function isDependencyRelated(f) {
+    const lower = `${f.ruleId} ${f.title} ${f.description}`.toLowerCase();
+    return DEP_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function categorizeDep(f) {
+    const lower = `${f.ruleId} ${f.title} ${f.description}`.toLowerCase();
+    if (lower.includes("vulnerable") || lower.includes("cve"))
+        return "vulnerability";
+    if (lower.includes("outdated") || lower.includes("version"))
+        return "outdated";
+    if (lower.includes("supply-chain") || lower.includes("integrity"))
+        return "supply-chain";
+    if (lower.includes("unused") || lower.includes("dead"))
+        return "unused";
+    return "general";
+}
+function analyzeDependencies(findings) {
+    const depFindings = findings.filter(isDependencyRelated);
+    const bySeverity = {};
+    const byCategory = {};
+    const risks = [];
+    for (const f of depFindings) {
+        bySeverity[f.severity] = (bySeverity[f.severity] ?? 0) + 1;
+        const cat = categorizeDep(f);
+        byCategory[cat] = (byCategory[cat] ?? 0) + 1;
+        risks.push({
+            ruleId: f.ruleId,
+            title: f.title,
+            severity: f.severity,
+            category: cat,
+            recommendation: f.recommendation,
+        });
+    }
+    return {
+        totalDependencyFindings: depFindings.length,
+        bySeverity,
+        byCategory,
+        risks,
+    };
+}
+export function runReviewDependencyReview(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-dependency-review [options]
+
+Review dependency-related findings and risks.
+
+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 ?? [];
+    const summary = analyzeDependencies(findings);
+    if (format === "json") {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    console.log("\n=== Dependency Review ===\n");
+    console.log(`Dependency findings: ${summary.totalDependencyFindings} of ${findings.length} total\n`);
+    if (summary.totalDependencyFindings === 0) {
+        console.log("No dependency-related findings detected.");
+        return;
+    }
+    console.log("By severity:");
+    for (const [sev, count] of Object.entries(summary.bySeverity)) {
+        console.log(`  ${sev}: ${count}`);
+    }
+    console.log("\nBy category:");
+    for (const [cat, count] of Object.entries(summary.byCategory)) {
+        console.log(`  ${cat}: ${count}`);
+    }
+    console.log("\nRisks:");
+    for (const r of summary.risks) {
+        console.log(`  [${r.severity.toUpperCase()}] ${r.ruleId}: ${r.title} (${r.category})`);
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-deployment-gate — Configure deployment gates based on review thresholds.
+ */
+export declare function runReviewDeploymentGate(argv: string[]): void;

package/dist/commands/review-deployment-gate.js

@@ -0,0 +1,94 @@
+/**
+ * Review-deployment-gate — Configure deployment gates based on review thresholds.
+ */
+import { readFileSync, writeFileSync, existsSync } from "fs";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function evaluateGate(rule, metrics) {
+    const actual = metrics[rule.metric] ?? 0;
+    let passed = false;
+    if (rule.operator === "gte")
+        passed = actual >= rule.threshold;
+    else if (rule.operator === "lte")
+        passed = actual <= rule.threshold;
+    else if (rule.operator === "eq")
+        passed = actual === rule.threshold;
+    return {
+        name: rule.name,
+        metric: rule.metric,
+        threshold: rule.threshold,
+        actual,
+        passed,
+        blocking: rule.blocking,
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewDeploymentGate(argv) {
+    const configIdx = argv.indexOf("--config");
+    const configPath = configIdx >= 0 ? argv[configIdx + 1] : ".judges-deployment-gate.json";
+    const metricsIdx = argv.indexOf("--metrics");
+    const metricsPath = metricsIdx >= 0 ? argv[metricsIdx + 1] : "";
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    const initMode = argv.includes("--init");
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-deployment-gate — Configure deployment gates
+
+Usage:
+  judges review-deployment-gate --metrics <path> [--config <path>] [--format table|json]
+  judges review-deployment-gate --init [--config <path>]
+
+Options:
+  --metrics <path>  Path to metrics JSON ({score, criticalCount, highCount, totalFindings})
+  --config <path>   Gate config file (default: .judges-deployment-gate.json)
+  --init            Create default gate config
+  --format <fmt>    Output format: table (default), json
+  --help, -h        Show this help
+`);
+        return;
+    }
+    if (initMode) {
+        const defaultConfig = {
+            gates: [
+                { name: "Min Score", metric: "score", operator: "gte", threshold: 70, blocking: true },
+                { name: "No Criticals", metric: "criticalCount", operator: "lte", threshold: 0, blocking: true },
+                { name: "Max High", metric: "highCount", operator: "lte", threshold: 3, blocking: false },
+            ],
+            lastUpdated: new Date().toISOString(),
+        };
+        writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+        console.log(`Created default gate config: ${configPath}`);
+        return;
+    }
+    if (!metricsPath || !existsSync(metricsPath)) {
+        console.error("Provide --metrics <path> to a valid metrics JSON file.");
+        process.exitCode = 1;
+        return;
+    }
+    if (!existsSync(configPath)) {
+        console.error(`Gate config not found: ${configPath}. Run with --init to create one.`);
+        process.exitCode = 1;
+        return;
+    }
+    const metrics = JSON.parse(readFileSync(metricsPath, "utf-8"));
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const results = config.gates.map((g) => evaluateGate(g, metrics));
+    if (format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    const allPassed = results.every((r) => r.passed || !r.blocking);
+    console.log(`\nDeployment Gate Evaluation`);
+    console.log("═".repeat(70));
+    console.log(`  ${"Gate".padEnd(20)} ${"Metric".padEnd(18)} ${"Threshold".padEnd(12)} ${"Actual".padEnd(10)} Result`);
+    console.log("  " + "─".repeat(65));
+    for (const r of results) {
+        const status = r.passed ? "PASS" : r.blocking ? "BLOCK" : "WARN";
+        console.log(`  ${r.name.padEnd(20)} ${r.metric.padEnd(18)} ${String(r.threshold).padEnd(12)} ${String(r.actual).padEnd(10)} ${status}`);
+    }
+    console.log(`\n  Overall: ${allPassed ? "DEPLOY ALLOWED" : "DEPLOY BLOCKED"}`);
+    console.log("═".repeat(70));
+    if (!allPassed) {
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-depth — Control review depth (shallow, normal, deep).
+ */
+export declare function runReviewDepth(argv: string[]): void;

package/dist/commands/review-depth.js

@@ -0,0 +1,142 @@
+/**
+ * Review-depth — Control review depth (shallow, normal, deep).
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+// ─── Profiles ───────────────────────────────────────────────────────────────
+const PROFILES = {
+    shallow: {
+        level: "shallow",
+        maxJudges: 5,
+        enableAST: false,
+        enableCrossFile: false,
+        description: "Quick scan — top security rules only",
+    },
+    normal: {
+        level: "normal",
+        maxJudges: 20,
+        enableAST: true,
+        enableCrossFile: false,
+        description: "Standard review — core judges with AST",
+    },
+    deep: {
+        level: "deep",
+        maxJudges: 45,
+        enableAST: true,
+        enableCrossFile: true,
+        description: "Full review — all judges, cross-file analysis",
+    },
+};
+// ─── Storage ────────────────────────────────────────────────────────────────
+const DEPTH_FILE = ".judges/review-depth.json";
+function loadConfig() {
+    if (!existsSync(DEPTH_FILE))
+        return { version: "1.0.0", currentLevel: "normal", perPath: {} };
+    try {
+        return JSON.parse(readFileSync(DEPTH_FILE, "utf-8"));
+    }
+    catch {
+        return { version: "1.0.0", currentLevel: "normal", perPath: {} };
+    }
+}
+function saveConfig(config) {
+    mkdirSync(dirname(DEPTH_FILE), { recursive: true });
+    writeFileSync(DEPTH_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewDepth(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-depth — Control review depth
+
+Usage:
+  judges review-depth                                Show current depth
+  judges review-depth set --level deep
+  judges review-depth set-path --path src/auth --level deep
+  judges review-depth profiles
+  judges review-depth reset
+
+Subcommands:
+  (default)             Show current depth setting
+  set                   Set global review depth
+  set-path              Set depth for a specific path
+  profiles              Show available depth profiles
+  reset                 Reset to default (normal)
+
+Depth Levels:
+  shallow               Quick scan — top security rules only
+  normal                Standard review — core judges with AST
+  deep                  Full review — all judges, cross-file analysis
+
+Options:
+  --level <level>       Depth level: shallow, normal, deep
+  --path <path>         File or directory path
+  --format json         JSON output
+  --help, -h            Show this help
+
+Config stored in .judges/review-depth.json.
+`);
+        return;
+    }
+    const subcommand = argv.find((a) => ["set", "set-path", "profiles", "reset"].includes(a));
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const config = loadConfig();
+    if (subcommand === "set") {
+        const level = argv.find((_a, i) => argv[i - 1] === "--level");
+        if (!level || !PROFILES[level]) {
+            console.log("Invalid level. Use: shallow, normal, deep");
+            return;
+        }
+        config.currentLevel = level;
+        saveConfig(config);
+        console.log(`Review depth set to: ${level} — ${PROFILES[level].description}`);
+        return;
+    }
+    if (subcommand === "set-path") {
+        const path = argv.find((_a, i) => argv[i - 1] === "--path") || "";
+        const level = argv.find((_a, i) => argv[i - 1] === "--level");
+        if (!path || !level || !PROFILES[level]) {
+            console.log("Specify --path and --level (shallow, normal, deep).");
+            return;
+        }
+        config.perPath[path] = level;
+        saveConfig(config);
+        console.log(`Set ${path} → ${level}`);
+        return;
+    }
+    if (subcommand === "profiles") {
+        if (format === "json") {
+            console.log(JSON.stringify(PROFILES, null, 2));
+            return;
+        }
+        console.log("\nDepth Profiles:");
+        console.log("═".repeat(50));
+        for (const [, p] of Object.entries(PROFILES)) {
+            console.log(`  ${p.level.padEnd(10)} ${p.description}`);
+            console.log(`             judges=${p.maxJudges}  AST=${p.enableAST}  crossFile=${p.enableCrossFile}`);
+        }
+        console.log("═".repeat(50));
+        return;
+    }
+    if (subcommand === "reset") {
+        saveConfig({ version: "1.0.0", currentLevel: "normal", perPath: {} });
+        console.log("Review depth reset to normal.");
+        return;
+    }
+    // Default: show current
+    const profile = PROFILES[config.currentLevel];
+    if (format === "json") {
+        console.log(JSON.stringify({ current: config.currentLevel, profile, perPath: config.perPath }, null, 2));
+        return;
+    }
+    console.log(`\nCurrent Review Depth: ${config.currentLevel}`);
+    console.log(`  ${profile.description}`);
+    console.log(`  Max judges: ${profile.maxJudges}  AST: ${profile.enableAST}  Cross-file: ${profile.enableCrossFile}`);
+    const pathEntries = Object.entries(config.perPath);
+    if (pathEntries.length > 0) {
+        console.log("\nPath Overrides:");
+        for (const [p, l] of pathEntries) {
+            console.log(`  ${p} → ${l}`);
+        }
+    }
+}

package/dist/commands/review-diff-annotate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-diff-annotate — Annotate diff hunks with review findings.
+ */
+export declare function runReviewDiffAnnotate(argv: string[]): void;

package/dist/commands/review-diff-annotate.js

@@ -0,0 +1,104 @@
+/**
+ * Review-diff-annotate — Annotate diff hunks with review findings.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewDiffAnnotate(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-diff-annotate — Annotate diff hunks with review findings
+
+Usage:
+  judges review-diff-annotate --diff changes.diff --results results.json
+
+Options:
+  --diff <path>         Path to unified diff file
+  --results <path>      Path to review result JSON
+  --format json         JSON output
+  --help, -h            Show this help
+
+Overlays review findings onto diff output, showing which changed
+lines have associated findings.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const diffPath = argv.find((_a, i) => argv[i - 1] === "--diff") || "";
+    const resultsPath = argv.find((_a, i) => argv[i - 1] === "--results") || "";
+    if (!diffPath || !resultsPath) {
+        console.log("Specify --diff and --results paths.");
+        return;
+    }
+    if (!existsSync(diffPath)) {
+        console.log(`Diff file not found: ${diffPath}`);
+        return;
+    }
+    if (!existsSync(resultsPath)) {
+        console.log(`Results file not found: ${resultsPath}`);
+        return;
+    }
+    const diffContent = readFileSync(diffPath, "utf-8");
+    let data;
+    try {
+        data = JSON.parse(readFileSync(resultsPath, "utf-8"));
+    }
+    catch {
+        console.log(`Failed to parse results: ${resultsPath}`);
+        return;
+    }
+    const findings = Array.isArray(data.findings) ? data.findings : [];
+    const lineMap = new Map();
+    for (const f of findings) {
+        if (Array.isArray(f.lineNumbers)) {
+            for (const ln of f.lineNumbers) {
+                const existing = lineMap.get(ln) || [];
+                existing.push(f);
+                lineMap.set(ln, existing);
+            }
+        }
+    }
+    // Parse diff and annotate
+    const diffLines = diffContent.split("\n");
+    const annotated = [];
+    let currentLine = 0;
+    for (const line of diffLines) {
+        // Parse hunk header for line numbers
+        const hunkMatch = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)/);
+        if (hunkMatch) {
+            currentLine = parseInt(hunkMatch[1], 10) - 1;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            currentLine++;
+            const matched = lineMap.get(currentLine) || [];
+            annotated.push({ line, findings: matched });
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            annotated.push({ line, findings: [] });
+        }
+        else {
+            if (!line.startsWith("---") && !line.startsWith("+++") && !line.startsWith("@@")) {
+                currentLine++;
+            }
+            annotated.push({ line, findings: [] });
+        }
+    }
+    const annotatedCount = annotated.filter((a) => a.findings.length > 0).length;
+    if (format === "json") {
+        console.log(JSON.stringify({ totalLines: diffLines.length, annotatedLines: annotatedCount, findings: findings.length }, null, 2));
+        return;
+    }
+    console.log(`\nAnnotated Diff (${annotatedCount} lines with findings):`);
+    console.log("═".repeat(70));
+    for (const a of annotated) {
+        if (a.findings.length > 0) {
+            console.log(a.line);
+            for (const f of a.findings) {
+                console.log(`  >>> [${String(f.severity || "?").toUpperCase()}] ${f.ruleId || ""}: ${f.title || ""}`);
+            }
+        }
+        else {
+            console.log(a.line);
+        }
+    }
+    console.log("═".repeat(70));
+}

package/dist/commands/review-diff-context.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-diff-context — Provide additional context around diff hunks for reviews.
+ */
+export declare function runReviewDiffContext(argv: string[]): void;

package/dist/commands/review-diff-context.js

@@ -0,0 +1,158 @@
+/**
+ * Review-diff-context — Provide additional context around diff hunks for reviews.
+ */
+import { readFileSync, existsSync } from "fs";
+import { runGit } from "../tools/command-safety.js";
+// ─── Diff Parsing ───────────────────────────────────────────────────────────
+function parseDiffOutput(diffText, contextLines) {
+    const hunks = [];
+    const lines = diffText.split("\n");
+    let currentFile = "";
+    let hunkLines = [];
+    let hunkStart = 0;
+    for (const line of lines) {
+        if (line.startsWith("+++ b/")) {
+            currentFile = line.slice(6);
+            continue;
+        }
+        if (line.startsWith("--- "))
+            continue;
+        if (line.startsWith("@@ ")) {
+            // Flush previous hunk
+            if (hunkLines.length > 0 && currentFile) {
+                hunks.push(buildHunk(currentFile, hunkStart, hunkLines, contextLines));
+                hunkLines = [];
+            }
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)/);
+            hunkStart = match ? parseInt(match[1], 10) : 1;
+            continue;
+        }
+        if (line.startsWith("diff --git")) {
+            // Flush previous hunk
+            if (hunkLines.length > 0 && currentFile) {
+                hunks.push(buildHunk(currentFile, hunkStart, hunkLines, contextLines));
+                hunkLines = [];
+            }
+            continue;
+        }
+        if (currentFile && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
+            hunkLines.push(line);
+        }
+    }
+    // Flush final hunk
+    if (hunkLines.length > 0 && currentFile) {
+        hunks.push(buildHunk(currentFile, hunkStart, hunkLines, contextLines));
+    }
+    return hunks;
+}
+function buildHunk(file, startLine, lines, contextLines) {
+    const content = lines.join("\n");
+    const endLine = startLine + lines.filter((l) => !l.startsWith("-")).length - 1;
+    const contextBefore = [];
+    const contextAfter = [];
+    // Try to read surrounding context from the file
+    if (existsSync(file)) {
+        try {
+            const fileLines = readFileSync(file, "utf-8").split("\n");
+            const bStart = Math.max(0, startLine - 1 - contextLines);
+            const bEnd = Math.max(0, startLine - 1);
+            for (let i = bStart; i < bEnd; i++) {
+                contextBefore.push(fileLines[i] || "");
+            }
+            const aStart = endLine;
+            const aEnd = Math.min(fileLines.length, endLine + contextLines);
+            for (let i = aStart; i < aEnd; i++) {
+                contextAfter.push(fileLines[i] || "");
+            }
+        }
+        catch {
+            // File unreadable, skip context
+        }
+    }
+    return { file, startLine, endLine, content, context: { before: contextBefore, after: contextAfter } };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewDiffContext(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-diff-context — Provide additional context for diff reviews
+
+Usage:
+  judges review-diff-context                         Show diff with context
+  judges review-diff-context --context 10            Custom context lines
+  judges review-diff-context --ref HEAD~3            Compare against a ref
+  judges review-diff-context --file src/api.ts       Focus on specific file
+
+Options:
+  --context <n>         Number of context lines (default: 5)
+  --ref <gitref>        Git ref to compare against (default: HEAD~1)
+  --file <path>         Focus on a specific file
+  --staged              Show only staged changes
+  --format json         JSON output
+  --help, -h            Show this help
+
+Shows diff hunks with surrounding file context to help reviewers
+understand the broader code landscape around changes.
+`);
+        return;
+    }
+    const contextLines = parseInt(argv.find((_a, i) => argv[i - 1] === "--context") || "5", 10);
+    const ref = argv.find((_a, i) => argv[i - 1] === "--ref") || "HEAD~1";
+    const fileFilter = argv.find((_a, i) => argv[i - 1] === "--file");
+    const staged = argv.includes("--staged");
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    // Get diff
+    let diffText;
+    try {
+        const diffArgs = staged ? ["diff", "--staged"] : ["diff", ref];
+        if (fileFilter)
+            diffArgs.push("--", fileFilter);
+        diffText = runGit(diffArgs, { trim: false, maxBuffer: 10 * 1024 * 1024 });
+    }
+    catch {
+        console.error("Error: Could not run git diff. Are you in a git repository?");
+        process.exitCode = 1;
+        return;
+    }
+    if (!diffText.trim()) {
+        console.log("No changes found.");
+        return;
+    }
+    const hunks = parseDiffOutput(diffText, contextLines);
+    const uniqueFiles = new Set(hunks.map((h) => h.file));
+    const report = {
+        timestamp: new Date().toISOString(),
+        contextLines,
+        hunks,
+        totalFiles: uniqueFiles.size,
+    };
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log("\nDiff Context Report:");
+    console.log("═".repeat(70));
+    console.log(`  Files changed: ${uniqueFiles.size}  Hunks: ${hunks.length}  Context: ±${contextLines} lines`);
+    console.log("═".repeat(70));
+    for (const hunk of hunks) {
+        console.log(`\n  ── ${hunk.file} (lines ${hunk.startLine}–${hunk.endLine}) ──`);
+        if (hunk.context.before.length > 0) {
+            console.log("  [context before]");
+            for (const l of hunk.context.before) {
+                console.log(`    │ ${l}`);
+            }
+        }
+        console.log("  [changes]");
+        for (const l of hunk.content.split("\n")) {
+            const prefix = l.startsWith("+") ? "  + " : l.startsWith("-") ? "  - " : "    ";
+            console.log(`${prefix}${l.slice(1)}`);
+        }
+        if (hunk.context.after.length > 0) {
+            console.log("  [context after]");
+            for (const l of hunk.context.after) {
+                console.log(`    │ ${l}`);
+            }
+        }
+    }
+    console.log("\n" + "═".repeat(70));
+}

package/dist/commands/review-diff-highlight.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-diff-highlight — Highlight key differences in review findings.
+ */
+export declare function runReviewDiffHighlight(argv: string[]): void;