@kevinrabun/judges-cli 3.124.0

package/dist/commands/quality-gate.js

@@ -0,0 +1,252 @@
+/**
+ * `judges quality-gate` — Configurable composite quality gates.
+ *
+ * Defines and evaluates multi-dimensional quality gates for CI pipelines.
+ * Goes beyond simple severity counts — supports score thresholds, specific
+ * rule requirements, trend-based gates, and custom composite conditions.
+ *
+ * Usage:
+ *   judges quality-gate --file src/app.ts                    # Evaluate default gate
+ *   judges quality-gate --file src/app.ts --gate strict      # Named gate definition
+ *   judges quality-gate --file src/app.ts --json             # JSON output
+ *
+ * Configuration in .judgesrc:
+ * ```json
+ * {
+ *   "qualityGates": {
+ *     "default": {
+ *       "maxFindings": { "critical": 0, "high": 2 },
+ *       "minScore": 70,
+ *       "requiredJudges": ["cybersecurity", "data-security"],
+ *       "maxFpRate": 0.3
+ *     },
+ *     "strict": {
+ *       "maxFindings": { "critical": 0, "high": 0, "medium": 5 },
+ *       "minScore": 85,
+ *       "requiredJudges": ["cybersecurity", "data-security", "authentication"]
+ *     }
+ *   }
+ * }
+ * ```
+ */
+import { existsSync, readFileSync } from "fs";
+import { extname } from "path";
+import { evaluateWithTribunal } from "../evaluators/index.js";
+// ─── Gate Evaluation ────────────────────────────────────────────────────────
+const SEVERITY_LEVELS = ["critical", "high", "medium", "low", "info"];
+export function evaluateQualityGate(gate, gateName, verdict, fpRateByRule) {
+    const checks = [];
+    // Check max findings by severity
+    if (gate.maxFindings) {
+        const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+        for (const f of verdict.findings) {
+            counts[f.severity] = (counts[f.severity] || 0) + 1;
+        }
+        for (const sev of SEVERITY_LEVELS) {
+            const max = gate.maxFindings[sev];
+            if (max !== undefined) {
+                const actual = counts[sev];
+                checks.push({
+                    name: `max-${sev}`,
+                    passed: actual <= max,
+                    message: `${sev} findings: ${actual}/${max} allowed`,
+                });
+            }
+        }
+    }
+    // Check minimum score
+    if (gate.minScore !== undefined) {
+        checks.push({
+            name: "min-score",
+            passed: verdict.overallScore >= gate.minScore,
+            message: `Score: ${verdict.overallScore}/${gate.minScore} required`,
+        });
+    }
+    // Check required judges participated
+    if (gate.requiredJudges) {
+        const participatingJudges = new Set(verdict.evaluations.map((e) => e.judgeId));
+        for (const required of gate.requiredJudges) {
+            checks.push({
+                name: `required-judge-${required}`,
+                passed: participatingJudges.has(required),
+                message: `Judge "${required}": ${participatingJudges.has(required) ? "participated" : "MISSING"}`,
+            });
+        }
+    }
+    // Check blocker rules
+    if (gate.blockerRules) {
+        const violatedRules = new Set(verdict.findings.map((f) => f.ruleId));
+        for (const rule of gate.blockerRules) {
+            const violated = violatedRules.has(rule);
+            checks.push({
+                name: `blocker-${rule}`,
+                passed: !violated,
+                message: `Blocker rule ${rule}: ${violated ? "VIOLATED" : "clear"}`,
+            });
+        }
+    }
+    // Check max FP rate
+    if (gate.maxFpRate !== undefined && fpRateByRule) {
+        const avgFpRate = fpRateByRule.size > 0 ? Array.from(fpRateByRule.values()).reduce((sum, r) => sum + r, 0) / fpRateByRule.size : 0;
+        checks.push({
+            name: "max-fp-rate",
+            passed: avgFpRate <= gate.maxFpRate,
+            message: `FP rate: ${(avgFpRate * 100).toFixed(1)}%/${(gate.maxFpRate * 100).toFixed(1)}% allowed`,
+        });
+    }
+    // Check min fix rate
+    if (gate.minFixRate !== undefined) {
+        const fixable = verdict.findings.filter((f) => f.patch).length;
+        const total = verdict.findings.length;
+        const fixRate = total > 0 ? fixable / total : 1;
+        checks.push({
+            name: "min-fix-rate",
+            passed: fixRate >= gate.minFixRate,
+            message: `Fix rate: ${(fixRate * 100).toFixed(1)}%/${(gate.minFixRate * 100).toFixed(1)}% required`,
+        });
+    }
+    // Check min confidence
+    if (gate.minConfidence !== undefined) {
+        const confidences = verdict.findings.filter((f) => f.confidence !== undefined).map((f) => f.confidence);
+        const avgConf = confidences.length > 0 ? confidences.reduce((s, c) => s + c, 0) / confidences.length : 1;
+        checks.push({
+            name: "min-confidence",
+            passed: avgConf >= gate.minConfidence,
+            message: `Avg confidence: ${(avgConf * 100).toFixed(1)}%/${(gate.minConfidence * 100).toFixed(1)}% required`,
+        });
+    }
+    const passed = checks.every((c) => c.passed);
+    const failed = checks.filter((c) => !c.passed);
+    return {
+        passed,
+        gateName,
+        checks,
+        summary: passed
+            ? `Quality gate "${gateName}" PASSED — all ${checks.length} check(s) passed`
+            : `Quality gate "${gateName}" FAILED — ${failed.length}/${checks.length} check(s) failed`,
+    };
+}
+// ─── Config Parsing ─────────────────────────────────────────────────────────
+export function parseQualityGateConfig(obj) {
+    if (!obj.qualityGates)
+        return undefined;
+    const raw = obj.qualityGates;
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return undefined;
+    const gates = {};
+    for (const [name, def] of Object.entries(raw)) {
+        if (typeof def !== "object" || def === null)
+            continue;
+        const d = def;
+        const gate = {};
+        if (d.maxFindings && typeof d.maxFindings === "object") {
+            gate.maxFindings = d.maxFindings;
+        }
+        if (typeof d.minScore === "number")
+            gate.minScore = d.minScore;
+        if (Array.isArray(d.requiredJudges))
+            gate.requiredJudges = d.requiredJudges;
+        if (typeof d.maxFpRate === "number")
+            gate.maxFpRate = d.maxFpRate;
+        if (Array.isArray(d.blockerRules))
+            gate.blockerRules = d.blockerRules;
+        if (typeof d.minFixRate === "number")
+            gate.minFixRate = d.minFixRate;
+        if (typeof d.minConfidence === "number")
+            gate.minConfidence = d.minConfidence;
+        gates[name] = gate;
+    }
+    return Object.keys(gates).length > 0 ? gates : undefined;
+}
+// ─── CLI Runner ─────────────────────────────────────────────────────────────
+import { EXT_TO_LANG } from "../ext-to-lang.js";
+export function runQualityGate(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges quality-gate — Evaluate configurable quality gates
+
+Usage:
+  judges quality-gate --file <path>              Evaluate default gate
+  judges quality-gate --file <path> --gate <name> Use a named gate definition
+  judges quality-gate --json                      JSON output
+
+Configuration (.judgesrc):
+  "qualityGates": {
+    "default": {
+      "maxFindings": { "critical": 0, "high": 2 },
+      "minScore": 70,
+      "requiredJudges": ["cybersecurity"],
+      "blockerRules": ["SEC-001", "AUTH-001"]
+    }
+  }
+
+Options:
+  --file, -f <path>    File to evaluate
+  --gate <name>        Gate name (default: "default")
+  --json               JSON output
+  --help, -h           Show this help
+`);
+        return;
+    }
+    const file = argv.find((_a, i) => argv[i - 1] === "--file" || argv[i - 1] === "-f");
+    const gateName = argv.find((_a, i) => argv[i - 1] === "--gate") || "default";
+    const jsonFormat = argv.includes("--json");
+    if (!file) {
+        console.error("Error: --file is required.");
+        process.exit(1);
+    }
+    if (!existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    // Load quality gate config from .judgesrc
+    let gates;
+    for (const name of [".judgesrc", ".judgesrc.json"]) {
+        if (existsSync(name)) {
+            try {
+                const raw = JSON.parse(readFileSync(name, "utf-8"));
+                gates = parseQualityGateConfig(raw);
+            }
+            catch {
+                // Skip invalid config
+            }
+            break;
+        }
+    }
+    // Use a sensible default gate if none configured
+    const gate = gates?.[gateName] ?? {
+        maxFindings: { critical: 0, high: 3 },
+        minScore: 60,
+    };
+    // Evaluate
+    const code = readFileSync(file, "utf-8");
+    const lang = EXT_TO_LANG[extname(file)] || "typescript";
+    const verdict = evaluateWithTribunal(code, lang);
+    // Load FP rates if available
+    let fpRateByRule;
+    try {
+        const { loadFeedbackStore, getFpRateByRule: getFpRate } = require("./feedback.js");
+        const store = loadFeedbackStore();
+        const rates = getFpRate(store);
+        fpRateByRule = rates instanceof Map ? rates : new Map(Object.entries(rates));
+    }
+    catch {
+        // Feedback data not available
+    }
+    const result = evaluateQualityGate(gate, gateName, verdict, fpRateByRule);
+    if (jsonFormat) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        const icon = result.passed ? "✅" : "❌";
+        console.log(`\n  ${icon} ${result.summary}\n`);
+        for (const check of result.checks) {
+            const checkIcon = check.passed ? "  ✓" : "  ✗";
+            console.log(`  ${checkIcon} ${check.message}`);
+        }
+        console.log("");
+    }
+    if (!result.passed) {
+        process.exit(1);
+    }
+}

package/dist/commands/query.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Advanced finding search/filter — complex queries across evaluation results.
+ *
+ * Reads local .judges-results.json files for searching.
+ */
+import type { Finding } from "../types.js";
+interface FindingRecord extends Finding {
+    source?: string;
+    timestamp?: string;
+}
+interface QueryResult {
+    matches: FindingRecord[];
+    total: number;
+    query: string;
+}
+export declare function queryFindings(queryStr: string, findings?: FindingRecord[]): QueryResult;
+export declare function aggregateFindings(findings: FindingRecord[], groupBy: string): Record<string, number>;
+export declare function runQuery(argv: string[]): void;
+export {};

package/dist/commands/query.js

@@ -0,0 +1,229 @@
+/**
+ * Advanced finding search/filter — complex queries across evaluation results.
+ *
+ * Reads local .judges-results.json files for searching.
+ */
+import { readFileSync, existsSync, writeFileSync } from "fs";
+const QUERY_FILE = ".judges-query.json";
+const RESULTS_FILE = ".judges-results.json";
+// ─── Core ───────────────────────────────────────────────────────────────────
+function loadResults() {
+    if (!existsSync(RESULTS_FILE))
+        return [];
+    try {
+        const data = JSON.parse(readFileSync(RESULTS_FILE, "utf-8"));
+        if (Array.isArray(data))
+            return data;
+        if (data.findings)
+            return data.findings;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function loadQueryDb() {
+    if (!existsSync(QUERY_FILE))
+        return { history: [], savedQueries: [] };
+    return JSON.parse(readFileSync(QUERY_FILE, "utf-8"));
+}
+function saveQueryDb(db) {
+    writeFileSync(QUERY_FILE, JSON.stringify(db, null, 2));
+}
+function matchesFilter(finding, key, value) {
+    const lowerVal = value.toLowerCase();
+    switch (key) {
+        case "severity":
+            return finding.severity.toLowerCase() === lowerVal;
+        case "rule":
+        case "ruleId":
+            return finding.ruleId.toLowerCase().includes(lowerVal);
+        case "title":
+            return finding.title.toLowerCase().includes(lowerVal);
+        case "description":
+        case "desc":
+            return finding.description.toLowerCase().includes(lowerVal);
+        case "confidence":
+            if (finding.confidence === undefined)
+                return false;
+            return finding.confidence >= parseFloat(value);
+        case "has-patch":
+            return !!finding.patch;
+        case "has-fix":
+            return !!finding.suggestedFix;
+        default:
+            // Generic text search across all string fields
+            return [finding.ruleId, finding.title, finding.description, finding.recommendation].some((f) => f.toLowerCase().includes(lowerVal));
+    }
+}
+export function queryFindings(queryStr, findings) {
+    const records = findings || loadResults();
+    // Parse query: "severity:critical rule:SEC text-search"
+    const parts = queryStr.split(/\s+/);
+    let matches = [...records];
+    const textParts = [];
+    for (const part of parts) {
+        const colonIdx = part.indexOf(":");
+        if (colonIdx > 0) {
+            const key = part.slice(0, colonIdx);
+            const val = part.slice(colonIdx + 1);
+            if (part.startsWith("-")) {
+                // Negation: -severity:low
+                const negKey = key.slice(1);
+                matches = matches.filter((f) => !matchesFilter(f, negKey, val));
+            }
+            else {
+                matches = matches.filter((f) => matchesFilter(f, key, val));
+            }
+        }
+        else {
+            textParts.push(part.toLowerCase());
+        }
+    }
+    if (textParts.length > 0) {
+        const textQuery = textParts.join(" ");
+        matches = matches.filter((f) => [f.ruleId, f.title, f.description, f.recommendation].some((s) => s.toLowerCase().includes(textQuery)));
+    }
+    return { matches, total: matches.length, query: queryStr };
+}
+export function aggregateFindings(findings, groupBy) {
+    const result = {};
+    for (const f of findings) {
+        let key;
+        switch (groupBy) {
+            case "severity":
+                key = f.severity;
+                break;
+            case "rule":
+            case "ruleId":
+                key = f.ruleId;
+                break;
+            case "confidence":
+                key = f.confidence !== undefined ? `${Math.floor(f.confidence * 10) * 10}%` : "unknown";
+                break;
+            default:
+                key = f.severity;
+        }
+        result[key] = (result[key] || 0) + 1;
+    }
+    return result;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runQuery(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges query — Advanced finding search and filter
+
+Usage:
+  judges query "severity:critical"
+  judges query "rule:SEC -severity:low"
+  judges query "injection" --aggregate severity
+  judges query --save "critical-sec" "severity:critical rule:SEC"
+  judges query --saved "critical-sec"
+  judges query --list-saved
+
+Filter keys:
+  severity:<level>     critical | high | medium | low
+  rule:<pattern>       Match ruleId (substring)
+  title:<text>         Match title
+  desc:<text>          Match description
+  confidence:<min>     Minimum confidence (e.g., 0.8)
+  has-patch:true       Only findings with patches
+  has-fix:true         Only findings with suggested fixes
+  -<key>:<value>       Negate a filter
+
+Options:
+  --aggregate <key>    Group by severity|rule|confidence
+  --limit <n>          Max results
+  --save <name>        Save query for reuse
+  --saved <name>       Run a saved query
+  --list-saved         List saved queries
+  --format json        JSON output
+  --help, -h           Show this help
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    // List saved queries
+    if (argv.includes("--list-saved")) {
+        const db = loadQueryDb();
+        if (db.savedQueries.length === 0) {
+            console.log("\n  No saved queries.\n");
+        }
+        else {
+            console.log(`\n  Saved Queries (${db.savedQueries.length})\n  ───────────────`);
+            for (const q of db.savedQueries) {
+                console.log(`    ${q.name.padEnd(20)} ${q.query}`);
+            }
+            console.log("");
+        }
+        return;
+    }
+    // Save a query
+    const saveName = argv.find((_a, i) => argv[i - 1] === "--save");
+    if (saveName) {
+        const queryStr = argv.filter((a) => !a.startsWith("--") && a !== saveName).join(" ");
+        const db = loadQueryDb();
+        db.savedQueries = db.savedQueries.filter((q) => q.name !== saveName);
+        db.savedQueries.push({ name: saveName, query: queryStr, createdAt: new Date().toISOString() });
+        saveQueryDb(db);
+        console.log(`  ✅ Saved query "${saveName}": ${queryStr}`);
+        return;
+    }
+    // Run saved query
+    const savedName = argv.find((_a, i) => argv[i - 1] === "--saved");
+    if (savedName) {
+        const db = loadQueryDb();
+        const saved = db.savedQueries.find((q) => q.name === savedName);
+        if (!saved) {
+            console.error(`  ❌ Saved query "${savedName}" not found`);
+            return;
+        }
+        const result = queryFindings(saved.query);
+        printResults(result, format, argv);
+        return;
+    }
+    // Execute query
+    const queryStr = argv.filter((a) => !a.startsWith("--")).join(" ");
+    if (!queryStr) {
+        console.error("  ❌ No query provided. Use --help for usage.");
+        return;
+    }
+    const result = queryFindings(queryStr);
+    printResults(result, format, argv);
+}
+function printResults(result, format, argv) {
+    const aggregateBy = argv.find((_a, i) => argv[i - 1] === "--aggregate");
+    const limitStr = argv.find((_a, i) => argv[i - 1] === "--limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : undefined;
+    let { matches } = result;
+    if (limit)
+        matches = matches.slice(0, limit);
+    if (aggregateBy) {
+        const agg = aggregateFindings(matches, aggregateBy);
+        if (format === "json") {
+            console.log(JSON.stringify(agg, null, 2));
+        }
+        else {
+            console.log(`\n  Aggregate by ${aggregateBy} (${result.total} matches)\n  ──────────────────────`);
+            for (const [key, count] of Object.entries(agg).sort((a, b) => b[1] - a[1])) {
+                console.log(`    ${key.padEnd(20)} ${count}`);
+            }
+            console.log("");
+        }
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify({ ...result, matches }, null, 2));
+        return;
+    }
+    console.log(`\n  Query: "${result.query}" → ${result.total} match(es)\n  ─────────────────────────`);
+    if (matches.length === 0) {
+        console.log("    No findings matched.\n");
+        return;
+    }
+    for (const f of matches) {
+        console.log(`    [${f.severity.toUpperCase()}] ${f.ruleId.padEnd(12)} ${f.title.slice(0, 50)}`);
+    }
+    console.log("");
+}

package/dist/commands/quick-check.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Quick-check — sub-100ms pattern-only review for real-time save-on-type feedback.
+ */
+export declare function runQuickCheck(argv: string[]): void;

package/dist/commands/quick-check.js

@@ -0,0 +1,173 @@
+/**
+ * Quick-check — sub-100ms pattern-only review for real-time save-on-type feedback.
+ */
+import { readFileSync, statSync } from "fs";
+import { extname } from "path";
+const PATTERNS = [
+    // Critical
+    { regex: /\beval\s*\(/, rule: "QC-INJECT-01", severity: "critical", message: "eval() usage — code injection risk" },
+    {
+        regex: /(?:password|secret|api[_-]?key)\s*[:=]\s*['"][^'"]{4,}['"]/,
+        rule: "QC-SECRET-01",
+        severity: "critical",
+        message: "Hardcoded credential detected",
+    },
+    { regex: /\.innerHTML\s*=/, rule: "QC-XSS-01", severity: "critical", message: "innerHTML assignment — XSS risk" },
+    {
+        regex: /new\s+Function\s*\(/,
+        rule: "QC-INJECT-02",
+        severity: "critical",
+        message: "new Function() — code injection risk",
+    },
+    // High
+    {
+        regex: /new\s+Buffer\s*\(/,
+        rule: "QC-DEPR-01",
+        severity: "high",
+        message: "Deprecated new Buffer() — use Buffer.from()",
+    },
+    {
+        regex: /(?:setTimeout|setInterval)\s*\(\s*['"]/,
+        rule: "QC-INJECT-03",
+        severity: "high",
+        message: "String passed to timer — implicit eval",
+    },
+    {
+        regex: /process\.exit\s*\(\s*\)/,
+        rule: "QC-RELIAB-01",
+        severity: "high",
+        message: "Unconditional process.exit() — may crash graceful shutdown",
+    },
+    {
+        regex: /document\.write\s*\(/,
+        rule: "QC-XSS-02",
+        severity: "high",
+        message: "document.write() — XSS and DOM clobbering risk",
+    },
+    // Medium
+    {
+        regex: /catch\s*\(\s*\w*\s*\)\s*\{\s*\}/,
+        rule: "QC-ERR-01",
+        severity: "medium",
+        message: "Empty catch block — errors silently swallowed",
+    },
+    { regex: /debugger\b/, rule: "QC-DEV-01", severity: "medium", message: "Debugger statement left in code" },
+    { regex: /console\.log\s*\(/, rule: "QC-DEV-02", severity: "medium", message: "console.log() in production code" },
+    {
+        regex: /\/\/\s*TODO\b|\/\/\s*FIXME\b|\/\/\s*HACK\b|\/\/\s*XXX\b/,
+        rule: "QC-DEBT-01",
+        severity: "medium",
+        message: "Open TODO/FIXME comment",
+    },
+    {
+        regex: /\.then\s*\([^)]*\)\s*;?\s*$/,
+        rule: "QC-ASYNC-01",
+        severity: "medium",
+        message: "Unhandled promise — missing .catch()",
+    },
+    // Low
+    { regex: /\bvar\s+\w+\s*=/, rule: "QC-MODERN-01", severity: "low", message: "var declaration — use const or let" },
+    {
+        regex: /\.substr\s*\(/,
+        rule: "QC-DEPR-02",
+        severity: "low",
+        message: "Deprecated .substr() — use .substring() or .slice()",
+    },
+    {
+        regex: /==\s*null\b|!=\s*null\b/,
+        rule: "QC-TYPE-01",
+        severity: "low",
+        message: "Loose null comparison — use === null",
+    },
+];
+// ─── Analysis ───────────────────────────────────────────────────────────────
+function quickScan(filepath, content) {
+    const start = performance.now();
+    const code = content || readFileSync(filepath, "utf-8");
+    const lines = code.split("\n");
+    const findings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip comments
+        if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*"))
+            continue;
+        for (const pattern of PATTERNS) {
+            if (pattern.regex.test(line)) {
+                findings.push({
+                    line: i + 1,
+                    severity: pattern.severity,
+                    rule: pattern.rule,
+                    message: pattern.message,
+                });
+            }
+        }
+    }
+    const critCount = findings.filter((f) => f.severity === "critical").length;
+    const highCount = findings.filter((f) => f.severity === "high").length;
+    const medCount = findings.filter((f) => f.severity === "medium").length;
+    const score = Math.max(0, 100 - critCount * 20 - highCount * 10 - medCount * 4 - findings.filter((f) => f.severity === "low").length);
+    return {
+        file: filepath,
+        findings,
+        score,
+        elapsedMs: Math.round((performance.now() - start) * 100) / 100,
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runQuickCheck(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges quick-check — Sub-100ms pattern-only review for real-time feedback
+
+Usage:
+  judges quick-check <file>
+  judges quick-check src/app.ts --format json
+
+Options:
+  <file>                File to check (required)
+  --format json         JSON output (for IDE integration)
+  --help, -h            Show this help
+
+Designed for save-on-type IDE integration. Runs only cheap regex/pattern
+checks with no LLM calls. Use 'judges review' for deep analysis.
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const file = argv.find((a) => !a.startsWith("-") && argv.indexOf(a) > 0 && argv[argv.indexOf(a) - 1] !== "--format");
+    if (!file) {
+        console.error("Error: File path required. Usage: judges quick-check <file>");
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        statSync(file);
+    }
+    catch {
+        console.error(`Error: File not found: ${file}`);
+        process.exitCode = 1;
+        return;
+    }
+    const ext = extname(file);
+    if (![".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", ".cs", ".rs", ".rb"].includes(ext)) {
+        console.error(`Warning: Language '${ext}' may have limited coverage.`);
+    }
+    const result = quickScan(file);
+    if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        const icon = result.score >= 80 ? "✅" : result.score >= 50 ? "⚠️ " : "❌";
+        console.log(`\n  Quick Check: ${icon} ${result.score}/100 (${result.elapsedMs}ms)\n  ─────────────────────────────`);
+        if (result.findings.length === 0) {
+            console.log("    No issues found.\n");
+            return;
+        }
+        for (const f of result.findings) {
+            const sev = f.severity === "critical" ? "🔴" : f.severity === "high" ? "🟠" : f.severity === "medium" ? "🟡" : "🔵";
+            console.log(`    ${sev} L${f.line} [${f.rule}] ${f.message}`);
+        }
+        console.log(`\n    ${result.findings.length} finding(s) in ${result.elapsedMs}ms\n`);
+    }
+}