@vibecodeqa/cli 0.16.0 → 0.18.0

package/dist/runners/architecture.js

@@ -228,8 +228,22 @@ export function generateArchSVG(details) {
         return "";
     const nodes = Object.entries(graph);
     const nodeCount = nodes.length;
-    if (nodeCount > 40)
-        return ""; // too many nodes to render meaningfully
+    if (nodeCount > 50)
+        return `<div style="color:#6b7280;font-size:0.75rem">${nodeCount} modules — too many to render. Consider splitting into smaller packages.</div>`;
+    // Detect cycles for highlighting
+    const cycleEdges = new Set();
+    const cycles = details.circularDeps;
+    if (cycles > 0) {
+        // Mark edges that participate in cycles (simplified: mutual imports)
+        for (const [path, info] of nodes) {
+            for (const imp of info.imports) {
+                if (graph[imp]?.imports.includes(path)) {
+                    cycleEdges.add(`${path}->${imp}`);
+                    cycleEdges.add(`${imp}->${path}`);
+                }
+            }
+        }
+    }
     // Group by directory
     const dirs = new Map();
     for (const [path, info] of nodes) {
@@ -238,23 +252,33 @@ export function generateArchSVG(details) {
         arr.push(path);
         dirs.set(dir, arr);
     }
-    const W = 800, padding = 40;
+    const W = 800, padding = 50;
     const dirEntries = [...dirs.entries()];
     const dirWidth = (W - padding * 2) / Math.max(dirEntries.length, 1);
+    const nodeSpacing = 38;
     // Position nodes
     const positions = new Map();
     let dirIdx = 0;
-    for (const [_d, paths] of dirEntries) {
+    for (const [, paths] of dirEntries) {
         const x0 = padding + dirIdx * dirWidth + dirWidth / 2;
         for (let i = 0; i < paths.length; i++) {
-            const y = padding + 50 + i * 35;
+            const y = padding + 55 + i * nodeSpacing;
             positions.set(paths[i], { x: x0, y });
         }
         dirIdx++;
     }
-    const H = Math.max(300, padding * 2 + 50 + Math.max(...[...dirs.values()].map((p) => p.length)) * 35 + 20);
-    // Draw edges
-    let edges = "";
+    const maxGroupLen = Math.max(...[...dirs.values()].map((p) => p.length));
+    const H = Math.max(320, padding * 2 + 55 + maxGroupLen * nodeSpacing + 50);
+    // ── Defs: arrowhead marker, glow filter ──
+    const defs = `<defs>
+<marker id="ah" viewBox="0 0 10 7" refX="10" refY="3.5" markerWidth="8" markerHeight="6" orient="auto"><polygon points="0 0, 10 3.5, 0 7" fill="#818cf850"/></marker>
+<marker id="ah-cross" viewBox="0 0 10 7" refX="10" refY="3.5" markerWidth="8" markerHeight="6" orient="auto"><polygon points="0 0, 10 3.5, 0 7" fill="#ef444460"/></marker>
+<marker id="ah-cycle" viewBox="0 0 10 7" refX="10" refY="3.5" markerWidth="8" markerHeight="6" orient="auto"><polygon points="0 0, 10 3.5, 0 7" fill="#f97316"/></marker>
+</defs>`;
+    // ── Background — transparent, inherits page dark bg ──
+    const bg = `<rect width="${W}" height="${H}" rx="8" fill="none"/>`;
+    // ── Draw edges (curved bezier paths with arrows) ──
+    let edgesSvg = "";
     for (const [path, info] of nodes) {
         const from = positions.get(path);
         if (!from)
@@ -263,22 +287,36 @@ export function generateArchSVG(details) {
             const to = positions.get(imp);
             if (!to)
                 continue;
-            const color = info.dir !== graph[imp]?.dir ? "#ef444440" : "#818cf825";
-            edges += `<line x1="${from.x}" y1="${from.y}" x2="${to.x}" y2="${to.y}" stroke="${color}" stroke-width="1.5"/>`;
+            const isCycle = cycleEdges.has(`${path}->${imp}`);
+            const isCross = info.dir !== graph[imp]?.dir;
+            const color = isCycle ? "#f9731680" : isCross ? "#ef444435" : "#818cf820";
+            const marker = isCycle ? "url(#ah-cycle)" : isCross ? "url(#ah-cross)" : "url(#ah)";
+            const width = isCycle ? "2" : "1.2";
+            const dash = isCycle ? ' stroke-dasharray="5,3"' : "";
+            // Bezier curve: offset control point sideways to avoid straight-line overlap
+            const dx = to.x - from.x;
+            const dy = to.y - from.y;
+            const cx1 = from.x + dx * 0.3 + (dy === 0 ? 0 : Math.sign(dx) * 15);
+            const cy1 = from.y + dy * 0.3;
+            const cx2 = to.x - dx * 0.3 + (dy === 0 ? 0 : Math.sign(dx) * 15);
+            const cy2 = to.y - dy * 0.3;
+            edgesSvg += `<path d="M${from.x},${from.y} C${cx1},${cy1} ${cx2},${cy2} ${to.x},${to.y}" fill="none" stroke="${color}" stroke-width="${width}" marker-end="${marker}"${dash}/>`;
         }
     }
-    // Draw directory groups
-    let groups = "";
+    // ── Draw directory groups ──
+    let groupsSvg = "";
     dirIdx = 0;
     for (const [dName, paths] of dirEntries) {
         const x = padding + dirIdx * dirWidth;
-        const h = paths.length * 35 + 20;
-        groups += `<rect x="${x + 5}" y="${padding + 30}" width="${dirWidth - 10}" height="${h}" rx="8" fill="#14141a" stroke="#23232a"/>`;
-        groups += `<text x="${x + dirWidth / 2}" y="${padding + 22}" text-anchor="middle" fill="#6b7280" font-size="10" font-weight="600">${dName === "." ? "root" : dName.split("/").pop()}</text>`;
+        const h = paths.length * nodeSpacing + 24;
+        groupsSvg += `<rect x="${x + 5}" y="${padding + 32}" width="${dirWidth - 10}" height="${h}" rx="8" fill="#ffffff06" stroke="#ffffff10"/>`;
+        const label = dName === "." ? "root" : dName.split("/").pop();
+        groupsSvg += `<text x="${x + dirWidth / 2}" y="${padding + 24}" text-anchor="middle" fill="#6b7280" font-size="10" font-weight="700" letter-spacing="0.03em">${label}</text>`;
         dirIdx++;
     }
-    // Draw nodes
+    // ── Draw nodes ──
     let nodesSvg = "";
+    const godThreshold = Math.max(3, Math.floor(nodeCount * 0.5));
     for (const [path] of nodes) {
         const pos = positions.get(path);
         if (!pos)
@@ -286,9 +324,183 @@ export function generateArchSVG(details) {
         const name = basename(path, extname(path));
         const info = graph[path];
         const fanIn = info.importedBy.length;
-        const size = Math.min(8, 3 + fanIn);
-        nodesSvg += `<circle cx="${pos.x}" cy="${pos.y}" r="${size}" fill="#818cf8"/>`;
-        nodesSvg += `<text x="${pos.x + size + 4}" y="${pos.y + 3}" fill="#e5e5e5" font-size="9">${name}</text>`;
+        const fanOut = info.imports.length;
+        // Node color based on health
+        const isGod = fanIn >= godThreshold;
+        const isOrphan = fanIn === 0 && !["index", "main", "cli", "App"].includes(name);
+        const isHighFanOut = fanOut > 10;
+        const isInCycle = [...cycleEdges].some((e) => e.startsWith(path + "->") || e.endsWith("->" + path));
+        let nodeColor = "#6d78d0"; // default: softer accent
+        if (isInCycle)
+            nodeColor = "#d97706"; // amber for cycle participant
+        else if (isGod)
+            nodeColor = "#dc2626"; // red for god module
+        else if (isOrphan)
+            nodeColor = "#4b5563"; // dim for orphan
+        else if (isHighFanOut)
+            nodeColor = "#ca8a04"; // yellow for high fan-out
+        const size = Math.min(9, 3 + Math.floor(fanIn * 0.8));
+        // Node circle with subtle glow for important nodes
+        if (isGod || isInCycle) {
+            nodesSvg += `<circle cx="${pos.x}" cy="${pos.y}" r="${size + 4}" fill="${nodeColor}" opacity="0.15"/>`;
+        }
+        nodesSvg += `<circle cx="${pos.x}" cy="${pos.y}" r="${size}" fill="${nodeColor}"/>`;
+        // Label
+        const labelColor = isOrphan ? "#4b5563" : "#9ca3af";
+        nodesSvg += `<text x="${pos.x + size + 5}" y="${pos.y + 3}" fill="${labelColor}" font-size="9" font-weight="${isGod ? "700" : "400"}">${name}</text>`;
+        // Fan-in/fan-out badge (only for notable nodes)
+        if (fanIn > 2 || fanOut > 5) {
+            nodesSvg += `<text x="${pos.x + size + 5}" y="${pos.y + 13}" fill="#555" font-size="7">${fanIn}\u2190 ${fanOut}\u2192</text>`;
+        }
+    }
+    // ── Legend ──
+    const legendY = H - 30;
+    const legend = `<g transform="translate(${padding}, ${legendY})" font-size="8" fill="#6b7280">
+<circle cx="0" cy="0" r="4" fill="#6d78d0"/><text x="8" y="3">module</text>
+<circle cx="60" cy="0" r="4" fill="#dc2626"/><text x="68" y="3">god module</text>
+<circle cx="140" cy="0" r="4" fill="#d97706"/><text x="148" y="3">in cycle</text>
+<circle cx="200" cy="0" r="4" fill="#ca8a04"/><text x="208" y="3">high fan-out</text>
+<circle cx="280" cy="0" r="4" fill="#4b5563"/><text x="288" y="3">orphan</text>
+<line x1="330" y1="0" x2="350" y2="0" stroke="#ef444440" stroke-width="1.2"/><text x="354" y="3">cross-dir</text>
+<line x1="410" y1="0" x2="430" y2="0" stroke="#d97706" stroke-width="1.5" stroke-dasharray="5,3"/><text x="434" y="3">circular</text>
+</g>`;
+    return `<svg viewBox="0 0 ${W} ${H}" xmlns="http://www.w3.org/2000/svg" style="width:100%;max-width:${W}px">${defs}${bg}${groupsSvg}${edgesSvg}${nodesSvg}${legend}</svg>`;
+}
+// ── Dependency Matrix (DSM) ──────────────────────────────────────────
+// Standard software architecture visualization. Rows and columns are modules,
+// cells show import relationships. Clusters on the diagonal = well-structured packages.
+export function generateDSM(details) {
+    const graph = details.graph;
+    if (!graph || Object.keys(graph).length === 0)
+        return "";
+    const entries = Object.entries(graph);
+    if (entries.length > 40)
+        return `<div style="color:#6b7280;font-size:0.75rem">${entries.length} modules — too many for matrix view.</div>`;
+    if (entries.length < 3)
+        return "";
+    // Sort by directory then name for clustering
+    entries.sort((a, b) => `${a[1].dir}/${a[0]}`.localeCompare(`${b[1].dir}/${b[0]}`));
+    const paths = entries.map(([p]) => p);
+    const idx = new Map(paths.map((p, i) => [p, i]));
+    const n = paths.length;
+    const cell = 14;
+    const labelW = 110;
+    const W = labelW + n * cell + 10;
+    const H = labelW + n * cell + 10;
+    // Build adjacency
+    const matrix = Array.from({ length: n }, () => Array(n).fill(false));
+    for (const [path, info] of entries) {
+        const from = idx.get(path);
+        for (const imp of info.imports) {
+            const to = idx.get(imp);
+            if (to !== undefined)
+                matrix[from][to] = true;
+        }
+    }
+    let svg = "";
+    const ox = labelW, oy = labelW;
+    // Grid
+    for (let i = 0; i <= n; i++) {
+        svg += `<line x1="${ox}" y1="${oy + i * cell}" x2="${ox + n * cell}" y2="${oy + i * cell}" stroke="#1e1e24" stroke-width="0.5"/>`;
+        svg += `<line x1="${ox + i * cell}" y1="${oy}" x2="${ox + i * cell}" y2="${oy + n * cell}" stroke="#1e1e24" stroke-width="0.5"/>`;
+    }
+    // Cells — row imports col
+    for (let r = 0; r < n; r++) {
+        for (let c = 0; c < n; c++) {
+            if (r === c) {
+                // Diagonal — highlight
+                svg += `<rect x="${ox + c * cell}" y="${oy + r * cell}" width="${cell}" height="${cell}" fill="#818cf808"/>`;
+            }
+            else if (matrix[r][c]) {
+                const mutual = matrix[c][r]; // circular?
+                const color = mutual ? "#d97706" : "#6d78d0";
+                svg += `<rect x="${ox + c * cell + 2}" y="${oy + r * cell + 2}" width="${cell - 4}" height="${cell - 4}" rx="2" fill="${color}" opacity="0.7"/>`;
+            }
+        }
+    }
+    // Directory bands (background stripe per dir group)
+    let prevDir = "";
+    let bandStart = 0;
+    const dirColors = ["#ffffff04", "#ffffff08"];
+    let dirIdx2 = 0;
+    for (let i = 0; i <= n; i++) {
+        const dir = i < n ? entries[i][1].dir : "__end__";
+        if (dir !== prevDir && i > 0) {
+            const fill = dirColors[dirIdx2 % 2];
+            svg += `<rect x="${ox}" y="${oy + bandStart * cell}" width="${n * cell}" height="${(i - bandStart) * cell}" fill="${fill}"/>`;
+            svg += `<rect x="${ox + bandStart * cell}" y="${oy}" width="${(i - bandStart) * cell}" height="${n * cell}" fill="${fill}"/>`;
+            dirIdx2++;
+            bandStart = i;
+        }
+        prevDir = dir;
+    }
+    // Row labels (left) and column labels (top, rotated)
+    for (let i = 0; i < n; i++) {
+        const name = basename(paths[i], extname(paths[i]));
+        svg += `<text x="${ox - 4}" y="${oy + i * cell + cell / 2 + 3}" text-anchor="end" fill="#9ca3af" font-size="7">${name}</text>`;
+        svg += `<text x="${ox + i * cell + cell / 2}" y="${oy - 4}" text-anchor="start" fill="#9ca3af" font-size="7" transform="rotate(-60 ${ox + i * cell + cell / 2} ${oy - 4})">${name}</text>`;
+    }
+    // Legend
+    svg += `<g transform="translate(${ox}, ${oy + n * cell + 16})" font-size="7" fill="#6b7280">`;
+    svg += `<rect x="0" y="-4" width="8" height="8" rx="2" fill="#6d78d0" opacity="0.7"/><text x="12" y="3">imports</text>`;
+    svg += `<rect x="60" y="-4" width="8" height="8" rx="2" fill="#d97706" opacity="0.7"/><text x="72" y="3">mutual (cycle)</text>`;
+    svg += `</g>`;
+    return `<svg viewBox="0 0 ${W} ${H + 30}" xmlns="http://www.w3.org/2000/svg" style="width:100%;max-width:${W}px">${svg}</svg>`;
+}
+// ── Package Nesting Diagram ──────────────────────────────────────────
+// UML-style Package diagram: directories as nested boxes, files as items inside.
+export function generatePackageDiagram(details) {
+    const graph = details.graph;
+    if (!graph || Object.keys(graph).length === 0)
+        return "";
+    const entries = Object.entries(graph);
+    if (entries.length > 50)
+        return `<div style="color:#6b7280;font-size:0.75rem">${entries.length} modules — too many for package view.</div>`;
+    // Group by directory
+    const dirs = new Map();
+    for (const [path, info] of entries) {
+        const dir = info.dir || ".";
+        const arr = dirs.get(dir) || [];
+        arr.push({ path, fanIn: info.importedBy.length, fanOut: info.imports.length });
+        dirs.set(dir, arr);
+    }
+    const dirEntries = [...dirs.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    const boxW = 180;
+    const fileH = 18;
+    const headerH = 24;
+    const gap = 16;
+    const cols = Math.min(dirEntries.length, 4);
+    const colW = boxW + gap;
+    let svg = "";
+    let maxH = 0;
+    for (let i = 0; i < dirEntries.length; i++) {
+        const [dir, files] = dirEntries[i];
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const prevRowsH = row * 300; // rough estimate, will adjust
+        const x = gap + col * colW;
+        let y = gap + prevRowsH;
+        const boxH = headerH + files.length * fileH + 8;
+        // Package box
+        svg += `<rect x="${x}" y="${y}" width="${boxW}" height="${boxH}" rx="6" fill="#ffffff04" stroke="#ffffff10"/>`;
+        // Package tab (UML-style)
+        svg += `<rect x="${x}" y="${y}" width="${Math.min(boxW * 0.6, 100)}" height="${headerH}" rx="4" fill="#ffffff08" stroke="#ffffff10"/>`;
+        const label = dir === "." ? "root" : dir.replace(/^src\//, "");
+        svg += `<text x="${x + 8}" y="${y + 16}" fill="#9ca3af" font-size="10" font-weight="700">${label}/</text>`;
+        svg += `<text x="${x + boxW - 8}" y="${y + 16}" text-anchor="end" fill="#4b5563" font-size="8">${files.length}</text>`;
+        y += headerH + 4;
+        // Files inside package
+        for (const f of files) {
+            const name = basename(f.path, extname(f.path));
+            const health = f.fanIn > 5 ? "#d97706" : f.fanOut > 8 ? "#ca8a04" : "#6d78d0";
+            svg += `<circle cx="${x + 12}" cy="${y + 7}" r="3" fill="${health}"/>`;
+            svg += `<text x="${x + 20}" y="${y + 10}" fill="#9ca3af" font-size="8">${name}</text>`;
+            svg += `<text x="${x + boxW - 8}" y="${y + 10}" text-anchor="end" fill="#4b5563" font-size="7">${f.fanIn}\u2190 ${f.fanOut}\u2192</text>`;
+            y += fileH;
+        }
+        maxH = Math.max(maxH, y + 8);
     }
-    return `<svg viewBox="0 0 ${W} ${H}" xmlns="http://www.w3.org/2000/svg" style="width:100%;max-width:${W}px;background:#09090b;border-radius:8px;border:1px solid #1e1e24">${groups}${edges}${nodesSvg}</svg>`;
+    const W = gap + cols * colW;
+    const H = maxH + gap;
+    return `<svg viewBox="0 0 ${W} ${H}" xmlns="http://www.w3.org/2000/svg" style="width:100%;max-width:${W}px">${svg}</svg>`;
 }

package/dist/runners/code-coherence.d.ts

@@ -0,0 +1,17 @@
+/** Code Coherence — detects internal contradictions and inconsistencies in the codebase.
+ *
+ * Premium feature (powered by LLM). Analyzes the codebase for patterns where
+ * different parts of the code contradict each other:
+ *   - Function A validates input X, but function B that calls A re-validates X differently
+ *   - Type says field is required, but all usages treat it as optional
+ *   - Error handling is strict in module A but permissive in module B for the same operations
+ *   - Naming conventions differ across modules (camelCase vs snake_case for same concepts)
+ *   - Two implementations of the same algorithm with different behavior
+ *   - Config declares a feature flag but no code reads it
+ *   - Dead branches: conditions that can never be true given the types
+ *   - Contradictory defaults (module A defaults timeout to 5s, module B to 30s)
+ *
+ * Currently returns a "coming soon" placeholder.
+ */
+import type { CheckResult } from "../types.js";
+export declare function runCodeCoherence(cwd: string): CheckResult;

package/dist/runners/code-coherence.js

@@ -0,0 +1,39 @@
+/** Code Coherence — detects internal contradictions and inconsistencies in the codebase.
+ *
+ * Premium feature (powered by LLM). Analyzes the codebase for patterns where
+ * different parts of the code contradict each other:
+ *   - Function A validates input X, but function B that calls A re-validates X differently
+ *   - Type says field is required, but all usages treat it as optional
+ *   - Error handling is strict in module A but permissive in module B for the same operations
+ *   - Naming conventions differ across modules (camelCase vs snake_case for same concepts)
+ *   - Two implementations of the same algorithm with different behavior
+ *   - Config declares a feature flag but no code reads it
+ *   - Dead branches: conditions that can never be true given the types
+ *   - Contradictory defaults (module A defaults timeout to 5s, module B to 30s)
+ *
+ * Currently returns a "coming soon" placeholder.
+ */
+import { getProductionFiles } from "../fs-utils.js";
+export function runCodeCoherence(cwd) {
+    const start = Date.now();
+    // Gather basic stats even in placeholder mode
+    const files = getProductionFiles(cwd);
+    const totalExports = files.reduce((s, f) => s + (f.content.match(/\bexport\s+/g) || []).length, 0);
+    const totalFunctions = files.reduce((s, f) => s + (f.content.match(/\bfunction\s+\w+/g) || []).length, 0);
+    return {
+        name: "code-coherence",
+        score: 0,
+        grade: "F",
+        details: {
+            premium: true,
+            comingSoon: true,
+            reason: "LLM-powered analysis — coming soon",
+            filesAnalyzed: files.length,
+            totalExports,
+            totalFunctions,
+            description: "Detects internal contradictions: inconsistent validation, conflicting defaults, naming drift, dead config flags, and behavioral mismatches across modules.",
+        },
+        issues: [],
+        duration: Date.now() - start,
+    };
+}

package/dist/runners/complexity.js

@@ -1,6 +1,5 @@
 /** Complexity analysis — counts lines, functions, and cognitive complexity via AST-free heuristics. */
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join } from "node:path";
+import { getProductionFiles } from "../fs-utils.js";
 import { gradeFromScore } from "../types.js";
 const MAX_FUNCTION_LINES = 60;
 const MAX_COMPLEXITY = 15;
@@ -8,27 +7,15 @@ export function runComplexity(cwd) {
     const start = Date.now();
     const issues = [];
     const functions = [];
-    // Find all TS/JS source files (not tests, not node_modules)
-    const srcDirs = ["src", "web/src"];
-    const files = [];
-    for (const dir of srcDirs) {
-        try {
-            collectFiles(join(cwd, dir), files);
-        }
-        catch {
-            /* dir doesn't exist */
-        }
-    }
+    const sourceFiles = getProductionFiles(cwd);
     let totalLines = 0;
-    const totalFiles = files.length;
+    const totalFiles = sourceFiles.length;
     let longFunctions = 0;
     let complexFunctions = 0;
-    for (const file of files) {
-        const content = readFileSync(file, "utf-8");
-        const lines = content.split("\n");
-        totalLines += lines.length;
+    for (const sf of sourceFiles) {
+        totalLines += sf.lines;
         // Simple heuristic: find function boundaries and measure complexity
-        const funcs = extractFunctions(content, file.replace(`${cwd}/`, ""));
+        const funcs = extractFunctions(sf.content, sf.path);
         for (const f of funcs) {
             functions.push(f);
             if (f.lines > MAX_FUNCTION_LINES) {
@@ -68,23 +55,6 @@ export function runComplexity(cwd) {
         duration: Date.now() - start,
     };
 }
-function collectFiles(dir, out) {
-    for (const entry of readdirSync(dir)) {
-        if (entry === "node_modules" || entry === "dist" || entry === ".git")
-            continue;
-        const full = join(dir, entry);
-        const stat = statSync(full);
-        if (stat.isDirectory()) {
-            collectFiles(full, out);
-        }
-        else {
-            const ext = extname(entry);
-            if ((ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx") && !entry.includes(".test.") && !entry.includes(".spec.")) {
-                out.push(full);
-            }
-        }
-    }
-}
 /** Simple heuristic function extraction — not a full AST parser but good enough for metrics. */
 function extractFunctions(content, filePath) {
     const funcs = [];
@@ -138,7 +108,7 @@ function measureComplexity(code) {
     for (const line of lines) {
         const trimmed = line.trim();
         // +1 for each branch/loop keyword
-        if (/\b(if|else if|else|switch|for|while|do|catch|&&|\|\||[?]:)\b/.test(trimmed)) {
+        if (/\b(if|else if|else|switch|for|while|do|catch)\b/.test(trimmed) || /&&|\|\|/.test(trimmed)) {
             complexity++;
         }
         // +1 for ternary

package/dist/runners/confusion.js

@@ -12,8 +12,7 @@
  *   3. Export name collisions (same name exported from multiple files)
  *   4. Ambiguous abbreviations (auth, config, ctx, etc. outside conventional scope)
  */
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, extname, join } from "node:path";
+import { getProductionFiles } from "../fs-utils.js";
 import { gradeFromScore } from "../types.js";
 // ── Pattern dictionaries ──
 const SYNONYM_PAIRS = [
@@ -97,16 +96,8 @@ const AMBIGUOUS_ABBREVS = {
 export function runConfusion(cwd) {
     const start = Date.now();
     const issues = [];
-    const files = [];
-    const dirs = ["src", "web/src"];
-    for (const dir of dirs) {
-        try {
-            collectFiles(join(cwd, dir), cwd, files);
-        }
-        catch {
-            /* dir doesn't exist */
-        }
-    }
+    const sourceFiles = getProductionFiles(cwd);
+    const files = sourceFiles.map((sf) => ({ path: sf.path, base: sf.base, content: sf.content, exports: extractExports(sf.content) }));
     if (files.length === 0) {
         return {
             name: "confusion",
@@ -263,22 +254,3 @@ function extractExports(content) {
     }
     return exports;
 }
-function collectFiles(dir, cwd, out) {
-    for (const entry of readdirSync(dir)) {
-        if (entry === "node_modules" || entry === "dist" || entry === ".git")
-            continue;
-        const full = join(dir, entry);
-        if (statSync(full).isDirectory()) {
-            collectFiles(full, cwd, out);
-        }
-        else {
-            const ext = extname(entry);
-            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext) && !entry.includes(".test.") && !entry.includes(".spec.")) {
-                const content = readFileSync(full, "utf-8");
-                const relPath = full.replace(`${cwd}/`, "");
-                const base = basename(entry, ext);
-                out.push({ path: relPath, base, content, exports: extractExports(content) });
-            }
-        }
-    }
-}

package/dist/runners/context.js

@@ -11,8 +11,7 @@
  *   3. File self-containment — ratio of local symbols to imported symbols
  *   4. Circular dependencies — import cycles that confuse navigation
  */
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join } from "node:path";
+import { getProductionFiles } from "../fs-utils.js";
 import { gradeFromScore } from "../types.js";
 const MAX_FILE_TOKENS = 4000; // ~400 lines; beyond this LLMs lose mid-context info
 const MAX_IMPORTS = 15; // files importing >15 modules are hard to reason about
@@ -21,16 +20,13 @@ export function runContext(cwd) {
     const start = Date.now();
     const issues = [];
     // Collect source files with imports
-    const files = [];
-    const dirs = ["src", "web/src"];
-    for (const dir of dirs) {
-        try {
-            collectFiles(join(cwd, dir), cwd, files);
-        }
-        catch {
-            /* dir doesn't exist */
-        }
-    }
+    const sourceFiles = getProductionFiles(cwd);
+    const files = sourceFiles.map((sf) => ({
+        path: sf.path,
+        content: sf.content,
+        imports: parseImports(sf.content),
+        tokens: Math.round(sf.content.length / CHARS_PER_TOKEN),
+    }));
     if (files.length === 0) {
         return {
             name: "context",
@@ -157,14 +153,8 @@ function resolveImport(fromPath, importPath) {
         parts.pop();
         resolved = [...parts, importPath.slice(3)].join("/");
     }
-    // Strip extension and try common ones
+    // Strip known extension if present, then default to .ts
     resolved = resolved.replace(/\.(js|ts|tsx|jsx)$/, "");
-    const extensions = [".ts", ".tsx", ".js", ".jsx"];
-    for (const ext of extensions) {
-        if (resolved.endsWith(ext.replace(".", "")))
-            return resolved;
-    }
-    // Return with .ts as default assumption
     return `${resolved}.ts`;
 }
 // ── Cycle detection (DFS) ──
@@ -201,24 +191,3 @@ function findCycles(graph) {
     }
     return cycles;
 }
-// ── File collection ──
-function collectFiles(dir, cwd, out) {
-    for (const entry of readdirSync(dir)) {
-        if (entry === "node_modules" || entry === "dist" || entry === ".git")
-            continue;
-        const full = join(dir, entry);
-        if (statSync(full).isDirectory()) {
-            collectFiles(full, cwd, out);
-        }
-        else {
-            const ext = extname(entry);
-            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext) && !entry.includes(".test.") && !entry.includes(".spec.")) {
-                const content = readFileSync(full, "utf-8");
-                const relPath = full.replace(`${cwd}/`, "");
-                const imports = parseImports(content);
-                const tokens = Math.round(content.length / CHARS_PER_TOKEN);
-                out.push({ path: relPath, content, imports, tokens });
-            }
-        }
-    }
-}

package/dist/runners/dependencies.js

@@ -5,6 +5,34 @@ export function runDependencies(cwd, stack) {
     const start = Date.now();
     const issues = [];
     const pm = stack.packageManager;
+    // Dart/Flutter: skip npm audit, just check pubspec for outdated
+    if (pm === "pub") {
+        const outdatedResult = run("dart pub outdated --json 2>/dev/null || true", cwd);
+        let outdatedCount = 0;
+        let majorOutdated = 0;
+        try {
+            const data = JSON.parse(outdatedResult.stdout);
+            for (const pkg of data.packages || []) {
+                if (pkg.current?.version && pkg.latest?.version && pkg.current.version !== pkg.latest.version) {
+                    outdatedCount++;
+                    if (pkg.current.version.split(".")[0] !== pkg.latest.version.split(".")[0])
+                        majorOutdated++;
+                }
+            }
+        }
+        catch { /* parse failed */ }
+        if (majorOutdated > 0)
+            issues.push({ severity: "warning", message: `${majorOutdated} packages behind by a major version` });
+        const score = Math.max(0, Math.min(100, 100 - majorOutdated));
+        return {
+            name: "dependencies",
+            score,
+            grade: gradeFromScore(score),
+            details: { vulnerabilities: { critical: 0, high: 0, moderate: 0, low: 0 }, outdated: outdatedCount, majorOutdated },
+            issues,
+            duration: Date.now() - start,
+        };
+    }
     // Vulnerability audit
     const auditCmd = pm === "pnpm" ? "pnpm audit --json" : pm === "yarn" ? "yarn audit --json" : "npm audit --json";
     const auditResult = run(`${auditCmd} 2>/dev/null || true`, cwd);

package/dist/runners/doc-coherence.d.ts

@@ -0,0 +1,14 @@
+/** Doc Coherence — detects contradictions between documentation and code.
+ *
+ * Premium feature (powered by LLM). Scans README, CLAUDE.md, JSDoc, and inline
+ * comments for claims that contradict the actual code:
+ *   - README says "supports X" but feature X was removed
+ *   - JSDoc says "@param required" but param has a default
+ *   - Comment says "never throws" but function has throw statements
+ *   - CHANGELOG references files that no longer exist
+ *   - API docs describe endpoints/functions that were renamed or deleted
+ *
+ * Currently returns a "coming soon" placeholder.
+ */
+import type { CheckResult } from "../types.js";
+export declare function runDocCoherence(cwd: string): CheckResult;