@kevinrabun/judges-cli 3.124.0

package/dist/commands/review-lock-file.js

@@ -0,0 +1,153 @@
+/**
+ * Review-lock-file — Analyze lock files for security and consistency issues.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function analyzeNpmLock(content) {
+    const issues = [];
+    let lockData;
+    try {
+        lockData = JSON.parse(content);
+    }
+    catch {
+        return [
+            { type: "integrity-missing", package: "(parse-error)", detail: "Invalid JSON in lock file", severity: "high" },
+        ];
+    }
+    const packages = (lockData.packages || lockData.dependencies || {});
+    for (const [name, info] of Object.entries(packages)) {
+        if (!name || name === "")
+            continue;
+        // check for missing integrity
+        if (info !== null && info !== undefined && !info.integrity && !name.startsWith("node_modules")) {
+            // Only flag actual packages, not the root
+            if (name !== "" && info.version !== undefined) {
+                issues.push({
+                    type: "integrity-missing",
+                    package: name,
+                    detail: "No integrity hash — supply chain risk",
+                    severity: "high",
+                });
+            }
+        }
+        // check for git dependencies
+        const resolved = String(info.resolved || "");
+        if (resolved.startsWith("git+") || resolved.startsWith("git://") || /(:?\/\/|@)github\.com[/:]/.test(resolved)) {
+            issues.push({
+                type: "git-dependency",
+                package: name,
+                detail: `Git dependency: ${resolved.slice(0, 60)}`,
+                severity: "medium",
+            });
+        }
+        // check for http (non-https) registry
+        if (resolved.startsWith("http://")) {
+            issues.push({
+                type: "http-registry",
+                package: name,
+                detail: "Uses HTTP instead of HTTPS — insecure transport",
+                severity: "high",
+            });
+        }
+    }
+    return issues;
+}
+function analyzeYarnLock(content) {
+    const issues = [];
+    const lines = content.split("\n");
+    let currentPkg = "";
+    for (const line of lines) {
+        if (line.startsWith('"') || (line.startsWith("@") && line.includes('"'))) {
+            currentPkg = line.replace(/[",:]/g, "").trim().split("@")[0] || line.replace(/[",:]/g, "").trim();
+        }
+        if (line.includes("resolved") && line.includes("http://")) {
+            issues.push({
+                type: "http-registry",
+                package: currentPkg,
+                detail: "Uses HTTP instead of HTTPS",
+                severity: "high",
+            });
+        }
+        if (line.includes("resolved") && (/(:?\/\/|@)github\.com[/:]/.test(line) || line.includes("git+"))) {
+            issues.push({
+                type: "git-dependency",
+                package: currentPkg,
+                detail: "Git dependency detected",
+                severity: "medium",
+            });
+        }
+    }
+    return issues;
+}
+function analyzeLockFile(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    if (filePath.endsWith("package-lock.json")) {
+        return analyzeNpmLock(content);
+    }
+    if (filePath.endsWith("yarn.lock")) {
+        return analyzeYarnLock(content);
+    }
+    return [{ type: "integrity-missing", package: "(unknown)", detail: "Unsupported lock file format", severity: "low" }];
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewLockFile(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-lock-file — Analyze lock files for security issues
+
+Usage:
+  judges review-lock-file --file <lock-file> [--format table|json]
+
+Options:
+  --file <path>      Path to lock file (package-lock.json, yarn.lock)
+  --format <fmt>     Output format: table (default), json
+  --help, -h         Show this help
+
+Checks:
+  - Missing integrity hashes
+  - HTTP (insecure) registries
+  - Git dependencies
+  - Registry mismatches
+`);
+        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;
+    }
+    const issues = analyzeLockFile(filePath);
+    if (format === "json") {
+        console.log(JSON.stringify(issues, null, 2));
+        return;
+    }
+    const high = issues.filter((i) => i.severity === "high").length;
+    const medium = issues.filter((i) => i.severity === "medium").length;
+    const low = issues.filter((i) => i.severity === "low").length;
+    console.log(`\nLock File Analysis: ${filePath}`);
+    console.log("═".repeat(75));
+    console.log(`  Issues: ${issues.length} (${high} high, ${medium} medium, ${low} low)`);
+    console.log("─".repeat(75));
+    if (issues.length === 0) {
+        console.log("  No issues found — lock file looks clean.");
+    }
+    else {
+        console.log(`${"Severity".padEnd(10)} ${"Type".padEnd(20)} ${"Package".padEnd(25)} Detail`);
+        console.log("─".repeat(75));
+        for (const issue of issues) {
+            const pkg = issue.package.length > 23 ? issue.package.slice(0, 23) + "…" : issue.package;
+            const detail = issue.detail.length > 30 ? issue.detail.slice(0, 30) + "…" : issue.detail;
+            console.log(`${issue.severity.padEnd(10)} ${issue.type.padEnd(20)} ${pkg.padEnd(25)} ${detail}`);
+        }
+    }
+    console.log("═".repeat(75));
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-lock — Lock reviews to prevent accidental re-runs.
+ */
+export declare function runReviewLock(argv: string[]): void;

package/dist/commands/review-lock.js

@@ -0,0 +1,107 @@
+/**
+ * Review-lock — Lock reviews to prevent accidental re-runs.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const LOCK_FILE = ".judges/review-locks.json";
+function loadStore() {
+    if (!existsSync(LOCK_FILE))
+        return { version: "1.0.0", locks: [] };
+    try {
+        return JSON.parse(readFileSync(LOCK_FILE, "utf-8"));
+    }
+    catch {
+        return { version: "1.0.0", locks: [] };
+    }
+}
+function saveStore(store) {
+    mkdirSync(dirname(LOCK_FILE), { recursive: true });
+    writeFileSync(LOCK_FILE, JSON.stringify(store, null, 2), "utf-8");
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewLock(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-lock — Lock reviews to prevent re-runs
+
+Usage:
+  judges review-lock add --file src/app.ts --reason "approved"
+  judges review-lock check --file src/app.ts
+  judges review-lock list
+  judges review-lock remove --file src/app.ts
+  judges review-lock clear
+
+Subcommands:
+  add                   Lock a file
+  check                 Check if a file is locked
+  list                  List all locks
+  remove                Unlock a file
+  clear                 Clear all locks
+
+Options:
+  --file <path>         File path
+  --reason <text>       Lock reason
+  --format json         JSON output
+  --help, -h            Show this help
+
+Locks stored in .judges/review-locks.json.
+`);
+        return;
+    }
+    const subcommand = argv.find((a) => ["add", "check", "list", "remove", "clear"].includes(a));
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const store = loadStore();
+    if (subcommand === "add") {
+        const file = argv.find((_a, i) => argv[i - 1] === "--file") || "";
+        const reason = argv.find((_a, i) => argv[i - 1] === "--reason") || "";
+        if (!file) {
+            console.log("Specify --file.");
+            return;
+        }
+        store.locks = store.locks.filter((l) => l.file !== file);
+        store.locks.push({ file, lockedAt: new Date().toISOString(), reason });
+        saveStore(store);
+        console.log(`Locked: ${file}`);
+        return;
+    }
+    if (subcommand === "check") {
+        const file = argv.find((_a, i) => argv[i - 1] === "--file") || "";
+        const lock = store.locks.find((l) => l.file === file);
+        if (lock) {
+            console.log(`LOCKED: ${file} — ${lock.reason} (${lock.lockedAt.slice(0, 10)})`);
+        }
+        else {
+            console.log(`Not locked: ${file}`);
+        }
+        return;
+    }
+    if (subcommand === "remove") {
+        const file = argv.find((_a, i) => argv[i - 1] === "--file") || "";
+        const before = store.locks.length;
+        store.locks = store.locks.filter((l) => l.file !== file);
+        saveStore(store);
+        console.log(before > store.locks.length ? `Unlocked: ${file}` : `${file} was not locked.`);
+        return;
+    }
+    if (subcommand === "clear") {
+        saveStore({ version: "1.0.0", locks: [] });
+        console.log("All locks cleared.");
+        return;
+    }
+    // Default: list
+    if (store.locks.length === 0) {
+        console.log("No review locks.");
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(store.locks, null, 2));
+        return;
+    }
+    console.log(`\nReview Locks (${store.locks.length}):`);
+    console.log("─".repeat(50));
+    for (const l of store.locks) {
+        console.log(`  ${l.file}  ${l.lockedAt.slice(0, 10)}  ${l.reason}`);
+    }
+    console.log("─".repeat(50));
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Review-log — Structured audit log of all review actions for compliance.
+ */
+interface ReviewLogEntry {
+    timestamp: string;
+    action: string;
+    command: string;
+    filesReviewed: number;
+    findingsCount: number;
+    severity: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    duration: number;
+    user: string;
+    commit: string;
+}
+declare function appendLog(entry: ReviewLogEntry): void;
+export declare function runReviewLog(argv: string[]): void;
+export { appendLog, ReviewLogEntry };

package/dist/commands/review-log.js

@@ -0,0 +1,164 @@
+/**
+ * Review-log — Structured audit log of all review actions for compliance.
+ */
+import { readFileSync, existsSync, mkdirSync, appendFileSync, readdirSync } from "fs";
+import { join } from "path";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function getLogDir() {
+    return join(".", ".judges", "logs");
+}
+function getLogFile() {
+    const dir = getLogDir();
+    const date = new Date().toISOString().slice(0, 7); // YYYY-MM
+    return join(dir, `review-log-${date}.jsonl`);
+}
+function appendLog(entry) {
+    const dir = getLogDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const logFile = getLogFile();
+    appendFileSync(logFile, JSON.stringify(entry) + "\n", "utf-8");
+}
+function readAllLogs() {
+    const dir = getLogDir();
+    if (!existsSync(dir))
+        return [];
+    const entries = [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+    for (const f of files) {
+        try {
+            const content = readFileSync(join(dir, f), "utf-8");
+            const lines = content.split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    // skip invalid lines
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return entries;
+}
+function summarizeLogs(entries) {
+    if (entries.length === 0) {
+        return {
+            totalEntries: 0,
+            recentEntries: [],
+            totalFilesReviewed: 0,
+            totalFindings: 0,
+            averageDuration: 0,
+            firstEntry: "",
+            lastEntry: "",
+        };
+    }
+    const sorted = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const totalFiles = entries.reduce((s, e) => s + e.filesReviewed, 0);
+    const totalFindings = entries.reduce((s, e) => s + e.findingsCount, 0);
+    const totalDuration = entries.reduce((s, e) => s + e.duration, 0);
+    return {
+        totalEntries: entries.length,
+        recentEntries: sorted.slice(-10),
+        totalFilesReviewed: totalFiles,
+        totalFindings,
+        averageDuration: Math.round(totalDuration / entries.length),
+        firstEntry: sorted[0].timestamp,
+        lastEntry: sorted[sorted.length - 1].timestamp,
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewLog(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-log — Structured audit log of review actions
+
+Usage:
+  judges review-log show                    Show log summary
+  judges review-log record --command eval --files 10 --findings 5
+  judges review-log export                  Export all logs as JSON
+  judges review-log --format json           JSON output
+
+Subcommands:
+  show                 Show log summary and recent entries
+  record               Record a review action to the log
+  export               Export complete log as JSON
+
+Record Options:
+  --command <name>     Command that was run
+  --files <n>          Number of files reviewed
+  --findings <n>       Number of findings
+  --critical <n>       Critical findings count
+  --high <n>           High findings count
+  --medium <n>         Medium findings count
+  --low <n>            Low findings count
+  --duration <ms>      Duration in milliseconds
+  --commit <hash>      Associated commit
+
+Logs are stored locally in .judges/logs/ as monthly JSONL files.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const subcommand = argv.find((a) => !a.startsWith("-") && a !== "review-log") || "show";
+    if (subcommand === "record") {
+        const getNum = (flag) => {
+            const val = argv.find((_a, i) => argv[i - 1] === flag);
+            return val ? parseInt(val, 10) : 0;
+        };
+        const getStr = (flag) => {
+            return argv.find((_a, i) => argv[i - 1] === flag) || "";
+        };
+        const entry = {
+            timestamp: new Date().toISOString(),
+            action: "review",
+            command: getStr("--command") || "unknown",
+            filesReviewed: getNum("--files"),
+            findingsCount: getNum("--findings"),
+            severity: {
+                critical: getNum("--critical"),
+                high: getNum("--high"),
+                medium: getNum("--medium"),
+                low: getNum("--low"),
+            },
+            duration: getNum("--duration"),
+            user: process.env.USER || process.env.USERNAME || "unknown",
+            commit: getStr("--commit"),
+        };
+        appendLog(entry);
+        console.log(`Logged review action: ${entry.command} (${entry.findingsCount} findings, ${entry.filesReviewed} files).`);
+        return;
+    }
+    if (subcommand === "export") {
+        const entries = readAllLogs();
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    // Show
+    const entries = readAllLogs();
+    const summary = summarizeLogs(entries);
+    if (format === "json") {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    console.log(`\n  Review Log\n  ─────────────────────────────`);
+    console.log(`    Total entries: ${summary.totalEntries}`);
+    console.log(`    Total files reviewed: ${summary.totalFilesReviewed}`);
+    console.log(`    Total findings: ${summary.totalFindings}`);
+    console.log(`    Average duration: ${summary.averageDuration}ms`);
+    if (summary.firstEntry) {
+        console.log(`    Period: ${summary.firstEntry.slice(0, 10)} to ${summary.lastEntry.slice(0, 10)}`);
+    }
+    if (summary.recentEntries.length > 0) {
+        console.log("\n    Recent entries:");
+        for (const e of summary.recentEntries) {
+            console.log(`      ${e.timestamp.slice(0, 19)} ${e.command} — ${e.findingsCount} findings, ${e.filesReviewed} files, ${e.duration}ms`);
+        }
+    }
+    console.log();
+}
+// Export for use by other commands
+export { appendLog };

package/dist/commands/review-mentor-suggest.d.ts

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

package/dist/commands/review-mentor-suggest.js

@@ -0,0 +1,112 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+function extractDomain(ruleId) {
+    const parts = ruleId.split("/");
+    return parts.length > 1 ? parts[0] : "general";
+}
+function buildProfiles(historyDir) {
+    if (!existsSync(historyDir))
+        return [];
+    const files = readdirSync(historyDir);
+    const jsonFiles = files.filter((f) => String(f).endsWith(".json"));
+    const domainScores = {};
+    for (const file of jsonFiles) {
+        const raw = readFileSync(join(historyDir, String(file)), "utf-8");
+        let verdict;
+        try {
+            verdict = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const reviewer = String(file)
+            .replace(/\.json$/, "")
+            .replace(/[-_]\d+$/, "");
+        if (!domainScores[reviewer])
+            domainScores[reviewer] = {};
+        const domainCounts = {};
+        for (const f of verdict.findings ?? []) {
+            const domain = extractDomain(f.ruleId);
+            domainCounts[domain] = (domainCounts[domain] ?? 0) + 1;
+        }
+        for (const domain of Object.keys(domainCounts)) {
+            if (!domainScores[reviewer][domain]) {
+                domainScores[reviewer][domain] = { total: 0, findings: 0 };
+            }
+            domainScores[reviewer][domain].total += 1;
+            domainScores[reviewer][domain].findings += domainCounts[domain];
+        }
+    }
+    const profiles = [];
+    for (const [reviewer, domains] of Object.entries(domainScores)) {
+        const strengths = [];
+        const weaknesses = [];
+        for (const [domain, stats] of Object.entries(domains)) {
+            const avgFindings = stats.findings / stats.total;
+            if (avgFindings <= 1) {
+                strengths.push(domain);
+            }
+            else if (avgFindings >= 3) {
+                weaknesses.push(domain);
+            }
+        }
+        profiles.push({ reviewer, strengths, weaknesses });
+    }
+    return profiles;
+}
+function suggestPairings(profiles) {
+    const pairings = [];
+    for (const mentee of profiles) {
+        for (const weakness of mentee.weaknesses) {
+            const mentor = profiles.find((p) => p.reviewer !== mentee.reviewer && p.strengths.includes(weakness));
+            if (mentor) {
+                pairings.push({
+                    mentee: mentee.reviewer,
+                    mentor: mentor.reviewer,
+                    domain: weakness,
+                    reason: `${mentor.reviewer} shows strength in "${weakness}" where ${mentee.reviewer} has frequent findings`,
+                });
+            }
+        }
+    }
+    return pairings;
+}
+export function runReviewMentorSuggest(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`Usage: judges review-mentor-suggest [options]
+
+Suggest mentor pairings based on expertise gaps in review history.
+
+Options:
+  --history <dir>      Directory with verdict JSON files (default: .judges/history)
+  --format <fmt>       Output format: table (default) or json
+  -h, --help           Show this help message`);
+        return;
+    }
+    const formatIdx = argv.indexOf("--format");
+    const format = formatIdx !== -1 && argv[formatIdx + 1] ? argv[formatIdx + 1] : "table";
+    const histIdx = argv.indexOf("--history");
+    const historyDir = histIdx !== -1 && argv[histIdx + 1]
+        ? join(process.cwd(), argv[histIdx + 1])
+        : join(process.cwd(), ".judges", "history");
+    const profiles = buildProfiles(historyDir);
+    if (profiles.length === 0) {
+        console.log("No reviewer profiles found. Run some reviews first.");
+        return;
+    }
+    const pairings = suggestPairings(profiles);
+    if (format === "json") {
+        console.log(JSON.stringify({ profiles, pairings }, null, 2));
+        return;
+    }
+    console.log(`\n=== Mentor Suggestions (${pairings.length} pairings) ===\n`);
+    if (pairings.length === 0) {
+        console.log("No clear mentor pairings identified — team expertise is well-distributed.");
+        return;
+    }
+    for (const p of pairings) {
+        console.log(`  ${p.mentee}  <--  ${p.mentor}  (domain: ${p.domain})`);
+        console.log(`           ${p.reason}`);
+        console.log();
+    }
+}

package/dist/commands/review-merge-check.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Review-merge-check — Pre-merge review validation.
+ */
+export declare function runReviewMergeCheck(argv: string[]): void;

package/dist/commands/review-merge-check.js

@@ -0,0 +1,101 @@
+/**
+ * Review-merge-check — Pre-merge review validation.
+ */
+import { readFileSync, existsSync } from "fs";
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runReviewMergeCheck(argv) {
+    const fileIdx = argv.indexOf("--file");
+    const strictIdx = argv.indexOf("--strict");
+    const formatIdx = argv.indexOf("--format");
+    const filePath = fileIdx >= 0 ? argv[fileIdx + 1] : undefined;
+    const strict = strictIdx >= 0;
+    const format = formatIdx >= 0 ? argv[formatIdx + 1] : "table";
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges review-merge-check — Pre-merge review validation
+
+Usage:
+  judges review-merge-check --file <verdict.json> [--strict] [--format table|json]
+
+Options:
+  --file <path>      Path to verdict JSON file (required)
+  --strict           Enable strict mode (no critical or high findings)
+  --format <fmt>     Output format: table (default), json
+  --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 checks = [];
+    // Check 1: No critical findings
+    checks.push({
+        name: "No critical findings",
+        passed: verdict.criticalCount === 0,
+        detail: verdict.criticalCount === 0 ? "No critical findings" : `${verdict.criticalCount} critical finding(s)`,
+    });
+    // Check 2: Score above threshold
+    const scoreThreshold = strict ? 70 : 40;
+    checks.push({
+        name: `Score ≥ ${scoreThreshold}`,
+        passed: verdict.overallScore >= scoreThreshold,
+        detail: `Score: ${verdict.overallScore}`,
+    });
+    // Check 3: Verdict is not fail (in unstrict mode)
+    checks.push({
+        name: "Verdict is not fail",
+        passed: verdict.overallVerdict !== "fail",
+        detail: `Verdict: ${verdict.overallVerdict}`,
+    });
+    // Check 4: (strict) No high findings
+    if (strict) {
+        checks.push({
+            name: "No high findings",
+            passed: verdict.highCount === 0,
+            detail: verdict.highCount === 0 ? "No high findings" : `${verdict.highCount} high finding(s)`,
+        });
+    }
+    // Check 5: (strict) Limited total findings
+    if (strict) {
+        checks.push({
+            name: "Total findings ≤ 10",
+            passed: verdict.findings.length <= 10,
+            detail: `${verdict.findings.length} total finding(s)`,
+        });
+    }
+    const canMerge = checks.every((c) => c.passed);
+    const result = { canMerge, checks, verdict: verdict.overallVerdict, score: verdict.overallScore };
+    if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`\nMerge Check Results${strict ? " (strict)" : ""}`);
+    console.log("═".repeat(55));
+    for (const c of checks) {
+        const icon = c.passed ? "PASS" : "FAIL";
+        console.log(`  [${icon}] ${c.name}`);
+        console.log(`         ${c.detail}`);
+    }
+    console.log("═".repeat(55));
+    console.log(`\nResult: ${canMerge ? "MERGE ALLOWED" : "MERGE BLOCKED"}`);
+    if (!canMerge) {
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Review-merge-config — Merge multiple Judges configuration files.
+ */
+export declare function runReviewMergeConfig(argv: string[]): void;