@kevinrabun/judges 3.115.1 → 3.115.3

package/dist/commands/group-findings.js

@@ -0,0 +1,154 @@
+/**
+ * Finding grouping — group related findings by category, file, or rule
+ * for better review UX and digest-style reporting.
+ */
+// ─── Category Classification ────────────────────────────────────────────────
+const RULE_CATEGORIES = {
+    // Security
+    "SEC-": "Security",
+    "AUTH-": "Authentication",
+    "CRYPTO-": "Cryptography",
+    "INJECT-": "Injection",
+    "XSS-": "Cross-Site Scripting",
+    "SSRF-": "Server-Side Request Forgery",
+    "IDOR-": "Broken Access Control",
+    // Quality
+    "PERF-": "Performance",
+    "ERR-": "Error Handling",
+    "LOG-": "Logging",
+    "TEST-": "Testing",
+    "DOC-": "Documentation",
+    "MAINT-": "Maintainability",
+    "STRUCT-": "Code Structure",
+    // Reliability
+    "CONCUR-": "Concurrency",
+    "RACE-": "Race Conditions",
+    "SCALE-": "Scalability",
+    "CACHE-": "Caching",
+    "RATE-": "Rate Limiting",
+    // Compliance
+    "COMPLY-": "Compliance",
+    "DATA-": "Data Protection",
+    "PII-": "Privacy",
+    // AI
+    "AI-": "AI Safety",
+    "HALLUC-": "Hallucination",
+    "FW-": "Framework Safety",
+    // Infrastructure
+    "IAC-": "Infrastructure as Code",
+    "CICD-": "CI/CD",
+    "CLOUD-": "Cloud Readiness",
+    "DB-": "Database",
+    // Accessibility / UX
+    "A11Y-": "Accessibility",
+    "I18N-": "Internationalization",
+    "UX-": "User Experience",
+};
+function classifyRule(ruleId) {
+    for (const [prefix, category] of Object.entries(RULE_CATEGORIES)) {
+        if (ruleId.toUpperCase().startsWith(prefix))
+            return category;
+    }
+    return "Other";
+}
+// ─── Grouping Logic ─────────────────────────────────────────────────────────
+function getGroupKey(finding, groupBy) {
+    switch (groupBy) {
+        case "category":
+            return classifyRule(finding.ruleId);
+        case "severity":
+            return finding.severity;
+        case "file":
+            return "(grouped)";
+        case "rule":
+            return finding.ruleId;
+        case "judge":
+            return finding.judgeId || "(unknown)";
+    }
+}
+export function groupFindings(findings, groupBy) {
+    const groups = new Map();
+    for (const f of findings) {
+        const key = getGroupKey(f, groupBy);
+        const arr = groups.get(key) || [];
+        arr.push(f);
+        groups.set(key, arr);
+    }
+    const sortedGroups = [...groups.entries()]
+        .map(([key, items]) => ({
+        key,
+        label: key,
+        findings: items,
+        count: items.length,
+        criticalCount: items.filter((f) => f.severity === "critical").length,
+        highCount: items.filter((f) => f.severity === "high").length,
+    }))
+        .sort((a, b) => b.criticalCount - a.criticalCount || b.highCount - a.highCount || b.count - a.count);
+    return {
+        groupBy,
+        groups: sortedGroups,
+        totalFindings: findings.length,
+        totalGroups: sortedGroups.length,
+    };
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runGroupFindings(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges group — Group findings by category, severity, file, rule, or judge
+
+Usage:
+  judges group --input results.json                 Group by category (default)
+  judges group --input results.json --by severity   Group by severity
+  judges group --input results.json --by file       Group by file
+
+Options:
+  --input <path>      Path to JSON results file (required)
+  --by <key>          Group by: category, severity, file, rule, judge (default: category)
+  --format json       JSON output
+  --help, -h          Show this help
+`);
+        return;
+    }
+    const { readFileSync, existsSync } = require("fs");
+    const inputPath = argv.find((_a, i) => argv[i - 1] === "--input");
+    if (!inputPath || !existsSync(inputPath)) {
+        console.error("Error: --input <path> required (JSON results file)");
+        process.exit(1);
+    }
+    const byArg = argv.find((_a, i) => argv[i - 1] === "--by") || "category";
+    const validKeys = new Set(["category", "severity", "file", "rule", "judge"]);
+    if (!validKeys.has(byArg)) {
+        console.error(`Error: --by must be one of: ${[...validKeys].join(", ")}`);
+        process.exit(1);
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const data = JSON.parse(readFileSync(inputPath, "utf-8"));
+    const findings = data.evaluations
+        ? data.evaluations.flatMap((e) => e.findings || [])
+        : data.findings || data;
+    const report = groupFindings(findings, byArg);
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`\n  Findings Grouped by ${report.groupBy}\n`);
+    console.log(`  Total: ${report.totalFindings} findings in ${report.totalGroups} groups\n`);
+    for (const g of report.groups) {
+        const badges = [];
+        if (g.criticalCount > 0)
+            badges.push(`🔴 ${g.criticalCount} critical`);
+        if (g.highCount > 0)
+            badges.push(`🟠 ${g.highCount} high`);
+        const badge = badges.length > 0 ? ` (${badges.join(", ")})` : "";
+        console.log(`  📁 ${g.label} — ${g.count} findings${badge}`);
+        for (const f of g.findings.slice(0, 5)) {
+            const loc = f.lineNumbers?.length ? `:${f.lineNumbers[0]}` : "";
+            console.log(`     ${f.severity.padEnd(8)} ${f.ruleId}: ${f.title.slice(0, 80)}${loc}`);
+        }
+        if (g.findings.length > 5) {
+            console.log(`     ... and ${g.findings.length - 5} more`);
+        }
+        console.log("");
+    }
+}

package/dist/commands/guided-tour.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Guided tour — interactive onboarding tutorial for new Judges users.
+ * Step-by-step walkthrough: first evaluation, understanding output,
+ * suppression/baseline workflows, building .judgesrc by example.
+ *
+ * All data local.
+ */
+export declare function runGuidedTour(argv: string[]): void;

package/dist/commands/guided-tour.js

@@ -0,0 +1,287 @@
+/**
+ * Guided tour — interactive onboarding tutorial for new Judges users.
+ * Step-by-step walkthrough: first evaluation, understanding output,
+ * suppression/baseline workflows, building .judgesrc by example.
+ *
+ * All data local.
+ */
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+// ─── Tour content ───────────────────────────────────────────────────────────
+const TOUR_TRACKS = [
+    {
+        id: "quickstart",
+        name: "Quick Start",
+        description: "Get your first code review in under 5 minutes",
+        steps: [
+            {
+                id: "install",
+                title: "Step 1: Installation",
+                description: "Install Judges globally or as a dev dependency.",
+                command: "npm install -g @kevinrabun/judges-cli",
+                example: "# Or as a dev dependency:\nnpm install --save-dev @kevinrabun/judges-cli",
+                tips: [
+                    "Use --save-dev for project-specific installations",
+                    "Global install lets you run 'judges' from anywhere",
+                ],
+            },
+            {
+                id: "first-review",
+                title: "Step 2: Run Your First Review",
+                description: "Point Judges at any source file to get an instant security review.",
+                command: "judges review src/app.ts",
+                example: "# Review an entire directory:\njudges review src/\n\n# Review with a specific preset:\njudges review src/ --preset strict",
+                tips: [
+                    "Start with a single file to learn the output format",
+                    "Use --preset lenient for fewer false positives initially",
+                ],
+            },
+            {
+                id: "understand-output",
+                title: "Step 3: Understanding the Output",
+                description: "Judges outputs findings with severity, confidence, and actionable recommendations.",
+                example: `Finding output explained:
+─────────────────────────
+  [HIGH] sql-injection-risk
+    Title: Potential SQL injection in query builder
+    Line: 42
+    Confidence: 0.92 (high tier)
+    Recommendation: Use parameterized queries instead of string concatenation
+
+  Fields:
+    severity   — critical / high / medium / low
+    confidence — 0.0–1.0 score (how certain the judge is)
+    ruleId     — unique identifier for the finding type
+    title      — human-readable description
+    recommendation — how to fix the issue`,
+                tips: [
+                    "High confidence + high severity = fix immediately",
+                    "Low confidence findings may be false positives — review carefully",
+                ],
+            },
+            {
+                id: "suppress",
+                title: "Step 4: Suppressing False Positives",
+                description: "Mark findings as acknowledged or false positives so they don't appear again.",
+                command: "judges baseline create --output .judges-baseline.json",
+                example: `# Create a baseline from current findings:
+judges baseline create --output .judges-baseline.json
+
+# Run review with baseline (only new findings shown):
+judges review src/ --baseline .judges-baseline.json
+
+# Suppress a specific rule:
+# Add to .judgesrc: { "disabledRules": ["rule-id-here"] }`,
+                tips: [
+                    "Baselines capture current state — only new issues surface",
+                    "Commit .judges-baseline.json to share with your team",
+                ],
+            },
+            {
+                id: "configure",
+                title: "Step 5: Create Your .judgesrc",
+                description: "Customize Judges behavior with a configuration file.",
+                example: `// .judgesrc (JSON format)
+{
+  "preset": "recommended",
+  "minSeverity": "medium",
+  "disabledRules": [],
+  "disabledJudges": [],
+  "ruleOverrides": {
+    "some-noisy-rule": { "severity": "low" }
+  }
+}`,
+                tips: [
+                    "Start with 'recommended' preset",
+                    "Use minSeverity to filter out low-priority findings",
+                    "Override specific rules without disabling them entirely",
+                ],
+            },
+        ],
+    },
+    {
+        id: "ci-integration",
+        name: "CI/CD Integration",
+        description: "Add Judges to your continuous integration pipeline",
+        steps: [
+            {
+                id: "github-actions",
+                title: "Step 1: GitHub Actions Setup",
+                description: "Add Judges as a review step in your GitHub Actions workflow.",
+                example: `# .github/workflows/judges.yml
+name: Judges Code Review
+on: [pull_request]
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install -g @kevinrabun/judges-cli
+      - run: judges review src/ --format sarif --output results.sarif
+      - uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif`,
+            },
+            {
+                id: "quality-gate",
+                title: "Step 2: Quality Gate",
+                description: "Block PRs that introduce critical or high-severity findings.",
+                command: "judges gate --max-critical 0 --max-high 3",
+                example: "# In CI:\njudges review src/ --format json | judges gate --max-critical 0 --max-high 3\n# Exit code 1 = gate failed, PR should not merge",
+                tips: ["Start lenient (allow some highs) and tighten over time", "Always block on critical findings"],
+            },
+            {
+                id: "diff-review",
+                title: "Step 3: Diff-Only Review",
+                description: "Review only changed files in a PR for faster feedback.",
+                command: "judges diff-review --base main",
+                tips: ["Diff review is much faster than full review", "Combine with baseline for minimal noise"],
+            },
+        ],
+    },
+    {
+        id: "team-adoption",
+        name: "Team Adoption",
+        description: "Roll out Judges across your development team",
+        steps: [
+            {
+                id: "shared-config",
+                title: "Step 1: Shared Configuration",
+                description: "Create a team-wide .judgesrc and commit it to your repository.",
+                example: `// Recommended team .judgesrc
+{
+  "preset": "recommended",
+  "minSeverity": "medium",
+  "disabledRules": []
+}`,
+                tips: ["Start with recommended preset for team consensus", "Document why rules are disabled"],
+            },
+            {
+                id: "baseline-workflow",
+                title: "Step 2: Baseline Workflow",
+                description: "Establish a baseline then only review new findings going forward.",
+                command: "judges baseline create --output .judges-baseline.json",
+                tips: ["Create baseline on main branch", "Each team member starts from the shared baseline"],
+            },
+            {
+                id: "metrics",
+                title: "Step 3: Track Metrics",
+                description: "Monitor your team's security posture over time.",
+                command: "judges trend --days 30",
+                tips: ["Track findings-per-PR to measure improvement", "Celebrate declining finding counts"],
+            },
+        ],
+    },
+];
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runGuidedTour(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges guided-tour — Interactive onboarding tutorials
+
+Usage:
+  judges guided-tour                      List available tour tracks
+  judges guided-tour quickstart           Start the quick start tour
+  judges guided-tour ci-integration       CI/CD integration guide
+  judges guided-tour team-adoption        Team rollout guide
+  judges guided-tour --init               Generate starter .judgesrc
+  judges guided-tour --all                Show all tour content
+
+Options:
+  --init          Generate a starter .judgesrc file
+  --all           Show all tracks at once
+  --format json   JSON output
+  --step <n>      Jump to specific step number
+  --help, -h      Show this help
+
+Available tracks: ${TOUR_TRACKS.map((t) => t.id).join(", ")}
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    // Generate starter config
+    if (argv.includes("--init")) {
+        const rcPath = join(".", ".judgesrc");
+        if (existsSync(rcPath)) {
+            console.log("  .judgesrc already exists — skipping");
+            return;
+        }
+        const config = {
+            preset: "recommended",
+            minSeverity: "medium",
+            disabledRules: [],
+            disabledJudges: [],
+            ruleOverrides: {},
+        };
+        writeFileSync(rcPath, JSON.stringify(config, null, 2) + "\n");
+        console.log("  ✅ Created .judgesrc with recommended defaults");
+        return;
+    }
+    const trackId = argv.find((a) => !a.startsWith("--") && !argv[argv.indexOf(a) - 1]?.startsWith("--"));
+    const stepNum = argv.find((_a, i) => argv[i - 1] === "--step");
+    const showAll = argv.includes("--all");
+    if (format === "json") {
+        const data = trackId
+            ? TOUR_TRACKS.find((t) => t.id === trackId) || TOUR_TRACKS
+            : showAll
+                ? TOUR_TRACKS
+                : TOUR_TRACKS.map(({ steps: _s, ...rest }) => rest);
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // List tracks
+    if (!trackId && !showAll) {
+        console.log(`\n  📚 Judges Guided Tour\n  ──────────────────────────`);
+        for (const track of TOUR_TRACKS) {
+            console.log(`\n    ${track.name} (${track.id})`);
+            console.log(`      ${track.description}`);
+            console.log(`      Steps: ${track.steps.length}`);
+            console.log(`      Run: judges guided-tour ${track.id}`);
+        }
+        console.log(`\n    💡 Quick setup: judges guided-tour --init\n`);
+        return;
+    }
+    // Show track(s)
+    const tracks = showAll ? TOUR_TRACKS : [TOUR_TRACKS.find((t) => t.id === trackId)];
+    if (!tracks[0]) {
+        console.error(`  Unknown track: ${trackId}\n  Available: ${TOUR_TRACKS.map((t) => t.id).join(", ")}`);
+        return;
+    }
+    for (const track of tracks) {
+        console.log(`\n  ═══════════════════════════════════════`);
+        console.log(`  📚 ${track.name}`);
+        console.log(`  ${track.description}`);
+        console.log(`  ═══════════════════════════════════════`);
+        const steps = stepNum ? [track.steps[parseInt(stepNum) - 1]].filter(Boolean) : track.steps;
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const num = stepNum ? parseInt(stepNum) : i + 1;
+            console.log(`\n  ─── ${num}/${track.steps.length} ──────────────────────────`);
+            console.log(`  ${step.title}`);
+            console.log(`  ${step.description}`);
+            if (step.command) {
+                console.log(`\n    $ ${step.command}`);
+            }
+            if (step.example) {
+                console.log(`\n${step.example
+                    .split("\n")
+                    .map((l) => "    " + l)
+                    .join("\n")}`);
+            }
+            if (step.tips && step.tips.length > 0) {
+                console.log("");
+                for (const tip of step.tips) {
+                    console.log(`    💡 ${tip}`);
+                }
+            }
+        }
+        console.log("");
+    }
+    // Generate .judgesrc directory for tour progress
+    const tourDir = join(".", ".judges-tour");
+    if (!existsSync(tourDir))
+        mkdirSync(tourDir, { recursive: true });
+}

package/dist/commands/habit-tracker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Habit tracker — track recurring finding patterns per developer or
+ * AI model and surface personalized improvement suggestions.
+ *
+ * Data stored locally in `.judges-habits/`.
+ */
+export declare function runHabitTracker(argv: string[]): void;

package/dist/commands/habit-tracker.js

@@ -0,0 +1,194 @@
+/**
+ * Habit tracker — track recurring finding patterns per developer or
+ * AI model and surface personalized improvement suggestions.
+ *
+ * Data stored locally in `.judges-habits/`.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+// ─── Storage ────────────────────────────────────────────────────────────────
+const DATA_DIR = ".judges-habits";
+function ensureDir() {
+    if (!existsSync(DATA_DIR))
+        mkdirSync(DATA_DIR, { recursive: true });
+}
+function loadProfile(author) {
+    const file = join(DATA_DIR, `${author}.json`);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveProfile(profile) {
+    ensureDir();
+    writeFileSync(join(DATA_DIR, `${profile.author}.json`), JSON.stringify(profile, null, 2));
+}
+// ─── Learning Resources ────────────────────────────────────────────────────
+const CATEGORY_RESOURCES = {
+    "sql-injection": [
+        "Use parameterized queries",
+        "Review OWASP SQL Injection Prevention Cheat Sheet",
+        "Enable SQL linting in CI",
+    ],
+    xss: [
+        "Sanitize all user input before rendering",
+        "Use Content Security Policy headers",
+        "Review OWASP XSS Prevention Cheat Sheet",
+    ],
+    "hardcoded-secret": [
+        "Use environment variables for secrets",
+        "Set up a secrets manager",
+        "Add secret scanning to pre-commit hooks",
+    ],
+    "empty-catch": [
+        "Always log or re-throw caught exceptions",
+        "Use error monitoring (Sentry, etc.)",
+        "Define error handling strategy per module",
+    ],
+    "missing-auth": [
+        "Apply auth middleware to all routes",
+        "Review OWASP Authentication Cheat Sheet",
+        "Implement role-based access control",
+    ],
+    "insecure-crypto": [
+        "Use crypto.randomUUID() for tokens",
+        "Use bcrypt/scrypt for password hashing",
+        "Never use MD5 or SHA1 for security",
+    ],
+    "error-handling": [
+        "Define a consistent error hierarchy",
+        "Use Result types or Either monads",
+        "Log errors with correlation IDs",
+    ],
+    performance: ["Profile before optimizing", "Use pagination for list endpoints", "Cache frequently accessed data"],
+    "code-quality": [
+        "Follow single responsibility principle",
+        "Reduce cyclomatic complexity",
+        "Write meaningful test names",
+    ],
+    documentation: ["Keep JSDoc in sync with code", "Document public API contracts", "Add examples to complex functions"],
+};
+function getResources(category) {
+    const key = Object.keys(CATEGORY_RESOURCES).find((k) => category.toLowerCase().includes(k));
+    return key
+        ? CATEGORY_RESOURCES[key]
+        : ["Review team coding standards", "Add targeted linting rules", "Consider pair programming for this area"];
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runHabitTracker(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges habit-tracker — Track recurring finding patterns
+
+Usage:
+  judges habit-tracker --record --author "alice" --category "sql-injection"
+  judges habit-tracker --record --author "copilot" --category "empty-catch" --count 3
+  judges habit-tracker --show --author "alice"
+  judges habit-tracker --digest --author "alice"
+
+Options:
+  --record              Record finding occurrence
+  --author <name>       Developer or AI model name
+  --category <name>     Finding category (e.g., sql-injection, xss, empty-catch)
+  --count <n>           Number of occurrences (default: 1)
+  --show                Show author's habit profile
+  --digest              Show improvement digest with resources
+  --format json         JSON output
+  --help, -h            Show this help
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const isRecord = argv.includes("--record");
+    const isDigest = argv.includes("--digest");
+    const authorName = argv.find((_a, i) => argv[i - 1] === "--author") || "";
+    const category = argv.find((_a, i) => argv[i - 1] === "--category") || "";
+    const count = parseInt(argv.find((_a, i) => argv[i - 1] === "--count") || "1");
+    if (!authorName) {
+        console.error("  --author is required");
+        return;
+    }
+    if (isRecord) {
+        if (!category) {
+            console.error("  --category is required for --record");
+            return;
+        }
+        const profile = loadProfile(authorName) || {
+            author: authorName,
+            entries: [],
+            totalFindings: 0,
+            topCategory: "",
+            lastUpdated: "",
+        };
+        let entry = profile.entries.find((e) => e.category === category);
+        if (!entry) {
+            entry = { category, count: 0, lastSeen: "", trend: "stable", resources: getResources(category) };
+            profile.entries.push(entry);
+        }
+        const prevCount = entry.count;
+        entry.count += count;
+        entry.lastSeen = new Date().toISOString();
+        entry.trend = entry.count > prevCount * 1.5 ? "rising" : entry.count < prevCount * 0.7 ? "declining" : "stable";
+        profile.totalFindings += count;
+        profile.topCategory = profile.entries.sort((a, b) => b.count - a.count)[0]?.category || "";
+        profile.lastUpdated = new Date().toISOString();
+        saveProfile(profile);
+        console.log(`  ✅ Recorded ${count}x ${category} for ${authorName} (total: ${entry.count})`);
+        return;
+    }
+    if (isDigest) {
+        const profile = loadProfile(authorName);
+        if (!profile || profile.entries.length === 0) {
+            console.log(`  No data for ${authorName}. Use --record to add findings.`);
+            return;
+        }
+        const sorted = [...profile.entries].sort((a, b) => b.count - a.count);
+        const top3 = sorted.slice(0, 3);
+        if (format === "json") {
+            console.log(JSON.stringify({
+                author: authorName,
+                digest: top3,
+                totalFindings: profile.totalFindings,
+                timestamp: new Date().toISOString(),
+            }, null, 2));
+        }
+        else {
+            console.log(`\n  Weekly Improvement Digest for ${authorName}\n  ──────────────────────────`);
+            console.log(`  Total findings: ${profile.totalFindings} across ${profile.entries.length} categories\n`);
+            for (const entry of top3) {
+                const trendIcon = entry.trend === "rising" ? "📈" : entry.trend === "declining" ? "📉" : "➡️";
+                console.log(`    ${trendIcon} ${entry.category} — ${entry.count} occurrences (${entry.trend})`);
+                console.log("        Suggested improvements:");
+                for (const r of entry.resources) {
+                    console.log(`          • ${r}`);
+                }
+                console.log("");
+            }
+        }
+        return;
+    }
+    // Default: show profile
+    const profile = loadProfile(authorName);
+    if (!profile || profile.entries.length === 0) {
+        console.log(`  No data for ${authorName}. Use --record to add findings.`);
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify(profile, null, 2));
+    }
+    else {
+        console.log(`\n  Habit Profile: ${authorName}\n  ──────────────────────────`);
+        console.log(`  Total: ${profile.totalFindings} | Categories: ${profile.entries.length} | Top: ${profile.topCategory}\n`);
+        const sorted = [...profile.entries].sort((a, b) => b.count - a.count);
+        for (const entry of sorted) {
+            const bar = "█".repeat(Math.min(20, Math.floor((entry.count / Math.max(1, profile.totalFindings)) * 40)));
+            const trendIcon = entry.trend === "rising" ? "↑" : entry.trend === "declining" ? "↓" : "→";
+            console.log(`    ${entry.category.padEnd(25)} ${String(entry.count).padStart(4)} ${bar} ${trendIcon}`);
+        }
+        console.log("");
+    }
+}

package/dist/commands/hallucination-detect.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hallucination detect — find fabricated API calls, non-existent methods, and invented config options.
+ */
+export declare function runHallucinationDetect(argv: string[]): void;