@kevinrabun/judges-cli 3.124.0

package/dist/commands/perf-compare.js

@@ -0,0 +1,245 @@
+/**
+ * Perf compare — before/after performance comparison of code changes.
+ * Compares algorithmic complexity, loop nesting, allocation patterns,
+ * and async anti-patterns between two code versions.
+ *
+ * All analysis local.
+ */
+import { existsSync, readFileSync } from "fs";
+// ─── Analysers ──────────────────────────────────────────────────────────────
+function analyzePerformance(content) {
+    const lines = content.split("\n");
+    // Loop depth
+    let maxLoopDepth = 0;
+    let currentDepth = 0;
+    let loopCount = 0;
+    for (const line of lines) {
+        if (/\b(?:for|while|do)\s*\(/.test(line) || /\.(?:forEach|map|filter|reduce|flatMap|some|every)\s*\(/.test(line)) {
+            currentDepth++;
+            loopCount++;
+            maxLoopDepth = Math.max(maxLoopDepth, currentDepth);
+        }
+        // Rough depth tracking by braces
+        const opens = (line.match(/{/g) || []).length;
+        const closes = (line.match(/}/g) || []).length;
+        if (closes > opens && currentDepth > 0)
+            currentDepth--;
+    }
+    // Allocations (new, object/array literals in loops)
+    let allocations = 0;
+    for (const line of lines) {
+        if (/\bnew\s+\w+/.test(line))
+            allocations++;
+        if (/(?:new\s+Array|new\s+Object|\[\s*\]|\{\s*\})\s*;?\s*$/.test(line.trim()))
+            allocations++;
+    }
+    // Async anti-patterns
+    let asyncAntiPatterns = 0;
+    for (let i = 0; i < lines.length; i++) {
+        // await in loop
+        if (/\bawait\b/.test(lines[i]) && currentDepth > 0)
+            asyncAntiPatterns++;
+        // sequential awaits that could be parallel
+        if (/\bawait\b/.test(lines[i]) && i > 0 && /\bawait\b/.test(lines[i - 1]))
+            asyncAntiPatterns++;
+    }
+    // Recursive calls
+    let recursiveCalls = 0;
+    const fnNames = [];
+    for (const line of lines) {
+        const fnMatch = line.match(/(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\(|function))/);
+        if (fnMatch)
+            fnNames.push(fnMatch[1] || fnMatch[2]);
+    }
+    for (const line of lines) {
+        for (const fn of fnNames) {
+            if (fn && new RegExp(`\\b${fn}\\s*\\(`).test(line)) {
+                const fnDef = lines.find((l) => l.includes(`function ${fn}`) || l.includes(`${fn} =`));
+                if (fnDef && fnDef !== line)
+                    recursiveCalls++;
+            }
+        }
+    }
+    // Regex count (complex regex can be perf bottleneck)
+    let regexCount = 0;
+    for (const line of lines) {
+        if (/new\s+RegExp|\/[^/]+\/[gimsuy]*/.test(line))
+            regexCount++;
+    }
+    // String concatenation in loops
+    let stringConcat = 0;
+    for (const line of lines) {
+        if (/\+=\s*["'`]|["'`]\s*\+/.test(line))
+            stringConcat++;
+    }
+    // Nested callbacks
+    let nestedCallbacks = 0;
+    let callbackDepth = 0;
+    for (const line of lines) {
+        if (/\bcallback\b|function\s*\(|=>\s*{/.test(line)) {
+            callbackDepth++;
+            if (callbackDepth >= 3)
+                nestedCallbacks++;
+        }
+        if (/}\s*\)/.test(line) && callbackDepth > 0)
+            callbackDepth--;
+    }
+    // Big-O estimate
+    let bigO = "O(n)";
+    if (maxLoopDepth >= 3)
+        bigO = "O(n³+)";
+    else if (maxLoopDepth === 2)
+        bigO = "O(n²)";
+    else if (recursiveCalls > 0 && maxLoopDepth > 0)
+        bigO = "O(n log n)";
+    else if (loopCount === 0)
+        bigO = "O(1)";
+    return {
+        loopDepth: maxLoopDepth,
+        loopCount,
+        allocations,
+        asyncAntiPatterns,
+        recursiveCalls,
+        regexCount,
+        stringConcat,
+        nestedCallbacks,
+        bigOEstimate: bigO,
+        lineCount: lines.length,
+    };
+}
+function compareAnalyses(before, after) {
+    const metrics = [];
+    function add(name, b, a, higherIsWorse, severity) {
+        const delta = a - b;
+        let verdict = "unchanged";
+        if (delta !== 0)
+            verdict = delta > 0 === higherIsWorse ? "regressed" : "improved";
+        metrics.push({
+            name,
+            before: b,
+            after: a,
+            delta,
+            verdict,
+            severity: verdict === "regressed" ? severity : undefined,
+        });
+    }
+    add("Loop nesting depth", before.loopDepth, after.loopDepth, true, "high");
+    add("Loop count", before.loopCount, after.loopCount, true, "medium");
+    add("Allocations", before.allocations, after.allocations, true, "medium");
+    add("Async anti-patterns", before.asyncAntiPatterns, after.asyncAntiPatterns, true, "high");
+    add("Recursive calls", before.recursiveCalls, after.recursiveCalls, true, "medium");
+    add("Regex operations", before.regexCount, after.regexCount, true, "low");
+    add("String concatenations", before.stringConcat, after.stringConcat, true, "low");
+    add("Nested callbacks", before.nestedCallbacks, after.nestedCallbacks, true, "medium");
+    add("Lines of code", before.lineCount, after.lineCount, true, "low");
+    // Big-O change
+    const oOrder = ["O(1)", "O(log n)", "O(n)", "O(n log n)", "O(n²)", "O(n³+)"];
+    const bIdx = oOrder.indexOf(before.bigOEstimate);
+    const aIdx = oOrder.indexOf(after.bigOEstimate);
+    metrics.push({
+        name: "Algorithmic complexity",
+        before: bIdx,
+        after: aIdx,
+        delta: aIdx - bIdx,
+        verdict: aIdx > bIdx ? "regressed" : aIdx < bIdx ? "improved" : "unchanged",
+        severity: aIdx > bIdx ? "critical" : undefined,
+        detail: `${before.bigOEstimate} → ${after.bigOEstimate}`,
+    });
+    return metrics;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+export function runPerfCompare(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges perf-compare — Before/after performance comparison
+
+Usage:
+  judges perf-compare <before-file> <after-file>
+  judges perf-compare old.ts new.ts --format json
+
+Options:
+  --format json   JSON output
+  --help, -h      Show this help
+
+Analyses:
+  • Loop nesting depth & count
+  • Memory allocations
+  • Async anti-patterns (await in loop, sequential awaits)
+  • Recursive call patterns
+  • Regex operation count
+  • String concatenation patterns
+  • Callback nesting depth
+  • Algorithmic complexity estimate (Big-O)
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    const positional = argv.filter((a) => !a.startsWith("--") && !argv[argv.indexOf(a) - 1]?.startsWith("--"));
+    if (positional.length < 2) {
+        console.error("  Usage: judges perf-compare <before-file> <after-file>");
+        return;
+    }
+    const [beforeFile, afterFile] = positional;
+    if (!existsSync(beforeFile)) {
+        console.error(`  File not found: ${beforeFile}`);
+        return;
+    }
+    if (!existsSync(afterFile)) {
+        console.error(`  File not found: ${afterFile}`);
+        return;
+    }
+    let beforeContent, afterContent;
+    try {
+        beforeContent = readFileSync(beforeFile, "utf-8");
+    }
+    catch {
+        console.error(`  Cannot read: ${beforeFile}`);
+        return;
+    }
+    try {
+        afterContent = readFileSync(afterFile, "utf-8");
+    }
+    catch {
+        console.error(`  Cannot read: ${afterFile}`);
+        return;
+    }
+    const beforeAnalysis = analyzePerformance(beforeContent);
+    const afterAnalysis = analyzePerformance(afterContent);
+    const metrics = compareAnalyses(beforeAnalysis, afterAnalysis);
+    const regressions = metrics.filter((m) => m.verdict === "regressed");
+    const improvements = metrics.filter((m) => m.verdict === "improved");
+    if (format === "json") {
+        console.log(JSON.stringify({
+            before: { file: beforeFile, analysis: beforeAnalysis },
+            after: { file: afterFile, analysis: afterAnalysis },
+            metrics,
+            summary: {
+                regressions: regressions.length,
+                improvements: improvements.length,
+                unchanged: metrics.filter((m) => m.verdict === "unchanged").length,
+            },
+            timestamp: new Date().toISOString(),
+        }, null, 2));
+    }
+    else {
+        console.log(`\n  Performance Comparison`);
+        console.log(`  Before: ${beforeFile} (${beforeAnalysis.bigOEstimate})`);
+        console.log(`  After:  ${afterFile} (${afterAnalysis.bigOEstimate})\n  ──────────────────────────`);
+        console.log(`\n    ${"Metric".padEnd(30)} ${"Before".padEnd(8)} ${"After".padEnd(8)} ${"Delta".padEnd(8)} Verdict`);
+        console.log(`    ${"─".repeat(70)}`);
+        for (const m of metrics) {
+            const icon = m.verdict === "improved" ? "✅" : m.verdict === "regressed" ? "❌" : "➖";
+            const deltaStr = m.delta > 0 ? `+${m.delta}` : String(m.delta);
+            const detail = m.detail ? ` (${m.detail})` : "";
+            console.log(`    ${m.name.padEnd(30)} ${String(m.before).padEnd(8)} ${String(m.after).padEnd(8)} ${deltaStr.padEnd(8)} ${icon}${detail}`);
+        }
+        console.log(`\n    Summary: ${improvements.length} improved, ${regressions.length} regressed, ${metrics.length - improvements.length - regressions.length} unchanged`);
+        if (regressions.length > 0) {
+            console.log(`\n    ⚠️  Performance regressions detected:`);
+            for (const r of regressions) {
+                console.log(`      • ${r.name}: ${r.before} → ${r.after}${r.severity ? ` [${r.severity}]` : ""}${r.detail ? ` (${r.detail})` : ""}`);
+            }
+        }
+        console.log("");
+    }
+}

package/dist/commands/perf-hotspot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performance hotspot detection — scans code for common
+ * performance anti-patterns using pattern-based analysis.
+ *
+ * All data stored locally.
+ */
+export declare function runPerfHotspot(argv: string[]): void;

package/dist/commands/perf-hotspot.js

@@ -0,0 +1,273 @@
+/**
+ * Performance hotspot detection — scans code for common
+ * performance anti-patterns using pattern-based analysis.
+ *
+ * All data stored locally.
+ */
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync } from "fs";
+import { join, extname } from "path";
+// ─── Patterns ───────────────────────────────────────────────────────────────
+const PERF_PATTERNS = [
+    {
+        id: "n-plus-one",
+        name: "N+1 Query Pattern",
+        severity: "critical",
+        description: "Database query inside a loop",
+        regex: /for\s*\(.*\)\s*\{[^}]*(?:\.query|\.execute|\.find|\.fetch|\.select|await\s+db\.|await\s+prisma\.)/s,
+        extensions: [".ts", ".js", ".py", ".java", ".go", ".rb"],
+        recommendation: "Batch queries outside the loop or use eager loading / JOIN",
+    },
+    {
+        id: "unbounded-collection",
+        name: "Unbounded Collection Fetch",
+        severity: "high",
+        description: "Fetching all records without limit/pagination",
+        regex: /\.findAll\(\s*\)|\.find\(\s*\{\s*\}\s*\)|SELECT\s+\*\s+FROM\s+\w+\s*(?:WHERE|;|\)|$)/i,
+        extensions: [".ts", ".js", ".py", ".java", ".go", ".rb"],
+        recommendation: "Add LIMIT/pagination or use cursor-based fetching",
+    },
+    {
+        id: "sync-io-hot-path",
+        name: "Synchronous I/O in Hot Path",
+        severity: "high",
+        description: "Synchronous file/network I/O that could block event loop",
+        regex: /readFileSync|writeFileSync|execSync|spawnSync/,
+        extensions: [".ts", ".js"],
+        recommendation: "Use async variants (readFile, writeFile, exec) in request handlers",
+    },
+    {
+        id: "string-concat-loop",
+        name: "String Concatenation in Loop",
+        severity: "medium",
+        description: "String concatenation inside a loop (O(n²) in some languages)",
+        regex: /for\s*\(.*\)\s*\{[^}]*\+=\s*["'`]|for\s*\(.*\)\s*\{[^}]*\+=\s*\w+/s,
+        extensions: [".ts", ".js", ".py", ".java", ".go", ".cs"],
+        recommendation: "Use array.join(), StringBuilder, or strings.Builder",
+    },
+    {
+        id: "missing-index-hint",
+        name: "Missing Index Hint",
+        severity: "medium",
+        description: "Query with WHERE clause on non-obvious columns",
+        regex: /WHERE\s+\w+\.\w+\s*(?:=|LIKE|IN|>|<)\s*/i,
+        extensions: [".sql", ".ts", ".js", ".py", ".java"],
+        recommendation: "Ensure queried columns have appropriate database indexes",
+    },
+    {
+        id: "excessive-json-parse",
+        name: "Repeated JSON Parse/Stringify",
+        severity: "medium",
+        description: "JSON.parse/stringify inside loops or frequently called functions",
+        regex: /for\s*\(.*\)\s*\{[^}]*JSON\.(?:parse|stringify)/s,
+        extensions: [".ts", ".js"],
+        recommendation: "Parse once and reuse the object; consider streaming parsers for large data",
+    },
+    {
+        id: "regex-in-loop",
+        name: "Regex Compilation in Loop",
+        severity: "low",
+        description: "Creating new RegExp objects inside loops",
+        regex: /for\s*\(.*\)\s*\{[^}]*new\s+RegExp\(/s,
+        extensions: [".ts", ".js", ".py", ".java"],
+        recommendation: "Compile regex once outside the loop and reuse",
+    },
+    {
+        id: "large-object-spread",
+        name: "Large Object Spread in Loop",
+        severity: "medium",
+        description: "Object spread operator inside loops creates many copies",
+        regex: /for\s*\(.*\)\s*\{[^}]*\.\.\.\w+/s,
+        extensions: [".ts", ".js"],
+        recommendation: "Mutate directly or use Object.assign for better performance",
+    },
+];
+// ─── Scanner ────────────────────────────────────────────────────────────────
+function scanFile(filePath, patterns) {
+    const ext = extname(filePath);
+    const applicable = patterns.filter((p) => p.extensions.includes(ext));
+    if (applicable.length === 0)
+        return [];
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split("\n");
+    const hotspots = [];
+    for (const pattern of applicable) {
+        const match = pattern.regex.exec(content);
+        if (match) {
+            const beforeMatch = content.substring(0, match.index);
+            const lineNum = beforeMatch.split("\n").length;
+            hotspots.push({
+                file: filePath,
+                line: lineNum,
+                patternId: pattern.id,
+                patternName: pattern.name,
+                severity: pattern.severity,
+                snippet: lines[lineNum - 1]?.trim() || "",
+                recommendation: pattern.recommendation,
+            });
+        }
+    }
+    return hotspots;
+}
+function collectFiles(dir, exts, maxFiles) {
+    const result = [];
+    const skipDirs = new Set(["node_modules", ".git", "dist", "build", "coverage", ".next"]);
+    function walk(d) {
+        if (result.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d, { withFileTypes: true }).map((e) => (typeof e === "string" ? e : e.name));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (result.length >= maxFiles)
+                return;
+            const full = join(d, entry);
+            if (skipDirs.has(entry))
+                continue;
+            try {
+                const stat = readFileSync(full, "utf-8"); // test readable
+                void stat;
+                if (exts.includes(extname(entry))) {
+                    result.push(full);
+                }
+            }
+            catch {
+                // might be a directory
+                try {
+                    const sub = readdirSync(full);
+                    void sub;
+                    walk(full);
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+    }
+    walk(dir);
+    return result;
+}
+// ─── CLI ────────────────────────────────────────────────────────────────────
+const STORE = ".judges-perf-hotspots";
+export function runPerfHotspot(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(`
+judges perf-hotspot — Performance hotspot detection
+
+Usage:
+  judges perf-hotspot [dir]
+  judges perf-hotspot src/ --severity critical,high
+  judges perf-hotspot --patterns
+  judges perf-hotspot --history
+
+Options:
+  --severity <levels>   Filter by severity (comma-separated)
+  --patterns            List all performance patterns
+  --history             Show scan history
+  --format json         JSON output
+  --help, -h            Show this help
+`);
+        return;
+    }
+    const format = argv.find((_a, i) => argv[i - 1] === "--format") || "text";
+    // List patterns
+    if (argv.includes("--patterns")) {
+        if (format === "json") {
+            console.log(JSON.stringify(PERF_PATTERNS.map(({ regex: _r, ...rest }) => rest), null, 2));
+        }
+        else {
+            console.log(`\n  Performance Anti-Patterns (${PERF_PATTERNS.length})\n  ──────────────────────────`);
+            for (const p of PERF_PATTERNS) {
+                console.log(`    [${p.severity.toUpperCase().padEnd(8)}] ${p.id.padEnd(25)} ${p.name}`);
+            }
+            console.log("");
+        }
+        return;
+    }
+    // History
+    if (argv.includes("--history")) {
+        const histPath = join(STORE, "scan-history.json");
+        const history = existsSync(histPath) ? JSON.parse(readFileSync(histPath, "utf-8")) : [];
+        if (format === "json") {
+            console.log(JSON.stringify(history, null, 2));
+        }
+        else {
+            if (history.length === 0) {
+                console.log("  No scan history.");
+                return;
+            }
+            console.log(`\n  Scan History\n  ──────────────────────────`);
+            for (const h of history.slice(-10)) {
+                console.log(`    ${h.timestamp}  ${h.scannedFiles} files  ${h.hotspots} hotspots`);
+            }
+            console.log("");
+        }
+        return;
+    }
+    // Scan
+    const scanDir = argv.find((a) => !a.startsWith("--") && !argv[argv.indexOf(a) - 1]?.startsWith("--")) || ".";
+    const sevFilter = argv.find((_a, i) => argv[i - 1] === "--severity");
+    const allowedSev = sevFilter ? sevFilter.split(",") : null;
+    const allExts = [...new Set(PERF_PATTERNS.flatMap((p) => p.extensions))];
+    const files = collectFiles(scanDir, allExts, 500);
+    let hotspots = [];
+    for (const file of files) {
+        hotspots.push(...scanFile(file, PERF_PATTERNS));
+    }
+    if (allowedSev) {
+        hotspots = hotspots.filter((h) => allowedSev.includes(h.severity));
+    }
+    const report = {
+        hotspots,
+        scannedFiles: files.length,
+        patternsChecked: PERF_PATTERNS.length,
+        timestamp: new Date().toISOString(),
+    };
+    // Save history
+    if (!existsSync(STORE))
+        mkdirSync(STORE, { recursive: true });
+    const histPath = join(STORE, "scan-history.json");
+    const history = existsSync(histPath) ? JSON.parse(readFileSync(histPath, "utf-8")) : [];
+    history.push({ timestamp: report.timestamp, scannedFiles: report.scannedFiles, hotspots: hotspots.length });
+    writeFileSync(histPath, JSON.stringify(history, null, 2));
+    if (format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`\n  Performance Hotspot Scan`);
+        console.log(`  Scanned: ${report.scannedFiles} files  Patterns: ${report.patternsChecked}`);
+        console.log(`  Found: ${hotspots.length} hotspots\n  ──────────────────────────`);
+        if (hotspots.length === 0) {
+            console.log(`    ✅ No performance hotspots detected\n`);
+            return;
+        }
+        const grouped = new Map();
+        for (const h of hotspots) {
+            const key = h.severity;
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(h);
+        }
+        for (const sev of ["critical", "high", "medium", "low"]) {
+            const items = grouped.get(sev);
+            if (!items)
+                continue;
+            console.log(`\n    ${sev.toUpperCase()} (${items.length})`);
+            for (const h of items) {
+                console.log(`      ${h.file}:${h.line} — ${h.patternName}`);
+                console.log(`        ${h.snippet}`);
+                console.log(`        → ${h.recommendation}`);
+            }
+        }
+        console.log("");
+    }
+}

package/dist/commands/phantom-import.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Phantom import — detect hallucinated imports, non-existent modules, and wrong export names.
+ */
+export declare function runPhantomImport(argv: string[]): void;