@kevinrabun/judges-cli 3.124.0

package/dist/commands/coverage-map.js

@@ -0,0 +1,222 @@
+/**
+ * Rule coverage map — show which rules apply to which languages,
+ * helping teams understand their coverage and identify gaps.
+ */
+// ─── Rules-to-Language Mapping ──────────────────────────────────────────────
+/**
+ * Universal rules applicable to all programming languages.
+ */
+const UNIVERSAL_RULES = [
+    { pattern: "SEC-", judge: "cybersecurity", severity: "high" },
+    { pattern: "ERR-", judge: "error-handling", severity: "medium" },
+    { pattern: "MAINT-", judge: "maintainability", severity: "low" },
+    { pattern: "DOC-", judge: "documentation", severity: "low" },
+    { pattern: "STRUCT-", judge: "code-structure", severity: "medium" },
+    { pattern: "TEST-", judge: "testing", severity: "medium" },
+    { pattern: "LOG-", judge: "logging-privacy", severity: "medium" },
+    { pattern: "AI-", judge: "ai-code-safety", severity: "high" },
+];
+/**
+ * Language-specific rules with limited applicability.
+ */
+const LANGUAGE_RULES = [
+    {
+        pattern: "INJECT-SQL",
+        judge: "cybersecurity",
+        severity: "critical",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "php", "ruby", "go"],
+    },
+    {
+        pattern: "INJECT-CMD",
+        judge: "cybersecurity",
+        severity: "critical",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "php", "ruby", "go", "rust"],
+    },
+    {
+        pattern: "XSS-",
+        judge: "cybersecurity",
+        severity: "high",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "php", "ruby"],
+    },
+    {
+        pattern: "SSRF-",
+        judge: "cybersecurity",
+        severity: "high",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "go", "ruby"],
+    },
+    {
+        pattern: "CRYPTO-",
+        judge: "cybersecurity",
+        severity: "high",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "c", "cpp"],
+    },
+    {
+        pattern: "AUTH-",
+        judge: "authentication",
+        severity: "high",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "go", "ruby", "php"],
+    },
+    {
+        pattern: "PERF-",
+        judge: "performance",
+        severity: "medium",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "c", "cpp"],
+    },
+    {
+        pattern: "DB-",
+        judge: "database",
+        severity: "medium",
+        languages: ["typescript", "javascript", "python", "java", "csharp", "go", "ruby", "sql"],
+    },
+    { pattern: "IAC-", judge: "iac-security", severity: "high", languages: ["terraform", "bicep", "yaml", "dockerfile"] },
+    { pattern: "CICD-", judge: "ci-cd", severity: "high", languages: ["yaml", "dockerfile", "bash", "powershell"] },
+    {
+        pattern: "CONCUR-",
+        judge: "concurrency",
+        severity: "high",
+        languages: ["go", "rust", "java", "csharp", "python", "c", "cpp"],
+    },
+    { pattern: "A11Y-", judge: "accessibility", severity: "medium", languages: ["typescript", "javascript", "html"] },
+    {
+        pattern: "I18N-",
+        judge: "internationalization",
+        severity: "low",
+        languages: ["typescript", "javascript", "python", "java", "csharp"],
+    },
+    { pattern: "FW-REACT", judge: "framework-safety", severity: "high", languages: ["typescript", "javascript"] },
+    { pattern: "FW-EXPRESS", judge: "framework-safety", severity: "high", languages: ["typescript", "javascript"] },
+    { pattern: "FW-DJANGO", judge: "framework-safety", severity: "high", languages: ["python"] },
+    { pattern: "FW-FLASK", judge: "framework-safety", severity: "high", languages: ["python"] },
+    { pattern: "FW-SPRING", judge: "framework-safety", severity: "high", languages: ["java", "kotlin"] },
+    { pattern: "FW-RAILS", judge: "framework-safety", severity: "high", languages: ["ruby"] },
+    { pattern: "FW-NEXT", judge: "framework-safety", severity: "high", languages: ["typescript", "javascript"] },
+    { pattern: "FW-FASTAPI", judge: "framework-safety", severity: "high", languages: ["python"] },
+];
+const ALL_LANGUAGES = [
+    "typescript",
+    "javascript",
+    "python",
+    "java",
+    "csharp",
+    "go",
+    "rust",
+    "ruby",
+    "php",
+    "c",
+    "cpp",
+    "kotlin",
+    "scala",
+    "swift",
+    "dart",
+    "bash",
+    "powershell",
+    "sql",
+    "terraform",
+    "bicep",
+    "yaml",
+    "dockerfile",
+    "html",
+];
+// ─── Coverage Computation ───────────────────────────────────────────────────
+export function buildCoverageMap(languages) {
+    const langs = languages || ALL_LANGUAGES;
+    const rules = [];
+    const matrix = {};
+    // Universal rules
+    for (const r of UNIVERSAL_RULES) {
+        const coverage = {
+            ruleId: r.pattern.replace(/-$/, ""),
+            languages: [...langs],
+            severity: r.severity,
+            judge: r.judge,
+        };
+        rules.push(coverage);
+        matrix[coverage.ruleId] = {};
+        for (const l of langs)
+            matrix[coverage.ruleId][l] = true;
+    }
+    // Language-specific rules
+    for (const r of LANGUAGE_RULES) {
+        const applicableLangs = r.languages.filter((l) => langs.includes(l));
+        const coverage = {
+            ruleId: r.pattern.replace(/-$/, ""),
+            languages: applicableLangs,
+            severity: r.severity,
+            judge: r.judge,
+        };
+        rules.push(coverage);
+        matrix[coverage.ruleId] = {};
+        for (const l of langs)
+            matrix[coverage.ruleId][l] = applicableLangs.includes(l);
+    }
+    // Statistics
+    const byLanguage = {};
+    const byJudge = {};
+    for (const r of rules) {
+        byJudge[r.judge] = (byJudge[r.judge] || 0) + 1;
+        for (const l of r.languages) {
+            byLanguage[l] = (byLanguage[l] || 0) + 1;
+        }
+    }
+    return {
+        languages: langs,
+        rules,
+        matrix,
+        stats: { totalRules: rules.length, byLanguage, byJudge },
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runCoverageMap(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges coverage-map — Show which rules apply to which languages
+
+Usage:
+  judges coverage-map                              Full coverage matrix
+  judges coverage-map --languages typescript,python Focus on specific languages
+  judges coverage-map --judge cybersecurity         Filter by judge
+
+Options:
+  --languages <list>    Comma-separated languages to show
+  --judge <id>          Filter rules by judge
+  --format json         JSON output
+  --help, -h            Show this help
+`);
+        return;
+    }
+    const langsArg = argv.find((_a, i) => argv[i - 1] === "--languages");
+    const judgeFilter = argv.find((_a, i) => argv[i - 1] === "--judge");
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const languages = langsArg ? langsArg.split(",").map((s) => s.trim()) : undefined;
+    const map = buildCoverageMap(languages);
+    let rules = map.rules;
+    if (judgeFilter) {
+        rules = rules.filter((r) => r.judge === judgeFilter);
+    }
+    if (format === "json") {
+        console.log(JSON.stringify({ ...map, rules }, null, 2));
+        return;
+    }
+    console.log(`\n  Rule Coverage Map\n`);
+    console.log(`  Total rules: ${rules.length} | Languages: ${map.languages.length}\n`);
+    // Show compact matrix
+    const displayLangs = map.languages.slice(0, 12); // limit width
+    const header = "  " + "Rule".padEnd(20) + displayLangs.map((l) => l.slice(0, 4).padEnd(5)).join("");
+    console.log(header);
+    console.log("  " + "─".repeat(header.length - 2));
+    for (const r of rules) {
+        const row = displayLangs.map((l) => (r.languages.includes(l) ? "  ✓  " : "  ·  ")).join("");
+        console.log(`  ${r.ruleId.padEnd(20)}${row}`);
+    }
+    console.log(`\n  Coverage by language:`);
+    const sorted = Object.entries(map.stats.byLanguage).sort((a, b) => b[1] - a[1]);
+    for (const [lang, count] of sorted) {
+        const pct = ((count / rules.length) * 100).toFixed(0);
+        console.log(`    ${lang.padEnd(15)} ${String(count).padStart(3)} rules (${pct}%)`);
+    }
+    console.log(`\n  Coverage by judge:`);
+    for (const [judge, count] of Object.entries(map.stats.byJudge).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${judge.padEnd(25)} ${count} rules`);
+    }
+    console.log("");
+}

package/dist/commands/coverage.d.ts

@@ -0,0 +1,40 @@
+export interface LanguageCoverageEntry {
+    language: string;
+    fileCount: number;
+    files: string[];
+    /** Whether this language has dedicated evaluator coverage */
+    covered: boolean;
+    /** Count of judges that apply to this language */
+    judgeCount: number;
+}
+export interface LanguageCoverageReport {
+    /** Languages with coverage */
+    covered: LanguageCoverageEntry[];
+    /** Languages without coverage */
+    uncovered: LanguageCoverageEntry[];
+    /** Summary stats */
+    stats: {
+        totalFiles: number;
+        coveredFiles: number;
+        uncoveredFiles: number;
+        coveragePercent: number;
+        languageCount: number;
+        coveredLanguages: number;
+        uncoveredLanguages: number;
+    };
+}
+/**
+ * Detect language from file path extension.
+ */
+export declare function detectFileLanguage(filePath: string): string;
+/**
+ * Compute language coverage for a set of file paths.
+ *
+ * @param files - Array of relative or absolute file paths
+ * @returns Coverage report with covered/uncovered breakdown
+ */
+export declare function computeLanguageCoverage(files: string[]): LanguageCoverageReport;
+/**
+ * Format a language coverage report as human-readable text.
+ */
+export declare function formatCoverageReport(report: LanguageCoverageReport): string;

package/dist/commands/coverage.js

@@ -0,0 +1,147 @@
+// ─── Language Coverage Report ────────────────────────────────────────────────
+// Analyse a set of files to report which languages have Judges Panel coverage
+// and which lack it. Helps teams identify blind spots.
+//
+// Usage (programmatic):
+//   const report = computeLanguageCoverage(fileList);
+//   console.log(formatCoverageReport(report));
+// ──────────────────────────────────────────────────────────────────────────────
+import { normalizeLanguage } from "../language-patterns.js";
+import { JUDGES } from "../judges/index.js";
+// ─── Extension → Language mapping ────────────────────────────────────────────
+import { detectLanguageFromPath } from "../ext-to-lang.js";
+/**
+ * Languages for which the Judges Panel has first-class evaluator coverage.
+ * A language is "covered" if normalizeLanguage returns a recognized LangFamily
+ * AND there are judges whose pattern matching includes that language.
+ */
+const COVERED_LANGUAGES = new Set([
+    "javascript",
+    "typescript",
+    "python",
+    "rust",
+    "csharp",
+    "java",
+    "go",
+    "cpp",
+    "powershell",
+    "terraform",
+    "bicep",
+    "arm",
+    "php",
+    "ruby",
+    "kotlin",
+    "swift",
+]);
+// ─── Core Functions ─────────────────────────────────────────────────────────
+/**
+ * Detect language from file path extension.
+ */
+export function detectFileLanguage(filePath) {
+    return detectLanguageFromPath(filePath) ?? "unknown";
+}
+/**
+ * Count how many judges can evaluate a given language.
+ * Most judges are language-agnostic (they analyze patterns across all languages),
+ * so we return the total judge count for covered languages and 0 for uncovered.
+ */
+function judgeCountForLanguage(language) {
+    const normalized = normalizeLanguage(language);
+    if (COVERED_LANGUAGES.has(normalized) || COVERED_LANGUAGES.has(language)) {
+        return JUDGES.length;
+    }
+    return 0;
+}
+/**
+ * Compute language coverage for a set of file paths.
+ *
+ * @param files - Array of relative or absolute file paths
+ * @returns Coverage report with covered/uncovered breakdown
+ */
+export function computeLanguageCoverage(files) {
+    // Group files by detected language
+    const langFiles = new Map();
+    for (const f of files) {
+        const lang = detectFileLanguage(f);
+        if (lang === "unknown")
+            continue; // Skip unrecognized files
+        const existing = langFiles.get(lang) ?? [];
+        existing.push(f);
+        langFiles.set(lang, existing);
+    }
+    const covered = [];
+    const uncovered = [];
+    for (const [lang, langFileList] of langFiles) {
+        const normalized = normalizeLanguage(lang);
+        const isCovered = COVERED_LANGUAGES.has(normalized) || COVERED_LANGUAGES.has(lang);
+        const jCount = judgeCountForLanguage(lang);
+        const entry = {
+            language: lang,
+            fileCount: langFileList.length,
+            files: langFileList,
+            covered: isCovered,
+            judgeCount: jCount,
+        };
+        if (isCovered) {
+            covered.push(entry);
+        }
+        else {
+            uncovered.push(entry);
+        }
+    }
+    // Sort by file count descending
+    covered.sort((a, b) => b.fileCount - a.fileCount);
+    uncovered.sort((a, b) => b.fileCount - a.fileCount);
+    const coveredFileCount = covered.reduce((sum, e) => sum + e.fileCount, 0);
+    const uncoveredFileCount = uncovered.reduce((sum, e) => sum + e.fileCount, 0);
+    const totalFiles = coveredFileCount + uncoveredFileCount;
+    return {
+        covered,
+        uncovered,
+        stats: {
+            totalFiles,
+            coveredFiles: coveredFileCount,
+            uncoveredFiles: uncoveredFileCount,
+            coveragePercent: totalFiles > 0 ? Math.round((coveredFileCount / totalFiles) * 100) : 100,
+            languageCount: covered.length + uncovered.length,
+            coveredLanguages: covered.length,
+            uncoveredLanguages: uncovered.length,
+        },
+    };
+}
+// ─── Formatting ─────────────────────────────────────────────────────────────
+/**
+ * Format a language coverage report as human-readable text.
+ */
+export function formatCoverageReport(report) {
+    const lines = [];
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║           Judges Panel — Language Coverage Report           ║");
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    lines.push(`  Total files     : ${report.stats.totalFiles}`);
+    lines.push(`  Languages found : ${report.stats.languageCount}`);
+    lines.push(`  Coverage        : ${report.stats.coveragePercent}% (${report.stats.coveredFiles}/${report.stats.totalFiles} files)`);
+    lines.push("");
+    if (report.covered.length > 0) {
+        lines.push("  ✅ Covered Languages:");
+        lines.push("  " + "─".repeat(55));
+        for (const entry of report.covered) {
+            lines.push(`    ${entry.language.padEnd(14)} ${entry.fileCount} file(s)  (${entry.judgeCount} judges)`);
+        }
+        lines.push("");
+    }
+    if (report.uncovered.length > 0) {
+        lines.push("  ⚠️  Uncovered Languages:");
+        lines.push("  " + "─".repeat(55));
+        for (const entry of report.uncovered) {
+            lines.push(`    ${entry.language.padEnd(14)} ${entry.fileCount} file(s)  — no dedicated evaluator`);
+        }
+        lines.push("");
+    }
+    if (report.uncovered.length === 0) {
+        lines.push("  All detected languages have Judges Panel coverage! 🎯");
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/commands/cross-file-consistency.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Cross-file consistency — verify naming and pattern consistency across files.
+ */
+export declare function runCrossFileConsistency(argv: string[]): void;

package/dist/commands/cross-file-consistency.js

@@ -0,0 +1,254 @@
+/**
+ * Cross-file consistency — verify naming and pattern consistency across files.
+ */
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join, extname, basename } from "path";
+// ─── File Collection ────────────────────────────────────────────────────────
+const CODE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+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;
+}
+function analyzeConsistency(files) {
+    const issues = [];
+    // Collect cross-file data
+    const allFunctions = [];
+    const errorPatterns = [];
+    const importStyles = new Map();
+    const returnPatterns = new Map();
+    const logStyles = [];
+    for (const filepath of files) {
+        let content;
+        try {
+            content = readFileSync(filepath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split("\n");
+        const fname = basename(filepath);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Collect function signatures
+            const funcMatch = trimmed.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+            if (funcMatch) {
+                allFunctions.push({ name: funcMatch[1], params: funcMatch[2], file: filepath, line: i + 1 });
+            }
+            // Collect error handling patterns
+            if (/catch\s*\(/.test(trimmed)) {
+                const block = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                if (/console\.error/.test(block))
+                    errorPatterns.push({ pattern: "console.error", file: filepath, line: i + 1 });
+                else if (/logger\.error/.test(block))
+                    errorPatterns.push({ pattern: "logger.error", file: filepath, line: i + 1 });
+                else if (/throw/.test(block))
+                    errorPatterns.push({ pattern: "rethrow", file: filepath, line: i + 1 });
+                else if (/return/.test(block))
+                    errorPatterns.push({ pattern: "return-on-error", file: filepath, line: i + 1 });
+            }
+            // Collect import styles for same module
+            const importMatch = trimmed.match(/import\s+(?:(\w+)|(\{[^}]+\}))\s+from\s+['"]([^'"]+)['"]/);
+            if (importMatch) {
+                const mod = importMatch[3];
+                const entry = importStyles.get(mod) || { default: 0, named: 0, file: filepath, line: i + 1 };
+                if (importMatch[1])
+                    entry.default++;
+                if (importMatch[2])
+                    entry.named++;
+                importStyles.set(mod, entry);
+            }
+            // Collect logging styles
+            if (/console\.(log|warn|error|info|debug)\s*\(/.test(trimmed)) {
+                logStyles.push({ style: "console", file: filepath, line: i + 1 });
+            }
+            else if (/logger\.(log|warn|error|info|debug)\s*\(/.test(trimmed)) {
+                logStyles.push({ style: "logger", file: filepath, line: i + 1 });
+            }
+            // Collect return type patterns for similar functions
+            const retMatch = trimmed.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*:\s*([\w<>[\]| ]+)/);
+            if (retMatch) {
+                const prefix = retMatch[1].replace(/\d+$/, "").replace(/[A-Z][a-z]+$/, "");
+                if (prefix.length > 2) {
+                    const entry = returnPatterns.get(prefix) || { patterns: new Set(), files: [] };
+                    entry.patterns.add(retMatch[2].trim());
+                    entry.files.push(`${fname}:${i + 1}`);
+                    returnPatterns.set(prefix, entry);
+                }
+            }
+        }
+    }
+    // Detect inconsistencies
+    // 1. Similar function names with inconsistent patterns
+    const nameGroups = new Map();
+    for (const func of allFunctions) {
+        const prefix = func.name
+            .replace(/\d+$/, "")
+            .replace(/[A-Z][a-z]+$/, "")
+            .toLowerCase();
+        if (prefix.length > 3) {
+            const group = nameGroups.get(prefix) || [];
+            group.push(func);
+            nameGroups.set(prefix, group);
+        }
+    }
+    for (const [_prefix, group] of nameGroups) {
+        if (group.length >= 2) {
+            const paramCounts = new Set(group.map((f) => f.params.split(",").filter((p) => p.trim()).length));
+            if (paramCounts.size > 1 && group.length <= 5) {
+                const first = group[0];
+                issues.push({
+                    file: first.file,
+                    line: first.line,
+                    issue: "Inconsistent parameter count across similar functions",
+                    severity: "medium",
+                    detail: `Functions with similar names have different parameter counts: ${group.map((f) => `${f.name}(${f.params.split(",").filter((p) => p.trim()).length} params)`).join(", ")}`,
+                });
+            }
+        }
+    }
+    // 2. Mixed error handling patterns
+    if (errorPatterns.length > 3) {
+        const patternCounts = new Map();
+        for (const ep of errorPatterns)
+            patternCounts.set(ep.pattern, (patternCounts.get(ep.pattern) || 0) + 1);
+        if (patternCounts.size > 2) {
+            const minority = [...patternCounts.entries()].sort((a, b) => a[1] - b[1])[0];
+            const sample = errorPatterns.find((ep) => ep.pattern === minority[0]);
+            if (sample) {
+                issues.push({
+                    file: sample.file,
+                    line: sample.line,
+                    issue: "Inconsistent error handling pattern",
+                    severity: "medium",
+                    detail: `Project uses ${patternCounts.size} different error handling patterns — \`${minority[0]}\` is used least (${minority[1]}×)`,
+                });
+            }
+        }
+    }
+    // 3. Mixed import styles for same module
+    for (const [mod, styles] of importStyles) {
+        if (styles.default > 0 && styles.named > 0) {
+            issues.push({
+                file: styles.file,
+                line: styles.line,
+                issue: "Mixed import style for same module",
+                severity: "low",
+                detail: `\`${mod}\` imported both as default (${styles.default}×) and named (${styles.named}×) — AI may have used wrong import style`,
+            });
+        }
+    }
+    // 4. Mixed logging styles
+    if (logStyles.length > 5) {
+        const consoleCount = logStyles.filter((l) => l.style === "console").length;
+        const loggerCount = logStyles.filter((l) => l.style === "logger").length;
+        if (consoleCount > 0 && loggerCount > 0) {
+            const minority = consoleCount < loggerCount
+                ? logStyles.find((l) => l.style === "console")
+                : logStyles.find((l) => l.style === "logger");
+            if (minority) {
+                issues.push({
+                    file: minority.file,
+                    line: minority.line,
+                    issue: "Mixed logging approach",
+                    severity: "low",
+                    detail: `Project uses both console.* (${consoleCount}×) and logger.* (${loggerCount}×) — standardize on one`,
+                });
+            }
+        }
+    }
+    // 5. Similar functions with inconsistent return types
+    for (const [_prefix, ret] of returnPatterns) {
+        if (ret.patterns.size > 1 && ret.files.length > 1) {
+            issues.push({
+                file: ret.files[0].split(":")[0],
+                line: 1,
+                issue: "Inconsistent return types for similar functions",
+                severity: "low",
+                detail: `Functions in the same family return different types: ${[...ret.patterns].join(", ")}`,
+            });
+        }
+    }
+    return issues;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runCrossFileConsistency(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges cross-file-consistency — Verify naming and pattern consistency across files
+
+Usage:
+  judges cross-file-consistency [dir]
+  judges cross-file-consistency src/ --format json
+
+Options:
+  [dir]                 Directory to scan (default: .)
+  --format json         JSON output
+  --help, -h            Show this help
+
+Checks: inconsistent parameter counts, mixed error handling, mixed import styles,
+mixed logging approaches, inconsistent return types for similar functions.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const dir = argv.find((a) => !a.startsWith("-") && argv.indexOf(a) > 0) || ".";
+    const files = collectFiles(dir);
+    const allIssues = analyzeConsistency(files);
+    const highCount = allIssues.filter((i) => i.severity === "high").length;
+    const medCount = allIssues.filter((i) => i.severity === "medium").length;
+    const score = Math.max(0, 100 - highCount * 10 - medCount * 5 - allIssues.filter((i) => i.severity === "low").length * 2);
+    if (format === "json") {
+        console.log(JSON.stringify({
+            issues: allIssues,
+            score,
+            summary: { high: highCount, medium: medCount, total: allIssues.length },
+            timestamp: new Date().toISOString(),
+        }, null, 2));
+    }
+    else {
+        const badge = score >= 80 ? "✅ CONSISTENT" : score >= 50 ? "⚠️  MIXED" : "❌ INCONSISTENT";
+        console.log(`\n  Cross-File Consistency: ${badge} (${score}/100)\n  ─────────────────────────────`);
+        if (allIssues.length === 0) {
+            console.log("    No cross-file inconsistencies detected.\n");
+            return;
+        }
+        for (const issue of allIssues.slice(0, 25)) {
+            const icon = issue.severity === "high" ? "🔴" : issue.severity === "medium" ? "🟡" : "🔵";
+            console.log(`    ${icon} ${issue.issue}`);
+            console.log(`        ${issue.file}:${issue.line}`);
+            console.log(`        ${issue.detail}`);
+        }
+        if (allIssues.length > 25)
+            console.log(`    ... and ${allIssues.length - 25} more`);
+        console.log(`\n    Total: ${allIssues.length} | High: ${highCount} | Medium: ${medCount} | Score: ${score}/100\n`);
+    }
+}

package/dist/commands/cross-pr-regression.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cross-PR pattern regression — track flagged patterns and alert
+ * when they recur in new code. Prevents AI from reintroducing
+ * known bugs.
+ *
+ * All data stored locally in `.judges-pr-patterns/`.
+ */
+export declare function runCrossPrRegression(argv: string[]): void;