roast-my-codebase 1.0.0

package/dist/index.js

@@ -0,0 +1,4480 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+import path15 from "path";
+import fs17 from "fs";
+import { fileURLToPath } from "url";
+import ora from "ora";
+import chalk8 from "chalk";
+
+// src/scanners/files.ts
+import fg from "fast-glob";
+import path2 from "path";
+
+// src/utils/constants.ts
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  // Python
+  ".go",
+  // Go
+  ".rs",
+  // Rust
+  ".java",
+  // Java
+  ".cs"
+  // C#
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.git/**",
+  "**/.turbo/**",
+  "**/.cache/**",
+  "**/out/**",
+  "**/.output/**"
+];
+var LARGE_FILE_THRESHOLDS = {
+  warning: 500,
+  large: 1e3,
+  extreme: 2e3
+};
+var HEALTH_DEDUCTIONS = {
+  unusedDependency: -2,
+  todo: -0.25,
+  largeFile: -3,
+  extremeFile: -5,
+  circularDependency: -5,
+  criticalIssue: -10,
+  excessiveDeps: -5,
+  deepNesting: -2,
+  utilExplosion: -1,
+  complexFunction: -2,
+  veryComplexFunction: -4,
+  duplicateCode: -3,
+  deadExport: -1,
+  typeSafetyIssue: -2,
+  criticalTypeSafety: -5,
+  gitChurn: -3,
+  largePRSize: -2,
+  secret: -10,
+  envInGit: -10,
+  evalUsage: -3,
+  missingTest: -0.5,
+  frameworkViolation: -2
+};
+
+// src/utils/files.ts
+import fs from "fs";
+import path from "path";
+function readFileLines(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8").split("\n");
+  } catch {
+    return [];
+  }
+}
+function countLines(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+function relativePath(rootDir, filePath) {
+  return path.relative(rootDir, filePath).replace(/\\/g, "/");
+}
+
+// src/scanners/files.ts
+var FileScanner = class {
+  constructor() {
+    this.name = "files";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const allFiles = await fg(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    const allProjectFiles = await fg("**/*", {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      onlyFiles: true
+    });
+    const fileSizes = [];
+    let totalLines = 0;
+    for (const file of allFiles) {
+      const lines = countLines(file);
+      totalLines += lines;
+      const rel = relativePath(rootDir, file);
+      fileSizes.push({ path: rel, lines });
+      if (lines >= LARGE_FILE_THRESHOLDS.extreme) {
+        findings.push({
+          id: `large-file-extreme-${rel}`,
+          severity: "critical",
+          category: "large-files",
+          message: `${rel} is ${lines.toLocaleString()} lines \u2014 this file has its own gravitational field`,
+          file: rel,
+          detail: `${lines} lines`
+        });
+      } else if (lines >= LARGE_FILE_THRESHOLDS.large) {
+        findings.push({
+          id: `large-file-${rel}`,
+          severity: "warning",
+          category: "large-files",
+          message: `${rel} is ${lines.toLocaleString()} lines`,
+          file: rel,
+          detail: `${lines} lines`
+        });
+      } else if (lines >= LARGE_FILE_THRESHOLDS.warning) {
+        findings.push({
+          id: `large-file-warn-${rel}`,
+          severity: "info",
+          category: "large-files",
+          message: `${rel} is ${lines.toLocaleString()} lines`,
+          file: rel,
+          detail: `${lines} lines`
+        });
+      }
+    }
+    fileSizes.sort((a, b) => b.lines - a.lines);
+    const pkgPath = path2.join(rootDir, "package.json");
+    let dependencies = 0;
+    let devDependencies = 0;
+    try {
+      const pkg = await import("fs").then(
+        (fs18) => JSON.parse(fs18.readFileSync(pkgPath, "utf-8"))
+      );
+      dependencies = Object.keys(pkg.dependencies || {}).length;
+      devDependencies = Object.keys(pkg.devDependencies || {}).length;
+    } catch {
+    }
+    const stats = {
+      totalFiles: allProjectFiles.length,
+      sourceFiles: allFiles.length,
+      totalLines,
+      largestFiles: fileSizes.slice(0, 5),
+      dependencies,
+      devDependencies
+    };
+    return { findings, stats };
+  }
+};
+
+// src/scanners/todos.ts
+import fg2 from "fast-glob";
+var TodoScanner = class {
+  constructor() {
+    this.name = "todos";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const files = await fg2(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    let totalTodos = 0;
+    let totalFixmes = 0;
+    let totalHacks = 0;
+    for (const file of files) {
+      const lines = readFileLines(file);
+      const rel = relativePath(rootDir, file);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/\bTODO\b/.test(line)) totalTodos++;
+        if (/\bFIXME\b/.test(line)) totalFixmes++;
+        if (/\bHACK\b/.test(line) || /\bXXX\b/.test(line)) totalHacks++;
+      }
+    }
+    const total = totalTodos + totalFixmes + totalHacks;
+    if (total > 0) {
+      findings.push({
+        id: "todo-count",
+        severity: total > 50 ? "warning" : "info",
+        category: "todos",
+        message: `Found ${total} comment markers (${totalTodos} TODO, ${totalFixmes} FIXME, ${totalHacks} HACK/XXX)`
+      });
+    }
+    if (totalHacks > 5) {
+      findings.push({
+        id: "hack-count",
+        severity: "warning",
+        category: "todos",
+        message: `${totalHacks} HACK/XXX comments \u2014 someone was in survival mode`
+      });
+    }
+    return {
+      findings,
+      stats: { totalTodos, totalFixmes, totalHacks, total }
+    };
+  }
+};
+
+// src/scanners/dependencies.ts
+import fg3 from "fast-glob";
+import path3 from "path";
+import fs2 from "fs";
+var DependencyScanner = class {
+  constructor() {
+    this.name = "dependencies";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const pkgPath = path3.join(rootDir, "package.json");
+    if (!fs2.existsSync(pkgPath)) {
+      return { findings };
+    }
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+    const deps = Object.keys(pkg.dependencies || {});
+    const devDeps = Object.keys(pkg.devDependencies || {});
+    const totalDeps = deps.length + devDeps.length;
+    if (totalDeps > 150) {
+      findings.push({
+        id: "excessive-deps",
+        severity: "critical",
+        category: "dependencies",
+        message: `${totalDeps} total dependencies \u2014 this package.json has commitment issues`
+      });
+    } else if (totalDeps > 80) {
+      findings.push({
+        id: "many-deps",
+        severity: "warning",
+        category: "dependencies",
+        message: `${totalDeps} total dependencies`
+      });
+    }
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const sourceFiles = await fg3(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    const allImports = /* @__PURE__ */ new Set();
+    for (const file of sourceFiles) {
+      try {
+        const content = fs2.readFileSync(file, "utf-8");
+        const patterns = [
+          /from\s+['"]([^./][^'"]*)['"]/g,
+          /import\s+['"]([^./][^'"]*)['"]/g,
+          /require\s*\(\s*['"]([^./][^'"]*)['"]\s*\)/g
+        ];
+        for (const regex of patterns) {
+          for (const match of content.matchAll(regex)) {
+            const pkg2 = match[1].startsWith("@") ? match[1].split("/").slice(0, 2).join("/") : match[1].split("/")[0];
+            allImports.add(pkg2);
+          }
+        }
+      } catch {
+      }
+    }
+    const configFiles = await fg3(
+      [
+        "*.config.*",
+        ".babelrc",
+        ".eslintrc*",
+        "tsconfig.json",
+        "jest.config.*",
+        "vite.config.*",
+        "next.config.*",
+        "tailwind.config.*",
+        "postcss.config.*"
+      ],
+      { cwd: rootDir, absolute: true }
+    );
+    for (const cf of configFiles) {
+      try {
+        const content = fs2.readFileSync(cf, "utf-8");
+        for (const dep of deps) {
+          if (content.includes(dep)) {
+            allImports.add(dep);
+          }
+        }
+      } catch {
+      }
+    }
+    const implicitDeps = /* @__PURE__ */ new Set([
+      "typescript",
+      "@types/node",
+      "@types/react",
+      "@types/react-dom",
+      "eslint",
+      "prettier",
+      "husky",
+      "lint-staged",
+      "nodemon",
+      "ts-node",
+      "tsx",
+      "concurrently",
+      "cross-env",
+      "dotenv",
+      "env-cmd"
+    ]);
+    const unusedDeps = [];
+    for (const dep of deps) {
+      if (implicitDeps.has(dep)) continue;
+      if (dep.startsWith("@types/")) continue;
+      if (!allImports.has(dep)) {
+        unusedDeps.push(dep);
+      }
+    }
+    if (unusedDeps.length > 0) {
+      for (const dep of unusedDeps.slice(0, 10)) {
+        findings.push({
+          id: `unused-dep-${dep}`,
+          severity: "warning",
+          category: "unused-deps",
+          message: `"${dep}" appears unused \u2014 paying rent for no reason`,
+          detail: dep
+        });
+      }
+      if (unusedDeps.length > 10) {
+        findings.push({
+          id: "unused-deps-overflow",
+          severity: "warning",
+          category: "unused-deps",
+          message: `...and ${unusedDeps.length - 10} more potentially unused dependencies`
+        });
+      }
+    }
+    return {
+      findings,
+      stats: {
+        deps: deps.length,
+        devDeps: devDeps.length,
+        total: totalDeps,
+        unusedCount: unusedDeps.length,
+        unused: unusedDeps
+      }
+    };
+  }
+};
+
+// src/scanners/circular.ts
+import fg4 from "fast-glob";
+import path4 from "path";
+import fs3 from "fs";
+var CircularDependencyScanner = class {
+  constructor() {
+    this.name = "circular";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const files = await fg4(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    const graph = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const rel = relativePath(rootDir, file);
+      const imports = this.extractImports(file, rootDir);
+      graph.set(rel, imports);
+    }
+    const cycles = this.findCycles(graph);
+    for (const cycle of cycles.slice(0, 5)) {
+      const chain = cycle.join(" \u2192 ");
+      findings.push({
+        id: `circular-${cycle[0]}`,
+        severity: "warning",
+        category: "circular-deps",
+        message: `Circular dependency: ${chain}`,
+        file: cycle[0],
+        detail: chain
+      });
+    }
+    if (cycles.length > 5) {
+      findings.push({
+        id: "circular-overflow",
+        severity: "warning",
+        category: "circular-deps",
+        message: `...and ${cycles.length - 5} more circular dependency chains`
+      });
+    }
+    return {
+      findings,
+      stats: { cycleCount: cycles.length }
+    };
+  }
+  extractImports(filePath, rootDir) {
+    const imports = /* @__PURE__ */ new Set();
+    try {
+      const content = fs3.readFileSync(filePath, "utf-8");
+      const dir = path4.dirname(filePath);
+      const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
+      const requireRegex = /require\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+      for (const regex of [importRegex, requireRegex]) {
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          const resolved = this.resolveImport(match[1], dir, rootDir);
+          if (resolved) {
+            imports.add(resolved);
+          }
+        }
+      }
+    } catch {
+    }
+    return imports;
+  }
+  resolveImport(importPath, fromDir, rootDir) {
+    const resolved = path4.resolve(fromDir, importPath);
+    const rel = relativePath(rootDir, resolved);
+    const stripped = rel.replace(/\.(js|mjs|cjs)$/, "");
+    const candidates = [rel, stripped];
+    for (const base of candidates) {
+      for (const ext of ["", ...SOURCE_EXTENSIONS]) {
+        const candidate = base + ext;
+        if (fs3.existsSync(path4.join(rootDir, candidate))) {
+          return candidate;
+        }
+      }
+      for (const ext of SOURCE_EXTENSIONS) {
+        const candidateIndex = base + "/index" + ext;
+        if (fs3.existsSync(path4.join(rootDir, candidateIndex))) {
+          return candidateIndex;
+        }
+      }
+    }
+    return null;
+  }
+  findCycles(graph) {
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    const dfs = (node) => {
+      if (cycles.length >= 10) return;
+      visited.add(node);
+      inStack.add(node);
+      stack.push(node);
+      const neighbors = graph.get(node) || /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        if (!graph.has(neighbor)) continue;
+        if (!visited.has(neighbor)) {
+          dfs(neighbor);
+        } else if (inStack.has(neighbor)) {
+          const cycleStart = stack.indexOf(neighbor);
+          const cycle = stack.slice(cycleStart);
+          cycle.push(neighbor);
+          cycles.push(cycle);
+        }
+      }
+      stack.pop();
+      inStack.delete(node);
+    };
+    for (const node of graph.keys()) {
+      if (!visited.has(node)) {
+        dfs(node);
+      }
+    }
+    return cycles;
+  }
+};
+
+// src/scanners/structure.ts
+import fg5 from "fast-glob";
+import path5 from "path";
+var UTIL_PATTERNS = [
+  "utils",
+  "helpers",
+  "common",
+  "shared",
+  "misc",
+  "lib",
+  "tools"
+];
+var StructureScanner = class {
+  constructor() {
+    this.name = "structure";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const allFiles = await fg5("**/*", {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      onlyFiles: true
+    });
+    let maxDepth = 0;
+    let deepestPath = "";
+    for (const file of allFiles) {
+      const depth = file.split("/").length;
+      if (depth > maxDepth) {
+        maxDepth = depth;
+        deepestPath = file;
+      }
+    }
+    if (maxDepth > 10) {
+      findings.push({
+        id: "deep-nesting",
+        severity: "warning",
+        category: "structure",
+        message: `Maximum nesting depth is ${maxDepth} levels \u2014 someone really loves subdirectories`,
+        file: deepestPath,
+        detail: `${maxDepth} levels deep`
+      });
+    } else if (maxDepth > 7) {
+      findings.push({
+        id: "moderate-nesting",
+        severity: "info",
+        category: "structure",
+        message: `Nesting depth reaches ${maxDepth} levels`,
+        file: deepestPath
+      });
+    }
+    const folderCounts = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const dir = path5.dirname(file);
+      folderCounts.set(dir, (folderCounts.get(dir) || 0) + 1);
+    }
+    for (const [dir, count] of folderCounts) {
+      if (count > 50) {
+        findings.push({
+          id: `large-folder-${dir}`,
+          severity: "warning",
+          category: "structure",
+          message: `${dir}/ contains ${count} files \u2014 this folder needs a filing cabinet`,
+          file: dir
+        });
+      }
+    }
+    const utilFiles = [];
+    for (const file of allFiles) {
+      const basename = path5.basename(file, path5.extname(file)).toLowerCase();
+      if (UTIL_PATTERNS.some((p) => basename.includes(p))) {
+        utilFiles.push(file);
+      }
+    }
+    if (utilFiles.length > 5) {
+      findings.push({
+        id: "util-explosion",
+        severity: "warning",
+        category: "structure",
+        message: `${utilFiles.length} utility/helper files detected \u2014 the junk drawer is overflowing`,
+        detail: utilFiles.slice(0, 5).join(", ")
+      });
+    } else if (utilFiles.length > 2) {
+      findings.push({
+        id: "util-files",
+        severity: "info",
+        category: "structure",
+        message: `${utilFiles.length} utility/helper files`
+      });
+    }
+    const componentFiles = await fg5(
+      ["**/*.tsx", "**/*.jsx"],
+      {
+        cwd: rootDir,
+        ignore: IGNORE_PATTERNS
+      }
+    );
+    return {
+      findings,
+      stats: {
+        maxDepth,
+        utilFiles: utilFiles.length,
+        componentFiles: componentFiles.length,
+        totalFolders: folderCounts.size
+      }
+    };
+  }
+};
+
+// src/scanners/complexity.ts
+import fs4 from "fs";
+import fg6 from "fast-glob";
+var WARNING_THRESHOLD = 15;
+var CRITICAL_THRESHOLD = 25;
+var ComplexityScanner = class {
+  constructor() {
+    this.name = "complexity";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const allFiles = await fg6(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    let totalComplexity = 0;
+    let totalFunctions = 0;
+    let maxComplexity = 0;
+    let complexFunctions = 0;
+    for (const file of allFiles) {
+      let content;
+      try {
+        content = fs4.readFileSync(file, "utf-8");
+      } catch {
+        continue;
+      }
+      const functions = extractFunctions(content);
+      const rel = relativePath(rootDir, file);
+      for (const fn of functions) {
+        const complexity = calculateComplexity(fn.body);
+        totalComplexity += complexity;
+        totalFunctions++;
+        if (complexity > maxComplexity) {
+          maxComplexity = complexity;
+        }
+        if (complexity >= CRITICAL_THRESHOLD) {
+          complexFunctions++;
+          findings.push({
+            id: `complexity-critical-${rel}-${fn.name}`,
+            severity: "critical",
+            category: "complexity",
+            message: `${fn.name} in ${rel} has cyclomatic complexity of ${complexity} \u2014 this function needs its own zip code`,
+            file: rel,
+            detail: `complexity: ${complexity}`
+          });
+        } else if (complexity >= WARNING_THRESHOLD) {
+          complexFunctions++;
+          findings.push({
+            id: `complexity-warning-${rel}-${fn.name}`,
+            severity: "warning",
+            category: "complexity",
+            message: `${fn.name} in ${rel} has cyclomatic complexity of ${complexity}`,
+            file: rel,
+            detail: `complexity: ${complexity}`
+          });
+        }
+      }
+    }
+    const stats = {
+      totalFunctions,
+      averageComplexity: totalFunctions > 0 ? Math.round(totalComplexity / totalFunctions * 100) / 100 : 0,
+      maxComplexity,
+      complexFunctions
+    };
+    return { findings, stats };
+  }
+};
+function extractFunctions(content) {
+  const functions = [];
+  const lines = content.split("\n");
+  const patterns = [
+    // function declarations: function name(, async function name(
+    // eslint-disable-next-line security/detect-unsafe-regex -- Bounded by file content, not user input
+    /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    // arrow functions assigned to variables: const name = (, let name = (, var name = (
+    // eslint-disable-next-line security/detect-unsafe-regex -- Bounded by file content, not user input
+    /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/,
+    // arrow functions assigned with arrow after params: const name = async (
+    // eslint-disable-next-line security/detect-unsafe-regex -- Bounded by file content, not user input
+    /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/,
+    // class methods: name(, async name(, public name(, private name(, protected name(
+    // eslint-disable-next-line security/detect-unsafe-regex -- Bounded by file content, not user input
+    /^\s+(?:public|private|protected|static|async|\s)*\s*(\w+)\s*\([^)]*\)\s*(?::\s*\w[^{]*)?\s*\{/
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let fnName = null;
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match && match[1]) {
+        if (["if", "else", "for", "while", "switch", "catch", "import", "from", "return", "class", "interface", "type", "constructor"].includes(match[1])) {
+          continue;
+        }
+        fnName = match[1];
+        break;
+      }
+    }
+    if (!fnName && /^\s+constructor\s*\(/.test(line)) {
+      fnName = "constructor";
+    }
+    if (fnName) {
+      const body = extractFunctionBody(lines, i);
+      if (body) {
+        functions.push({ name: fnName, startLine: i + 1, body });
+      }
+    }
+  }
+  return functions;
+}
+function extractFunctionBody(lines, startLine) {
+  let braceCount = 0;
+  let started = false;
+  const bodyLines = [];
+  for (let i = startLine; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        braceCount++;
+        started = true;
+      } else if (ch === "}") {
+        braceCount--;
+      }
+    }
+    bodyLines.push(line);
+    if (started && braceCount === 0) {
+      return bodyLines.join("\n");
+    }
+  }
+  if (!started && bodyLines.length > 0) {
+    return bodyLines.slice(0, 5).join("\n");
+  }
+  return null;
+}
+function calculateComplexity(body) {
+  let complexity = 1;
+  const cleaned = body.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/`(?:[^`\\]|\\.)*`/g, "``");
+  const decisionPatterns = [
+    [/\bif\s*\(/g, 1],
+    [/\belse\s+if\s*\(/g, 1],
+    [/\bcase\s+/g, 1],
+    [/\bwhile\s*\(/g, 1],
+    [/\bfor\s*\(/g, 1],
+    [/&&/g, 1],
+    [/\|\|/g, 1],
+    [/\?\./g, 1],
+    [/\?\?/g, 1],
+    [/\bcatch\s*\(/g, 1],
+    // Ternary: ? not followed by . or ? (to avoid ?. and ??)
+    [/\?(?![.?])/g, 1]
+  ];
+  for (const [pattern, weight] of decisionPatterns) {
+    const matches = cleaned.match(pattern);
+    if (matches) {
+      complexity += matches.length * weight;
+    }
+  }
+  const elseIfMatches = cleaned.match(/\belse\s+if\s*\(/g);
+  if (elseIfMatches) {
+    complexity -= elseIfMatches.length;
+  }
+  return complexity;
+}
+
+// src/scanners/duplicates.ts
+import fg7 from "fast-glob";
+import fs5 from "fs";
+var WINDOW_SIZE = 6;
+var DuplicateScanner = class {
+  constructor() {
+    this.name = "duplicates";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const files = await fg7(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    const hashMap = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const content = fs5.readFileSync(file, "utf-8");
+        const lines = content.split("\n");
+        const rel = relativePath(rootDir, file);
+        for (let i = 0; i <= lines.length - WINDOW_SIZE; i++) {
+          const window = lines.slice(i, i + WINDOW_SIZE);
+          const normalized = this.normalizeWindow(window);
+          if (this.shouldSkipWindow(normalized)) continue;
+          const hash = this.hashString(normalized.join("\n"));
+          if (!hashMap.has(hash)) {
+            hashMap.set(hash, []);
+          }
+          hashMap.get(hash).push({
+            file: rel,
+            startLine: i + 1,
+            endLine: i + WINDOW_SIZE
+          });
+        }
+      } catch {
+      }
+    }
+    const duplicates = [];
+    for (const [hash, locations] of hashMap) {
+      if (locations.length < 2) continue;
+      const uniqueLocations = this.filterUniqueLocations(locations);
+      if (uniqueLocations.length < 2) continue;
+      const blockSize = this.calculateBlockSize(
+        uniqueLocations,
+        files,
+        rootDir
+      );
+      duplicates.push({ locations: uniqueLocations, blockSize });
+    }
+    duplicates.sort((a, b) => b.blockSize - a.blockSize);
+    const topDuplicates = duplicates.slice(0, 10);
+    let totalDuplicateLines = 0;
+    for (const dup of topDuplicates) {
+      const severity = dup.blockSize >= 15 ? "warning" : dup.blockSize >= 6 ? "info" : "info";
+      const locs = dup.locations.slice(0, 2).map((l) => `${l.file}:${l.startLine}`).join(" and ");
+      findings.push({
+        id: `duplicate-${dup.locations[0].file}-${dup.locations[0].startLine}`,
+        severity,
+        category: "duplicates",
+        message: `${dup.blockSize}-line duplicate found in ${locs}${dup.locations.length > 2 ? ` (and ${dup.locations.length - 2} more)` : ""}`,
+        file: dup.locations[0].file,
+        detail: `${dup.blockSize} lines duplicated`
+      });
+      totalDuplicateLines += dup.blockSize * dup.locations.length;
+    }
+    return {
+      findings,
+      stats: {
+        totalBlocks: topDuplicates.length,
+        totalDuplicateLines,
+        filesAnalyzed: files.length
+      }
+    };
+  }
+  normalizeWindow(lines) {
+    return lines.map((line) => {
+      let normalized = line.replace(/\/\/.*$/, "");
+      normalized = normalized.replace(/\/\*.*?\*\//g, "");
+      normalized = normalized.trim().replace(/\s+/g, " ");
+      return normalized;
+    });
+  }
+  shouldSkipWindow(normalized) {
+    const nonBlank = normalized.filter((l) => l.length > 0);
+    if (nonBlank.length < 3) return true;
+    const imports = normalized.filter(
+      (l) => l.startsWith("import ") || l.startsWith("export ")
+    );
+    if (imports.length > normalized.length * 0.5) return true;
+    return false;
+  }
+  filterUniqueLocations(locations) {
+    const unique = [];
+    for (const loc of locations) {
+      const isDuplicate = unique.some(
+        (u) => u.file === loc.file && Math.abs(u.startLine - loc.startLine) < WINDOW_SIZE * 2
+      );
+      if (!isDuplicate) {
+        unique.push(loc);
+      }
+    }
+    return unique;
+  }
+  calculateBlockSize(locations, files, rootDir) {
+    return WINDOW_SIZE;
+  }
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
+};
+
+// src/scanners/dead-exports.ts
+import fg8 from "fast-glob";
+import path6 from "path";
+import fs6 from "fs";
+var DeadExportScanner = class {
+  constructor() {
+    this.name = "dead-exports";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const extGlob = SOURCE_EXTENSIONS.map((e) => `**/*${e}`);
+    const files = await fg8(extGlob, {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    if (files.length === 0) {
+      return {
+        findings,
+        stats: { totalExports: 0, deadExports: 0, percentDead: 0 }
+      };
+    }
+    const entryPoints = this.getEntryPoints(rootDir);
+    const allExports = [];
+    const fileContents = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const rel = relativePath(rootDir, file);
+      if (this.isBarrelFile(rel)) continue;
+      try {
+        const content = fs6.readFileSync(file, "utf-8");
+        fileContents.set(rel, content);
+        const exports = this.extractExports(content, rel);
+        allExports.push(...exports);
+      } catch {
+      }
+    }
+    if (allExports.length === 0) {
+      return {
+        findings,
+        stats: { totalExports: 0, deadExports: 0, percentDead: 0 }
+      };
+    }
+    const usedExports = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const rel = relativePath(rootDir, file);
+      let content = fileContents.get(rel);
+      if (!content) {
+        try {
+          content = fs6.readFileSync(file, "utf-8");
+        } catch {
+          continue;
+        }
+      }
+      this.trackImports(content, file, rootDir, allExports, usedExports);
+    }
+    const deadExports = [];
+    for (const exp of allExports) {
+      const key = `${exp.file}::${exp.name}`;
+      if (usedExports.has(key)) continue;
+      if (exp.name === "default" && entryPoints.has(exp.file)) continue;
+      deadExports.push(exp);
+    }
+    for (const dead of deadExports.slice(0, 15)) {
+      const severity = dead.kind === "type" || dead.kind === "interface" ? "info" : "warning";
+      const exportLabel = dead.name === "default" ? "default export" : `"${dead.name}"`;
+      findings.push({
+        id: `dead-export-${dead.file}-${dead.name}`,
+        severity,
+        category: "dead-exports",
+        message: `Exported ${dead.kind} ${exportLabel} in ${dead.file} is never imported`,
+        file: dead.file,
+        detail: `${dead.kind} ${dead.name}`
+      });
+    }
+    if (deadExports.length > 15) {
+      findings.push({
+        id: "dead-exports-overflow",
+        severity: "info",
+        category: "dead-exports",
+        message: `...and ${deadExports.length - 15} more dead exports`
+      });
+    }
+    const totalExports = allExports.length;
+    const totalDead = deadExports.length;
+    const percentDead = totalExports > 0 ? Math.round(totalDead / totalExports * 100) : 0;
+    return {
+      findings,
+      stats: { totalExports, deadExports: totalDead, percentDead }
+    };
+  }
+  getEntryPoints(rootDir) {
+    const entryPoints = /* @__PURE__ */ new Set();
+    try {
+      const pkgPath = path6.join(rootDir, "package.json");
+      const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      const candidates = [];
+      if (pkg.main) candidates.push(pkg.main);
+      if (pkg.module) candidates.push(pkg.module);
+      if (pkg.bin) {
+        if (typeof pkg.bin === "string") {
+          candidates.push(pkg.bin);
+        } else {
+          candidates.push(...Object.values(pkg.bin));
+        }
+      }
+      for (const entry of candidates) {
+        const normalized = entry.replace(/^\.\//, "").replace(/\\/g, "/");
+        entryPoints.add(normalized);
+        const stripped = normalized.replace(/\.(js|mjs|cjs|ts|tsx)$/, "");
+        for (const ext of SOURCE_EXTENSIONS) {
+          entryPoints.add(stripped + ext);
+        }
+      }
+    } catch {
+    }
+    return entryPoints;
+  }
+  isBarrelFile(rel) {
+    const basename = path6.basename(rel);
+    return /^index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(basename);
+  }
+  extractExports(content, file) {
+    const exports = [];
+    const funcRegex = /export\s+function\s+(\w+)/g;
+    let match;
+    while ((match = funcRegex.exec(content)) !== null) {
+      exports.push({ name: match[1], kind: "function", file });
+    }
+    const constRegex = /export\s+(?:const|let|var)\s+(\w+)/g;
+    while ((match = constRegex.exec(content)) !== null) {
+      exports.push({ name: match[1], kind: "const", file });
+    }
+    const classRegex = /export\s+class\s+(\w+)/g;
+    while ((match = classRegex.exec(content)) !== null) {
+      exports.push({ name: match[1], kind: "class", file });
+    }
+    const ifaceRegex = /export\s+interface\s+(\w+)/g;
+    while ((match = ifaceRegex.exec(content)) !== null) {
+      exports.push({ name: match[1], kind: "interface", file });
+    }
+    const typeRegex = /export\s+type\s+(\w+)/g;
+    while ((match = typeRegex.exec(content)) !== null) {
+      exports.push({ name: match[1], kind: "type", file });
+    }
+    const namedRegex = /export\s*\{([^}]+)\}/g;
+    while ((match = namedRegex.exec(content)) !== null) {
+      const names = match[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+      for (const name of names) {
+        if (name) {
+          exports.push({ name, kind: "const", file });
+        }
+      }
+    }
+    const defaultRegex = /export\s+default\s+/g;
+    while ((match = defaultRegex.exec(content)) !== null) {
+      exports.push({ name: "default", kind: "default", file });
+    }
+    return exports;
+  }
+  trackImports(content, filePath, rootDir, allExports, usedExports) {
+    const currentFile = relativePath(rootDir, filePath);
+    const namedImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"](\.[^'"]+)['"]/g;
+    let match;
+    while ((match = namedImportRegex.exec(content)) !== null) {
+      const names = match[1].split(",").map((n) => {
+        const parts = n.trim().split(/\s+as\s+/);
+        return parts[0].trim();
+      });
+      const resolved = this.resolveImport(match[2], filePath, rootDir);
+      if (resolved && resolved !== currentFile) {
+        for (const name of names) {
+          if (name) usedExports.add(`${resolved}::${name}`);
+        }
+      }
+    }
+    const defaultImportRegex = /import\s+(\w+)\s+from\s*['"](\.[^'"]+)['"]/g;
+    while ((match = defaultImportRegex.exec(content)) !== null) {
+      const resolved = this.resolveImport(match[2], filePath, rootDir);
+      if (resolved && resolved !== currentFile) {
+        usedExports.add(`${resolved}::default`);
+      }
+    }
+    const namespaceImportRegex = /import\s*\*\s*as\s+\w+\s+from\s*['"](\.[^'"]+)['"]/g;
+    while ((match = namespaceImportRegex.exec(content)) !== null) {
+      const resolved = this.resolveImport(match[1], filePath, rootDir);
+      if (resolved && resolved !== currentFile) {
+        for (const exp of allExports) {
+          if (exp.file === resolved) {
+            usedExports.add(`${resolved}::${exp.name}`);
+          }
+        }
+      }
+    }
+    const reExportRegex = /export\s*\*\s*from\s*['"](\.[^'"]+)['"]/g;
+    while ((match = reExportRegex.exec(content)) !== null) {
+      const resolved = this.resolveImport(match[1], filePath, rootDir);
+      if (resolved && resolved !== currentFile) {
+        for (const exp of allExports) {
+          if (exp.file === resolved) {
+            usedExports.add(`${resolved}::${exp.name}`);
+          }
+        }
+      }
+    }
+    const namedReExportRegex = /export\s*\{([^}]+)\}\s*from\s*['"](\.[^'"]+)['"]/g;
+    while ((match = namedReExportRegex.exec(content)) !== null) {
+      const names = match[1].split(",").map((n) => {
+        const parts = n.trim().split(/\s+as\s+/);
+        return parts[0].trim();
+      });
+      const resolved = this.resolveImport(match[2], filePath, rootDir);
+      if (resolved && resolved !== currentFile) {
+        for (const name of names) {
+          if (name) usedExports.add(`${resolved}::${name}`);
+        }
+      }
+    }
+  }
+  resolveImport(importPath, fromFile, rootDir) {
+    const fromDir = path6.dirname(fromFile);
+    const resolved = path6.resolve(fromDir, importPath);
+    const rel = relativePath(rootDir, resolved);
+    const stripped = rel.replace(/\.(js|mjs|cjs)$/, "");
+    const candidates = [rel, stripped];
+    for (const base of candidates) {
+      for (const ext of ["", ...SOURCE_EXTENSIONS]) {
+        const candidate = base + ext;
+        if (fs6.existsSync(path6.join(rootDir, candidate))) {
+          return candidate;
+        }
+      }
+      for (const ext of SOURCE_EXTENSIONS) {
+        const candidateIndex = base + "/index" + ext;
+        if (fs6.existsSync(path6.join(rootDir, candidateIndex))) {
+          return candidateIndex;
+        }
+      }
+    }
+    return null;
+  }
+};
+
+// src/scanners/type-safety.ts
+import fg9 from "fast-glob";
+import fs7 from "fs";
+var TypeSafetyScanner = class {
+  constructor() {
+    this.name = "type-safety";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const allFiles = await fg9(["**/*.ts", "**/*.tsx"], {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    let totalAny = 0;
+    let totalTsIgnore = 0;
+    let totalTsNocheck = 0;
+    let totalTsExpectError = 0;
+    const fileViolations = [];
+    for (const file of allFiles) {
+      const rel = relativePath(rootDir, file);
+      let content;
+      try {
+        content = fs7.readFileSync(file, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = content.split("\n");
+      let inBlockComment = false;
+      let fileAnyCount = 0;
+      let fileTsIgnore = 0;
+      let fileTsNocheck = 0;
+      let fileTsExpectError = 0;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (inBlockComment) {
+          if (trimmed.includes("*/")) {
+            inBlockComment = false;
+          }
+          continue;
+        }
+        if (trimmed.startsWith("/*")) {
+          if (!trimmed.includes("*/")) {
+            inBlockComment = true;
+          }
+          continue;
+        }
+        const isComment = trimmed.startsWith("//");
+        if (/@ts-ignore/.test(line)) {
+          fileTsIgnore++;
+        }
+        if (/@ts-nocheck/.test(line)) {
+          fileTsNocheck++;
+        }
+        if (/@ts-expect-error/.test(line)) {
+          fileTsExpectError++;
+        }
+        if (isComment) {
+          continue;
+        }
+        const colonAny = line.match(/:\s*any\b/g);
+        const asAny = line.match(/\bas\s+any\b/g);
+        if (colonAny) {
+          fileAnyCount += colonAny.length;
+        }
+        if (asAny) {
+          fileAnyCount += asAny.length;
+        }
+      }
+      totalAny += fileAnyCount;
+      totalTsIgnore += fileTsIgnore;
+      totalTsNocheck += fileTsNocheck;
+      totalTsExpectError += fileTsExpectError;
+      const totalFileViolations = fileAnyCount + fileTsIgnore + fileTsNocheck + fileTsExpectError;
+      if (totalFileViolations > 0) {
+        fileViolations.push({ path: rel, violations: totalFileViolations });
+      }
+      if (fileTsNocheck > 0) {
+        findings.push({
+          id: `ts-nocheck-${rel}`,
+          severity: "warning",
+          category: "type-safety",
+          message: `${rel} uses @ts-nocheck \u2014 entire file skips type checking`,
+          file: rel,
+          detail: `${fileTsNocheck} @ts-nocheck directive(s)`
+        });
+      }
+    }
+    if (totalAny > 20) {
+      findings.push({
+        id: "type-safety-any-critical",
+        severity: "critical",
+        category: "type-safety",
+        message: `${totalAny} uses of \`any\` \u2014 the type system is being bypassed wholesale`,
+        detail: `${totalAny} total any usages across the codebase`
+      });
+    } else if (totalAny >= 6) {
+      findings.push({
+        id: "type-safety-any-warning",
+        severity: "warning",
+        category: "type-safety",
+        message: `${totalAny} uses of \`any\` \u2014 significant type safety gaps`,
+        detail: `${totalAny} total any usages across the codebase`
+      });
+    } else if (totalAny >= 1) {
+      findings.push({
+        id: "type-safety-any-info",
+        severity: "info",
+        category: "type-safety",
+        message: `${totalAny} uses of \`any\` \u2014 minor type safety gaps`,
+        detail: `${totalAny} total any usages across the codebase`
+      });
+    }
+    if (totalTsIgnore > 5) {
+      findings.push({
+        id: "type-safety-ts-ignore",
+        severity: "warning",
+        category: "type-safety",
+        message: `${totalTsIgnore} @ts-ignore comments \u2014 errors are being silenced`,
+        detail: `${totalTsIgnore} total @ts-ignore directives`
+      });
+    }
+    fileViolations.sort((a, b) => b.violations - a.violations);
+    const worstOffenders = fileViolations.slice(0, 5);
+    const stats = {
+      totalAny,
+      totalTsIgnore,
+      totalTsNocheck,
+      totalTsExpectError,
+      worstOffenders
+    };
+    return { findings, stats };
+  }
+};
+
+// src/scanners/test-coverage.ts
+import fg10 from "fast-glob";
+import path7 from "path";
+var TestCoverageScanner = class {
+  constructor() {
+    this.name = "test-coverage";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const sourceFiles = await fg10(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], {
+      cwd: rootDir,
+      ignore: [
+        ...IGNORE_PATTERNS,
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/__tests__/**",
+        "**/*.d.ts",
+        "**/index.ts",
+        "**/index.js",
+        "**/*.config.*"
+      ],
+      absolute: false
+    });
+    const testFiles = await fg10(
+      [
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "**/*.test.js",
+        "**/*.test.jsx",
+        "**/*.spec.ts",
+        "**/*.spec.tsx",
+        "**/*.spec.js",
+        "**/*.spec.jsx"
+      ],
+      {
+        cwd: rootDir,
+        ignore: IGNORE_PATTERNS,
+        absolute: false
+      }
+    );
+    const testFileSet = new Set(testFiles.map(normalizeTestPath));
+    let missingTestCount = 0;
+    for (const sourceFile of sourceFiles) {
+      const hasTest = hasCorrespondingTest(sourceFile, testFileSet);
+      if (!hasTest) {
+        missingTestCount++;
+        if (missingTestCount <= 10) {
+          findings.push({
+            id: `missing-test-${sourceFile}`,
+            severity: "info",
+            category: "test-coverage",
+            message: `${sourceFile} has no corresponding test file`,
+            file: sourceFile
+          });
+        }
+      }
+    }
+    if (missingTestCount > 10) {
+      findings.push({
+        id: "many-missing-tests",
+        severity: "info",
+        category: "test-coverage",
+        message: `...and ${missingTestCount - 10} more files without tests`
+      });
+    }
+    const coveragePercent = sourceFiles.length > 0 ? ((sourceFiles.length - missingTestCount) / sourceFiles.length * 100).toFixed(1) : "100.0";
+    return {
+      findings,
+      stats: {
+        sourceFiles: sourceFiles.length,
+        missingTests: missingTestCount,
+        coveragePercent
+      }
+    };
+  }
+};
+function hasCorrespondingTest(sourceFile, testFileSet) {
+  const dir = path7.dirname(sourceFile);
+  const base = path7.basename(sourceFile, path7.extname(sourceFile));
+  const ext = path7.extname(sourceFile);
+  const possibleTests = [
+    path7.join(dir, `${base}.test${ext}`),
+    path7.join(dir, `${base}.spec${ext}`),
+    path7.join(dir, "__tests__", `${base}.test${ext}`),
+    path7.join(dir, "__tests__", `${base}.spec${ext}`)
+  ];
+  return possibleTests.some((test) => testFileSet.has(normalizeTestPath(test)));
+}
+function normalizeTestPath(testPath) {
+  return testPath.replace(/\\/g, "/");
+}
+
+// src/scanners/git-insights.ts
+import { spawnSync } from "child_process";
+var GitInsightsScanner = class {
+  constructor() {
+    this.name = "git-insights";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const gitCheck = spawnSync("git", ["rev-parse", "--git-dir"], {
+      cwd: rootDir,
+      stdio: "pipe"
+    });
+    if (gitCheck.status !== 0) {
+      return { findings: [], stats: { isGitRepo: false } };
+    }
+    const churnResult = spawnSync(
+      "git",
+      ["log", "--name-only", "--format=", "--since=6 months ago"],
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    if (churnResult.status === 0 && churnResult.stdout) {
+      const churnMap = this.analyzeChurn(churnResult.stdout);
+      for (const [file, count] of churnMap.entries()) {
+        if (count >= 100) {
+          findings.push({
+            id: `high-churn-${file}`,
+            severity: "critical",
+            category: "git-churn",
+            message: `${file} changed ${count} times in 6 months \u2014 high instability`,
+            file,
+            detail: `${count} changes`
+          });
+        } else if (count >= 50) {
+          findings.push({
+            id: `moderate-churn-${file}`,
+            severity: "warning",
+            category: "git-churn",
+            message: `${file} changed ${count} times in 6 months`,
+            file,
+            detail: `${count} changes`
+          });
+        }
+      }
+    }
+    const prSizeStats = this.analyzePRSize(rootDir);
+    if (prSizeStats.avgFilesPerPR > 0) {
+      if (prSizeStats.avgFilesPerPR > 40) {
+        findings.push({
+          id: "large-pr-size",
+          severity: "critical",
+          category: "pr-size",
+          message: `Average PR changes ${Math.round(prSizeStats.avgFilesPerPR)} files \u2014 PRs are too large`,
+          detail: `${Math.round(prSizeStats.avgFilesPerPR)} files per PR`
+        });
+      } else if (prSizeStats.avgFilesPerPR > 20) {
+        findings.push({
+          id: "moderate-pr-size",
+          severity: "warning",
+          category: "pr-size",
+          message: `Average PR changes ${Math.round(prSizeStats.avgFilesPerPR)} files`,
+          detail: `${Math.round(prSizeStats.avgFilesPerPR)} files per PR`
+        });
+      }
+    }
+    const staleBranches = this.findStaleBranches(rootDir);
+    if (staleBranches.length > 0) {
+      findings.push({
+        id: "stale-branches",
+        severity: "info",
+        category: "stale-branches",
+        message: `${staleBranches.length} branches haven't been updated in 90+ days`,
+        detail: staleBranches.slice(0, 5).join(", ")
+      });
+    }
+    return {
+      findings,
+      stats: {
+        isGitRepo: true,
+        avgPRSize: prSizeStats.avgFilesPerPR,
+        staleBranchCount: staleBranches.length,
+        highChurnFiles: findings.filter((f) => f.category === "git-churn").length
+      }
+    };
+  }
+  analyzeChurn(gitOutput) {
+    const churnMap = /* @__PURE__ */ new Map();
+    const lines = gitOutput.split("\n").filter((line) => line.trim() !== "");
+    for (const file of lines) {
+      const normalized = file.trim();
+      if (normalized) {
+        churnMap.set(normalized, (churnMap.get(normalized) || 0) + 1);
+      }
+    }
+    return churnMap;
+  }
+  analyzePRSize(rootDir) {
+    const mergeResult = spawnSync(
+      "git",
+      ["log", "--format=%H", "--merges", "--since=6 months ago"],
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    if (mergeResult.status !== 0 || !mergeResult.stdout) {
+      return { avgFilesPerPR: 0 };
+    }
+    const mergeCommits = mergeResult.stdout.split("\n").filter((line) => line.trim() !== "");
+    if (mergeCommits.length === 0) {
+      return { avgFilesPerPR: 0 };
+    }
+    let totalFiles = 0;
+    let validMerges = 0;
+    for (const commit of mergeCommits) {
+      const diffResult = spawnSync(
+        "git",
+        ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
+        { cwd: rootDir, encoding: "utf-8" }
+      );
+      if (diffResult.status === 0 && diffResult.stdout) {
+        const files = diffResult.stdout.split("\n").filter((line) => line.trim() !== "");
+        totalFiles += files.length;
+        validMerges++;
+      }
+    }
+    return {
+      avgFilesPerPR: validMerges > 0 ? totalFiles / validMerges : 0
+    };
+  }
+  findStaleBranches(rootDir) {
+    const branchResult = spawnSync(
+      "git",
+      ["branch", "-a", "--format=%(refname:short) %(committerdate:unix)"],
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    if (branchResult.status !== 0 || !branchResult.stdout) {
+      return [];
+    }
+    const staleBranches = [];
+    const now = Math.floor(Date.now() / 1e3);
+    const ninetyDaysAgo = now - 90 * 24 * 60 * 60;
+    const lines = branchResult.stdout.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^(.+?)\s+(\d+)$/);
+      if (match) {
+        const [, branchName, timestamp] = match;
+        const ts = parseInt(timestamp, 10);
+        if (ts < ninetyDaysAgo) {
+          if (!branchName.includes("HEAD") && !branchName.includes("origin/main") && !branchName.includes("origin/master")) {
+            staleBranches.push(branchName);
+          }
+        }
+      }
+    }
+    return staleBranches;
+  }
+};
+
+// src/scanners/security.ts
+import fg11 from "fast-glob";
+import fs8 from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+var SECRET_PATTERNS = [
+  {
+    name: "AWS Access Key",
+    pattern: /AKIA[0-9A-Z]{16}/g,
+    severity: "critical"
+  },
+  {
+    name: "Private Key",
+    pattern: /-----BEGIN (RSA|DSA|EC|OPENSSH) PRIVATE KEY-----/g,
+    severity: "critical"
+  },
+  {
+    name: "Generic API Key",
+    pattern: /(api[_-]?key|apikey|secret[_-]?key)\s*[=:]\s*['"][A-Za-z0-9_-]{20,1000}['"]/gi,
+    severity: "warning"
+  },
+  {
+    name: "JWT Token",
+    pattern: /eyJ[A-Za-z0-9_-]{1,500}\.eyJ[A-Za-z0-9_-]{1,500}\.[A-Za-z0-9_-]{1,500}/g,
+    severity: "warning"
+  }
+];
+var SecurityScanner = class {
+  constructor() {
+    this.name = "security";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const secretFindings = await this.detectSecrets(rootDir);
+    findings.push(...secretFindings);
+    const envFindings = await this.detectEnvInGit(rootDir);
+    findings.push(...envFindings);
+    const evalFindings = await this.detectEvalUsage(rootDir);
+    findings.push(...evalFindings);
+    return {
+      findings,
+      stats: {
+        secretsFound: secretFindings.length,
+        envFilesInGit: envFindings.length,
+        evalUsage: evalFindings.length
+      }
+    };
+  }
+  async detectSecrets(rootDir) {
+    const findings = [];
+    const files = await fg11(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], {
+      cwd: rootDir,
+      ignore: [
+        ...IGNORE_PATTERNS,
+        "**/test/**",
+        "**/tests/**",
+        "**/__tests__/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/examples/**",
+        "**/demo/**"
+      ],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs8.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        for (const { name, pattern, severity } of SECRET_PATTERNS) {
+          pattern.lastIndex = 0;
+          const matches = content.match(pattern);
+          if (matches) {
+            findings.push({
+              id: `secret-${rel}-${name.replace(/\s+/g, "-")}`,
+              severity,
+              category: "secrets",
+              message: `Potential ${name} found in ${rel}`,
+              file: rel,
+              detail: `${matches.length} match(es)`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return findings;
+  }
+  async detectEnvInGit(rootDir) {
+    const findings = [];
+    const gitCheck = spawnSync2("git", ["rev-parse", "--git-dir"], {
+      cwd: rootDir,
+      stdio: "pipe"
+    });
+    if (gitCheck.status !== 0) {
+      return findings;
+    }
+    const envFiles = spawnSync2("git", ["ls-files"], {
+      cwd: rootDir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    if (envFiles.status === 0 && envFiles.stdout) {
+      const trackedFiles = envFiles.stdout.split("\n").filter(Boolean);
+      const envInGit = trackedFiles.filter((f) => /\.env(\.|$)/.test(f));
+      for (const envFile of envInGit) {
+        findings.push({
+          id: `env-in-git-${envFile}`,
+          severity: "critical",
+          category: "env-in-git",
+          message: `${envFile} is tracked in git \u2014 secrets may be exposed`,
+          file: envFile
+        });
+      }
+    }
+    return findings;
+  }
+  async detectEvalUsage(rootDir) {
+    const findings = [];
+    const files = await fg11(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs8.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        if (/\beval\s*\(/.test(content)) {
+          findings.push({
+            id: `eval-${rel}`,
+            severity: "warning",
+            category: "eval-usage",
+            message: `${rel} uses eval() \u2014 potential code injection risk`,
+            file: rel
+          });
+        }
+      } catch {
+      }
+    }
+    return findings;
+  }
+};
+
+// src/scanners/framework.ts
+import fg12 from "fast-glob";
+import fs9 from "fs";
+import path8 from "path";
+var FrameworkScanner = class {
+  constructor() {
+    this.name = "framework";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const pkgPath = path8.join(rootDir, "package.json");
+    let isNextJS = false;
+    let isReact = false;
+    if (fs9.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+        isNextJS = !!(pkg.dependencies?.next || pkg.devDependencies?.next);
+        isReact = !!(pkg.dependencies?.react || pkg.devDependencies?.react);
+      } catch (error) {
+        return { findings: [], stats: { isNextJS: false, isReact: false } };
+      }
+    }
+    if (!isNextJS && !isReact) {
+      return { findings: [], stats: { isNextJS: false, isReact: false } };
+    }
+    if (isNextJS) {
+      const appPages = await fg12(["app/**/page.{ts,tsx,js,jsx}"], {
+        cwd: rootDir,
+        ignore: IGNORE_PATTERNS,
+        absolute: true
+      });
+      for (const pagePath of appPages) {
+        try {
+          const content = fs9.readFileSync(pagePath, "utf-8");
+          const hasMetadata = /export\s+(const|function)\s+metadata/.test(content) || // eslint-disable-next-line security/detect-unsafe-regex -- Bounded by file content
+          /export\s+(async\s+)?function\s+generateMetadata/.test(content);
+          if (!hasMetadata) {
+            const rel = path8.relative(rootDir, pagePath).replace(/\\/g, "/");
+            findings.push({
+              id: `no-metadata-${rel}`,
+              severity: "warning",
+              category: "nextjs-metadata",
+              message: `${rel} missing metadata export \u2014 SEO impact`,
+              file: rel
+            });
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+      const serverComponents = await fg12(["app/**/*.{ts,tsx}"], {
+        cwd: rootDir,
+        ignore: IGNORE_PATTERNS,
+        absolute: true
+      });
+      for (const compPath of serverComponents) {
+        try {
+          const content = fs9.readFileSync(compPath, "utf-8");
+          const isClientComponent = /['"]use client['"]/.test(content);
+          if (!isClientComponent) {
+            const hasClientHooks = /\b(useState|useEffect|useLayoutEffect|useReducer)\s*\(/.test(
+              content
+            );
+            if (hasClientHooks) {
+              const rel = path8.relative(rootDir, compPath).replace(/\\/g, "/");
+              findings.push({
+                id: `server-client-mismatch-${rel}`,
+                severity: "warning",
+                category: "nextjs-client-server",
+                message: `${rel} uses client hooks without 'use client' directive`,
+                file: rel
+              });
+            }
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    if (isReact) {
+      const rootComponents = await fg12(
+        [
+          "app/layout.{ts,tsx}",
+          "app/error.{ts,tsx}",
+          "pages/_app.{ts,tsx,js,jsx}",
+          "src/App.{ts,tsx,js,jsx}"
+        ],
+        {
+          cwd: rootDir,
+          ignore: IGNORE_PATTERNS,
+          absolute: true
+        }
+      );
+      if (rootComponents.length > 0) {
+        for (const compPath of rootComponents) {
+          try {
+            const content = fs9.readFileSync(compPath, "utf-8");
+            const hasErrorBoundary = /ErrorBoundary|componentDidCatch|static getDerivedStateFromError/.test(
+              content
+            );
+            if (!hasErrorBoundary) {
+              const rel = path8.relative(rootDir, compPath).replace(/\\/g, "/");
+              findings.push({
+                id: `no-error-boundary-${rel}`,
+                severity: "info",
+                category: "react-error-boundary",
+                message: `${rel} could benefit from an error boundary`,
+                file: rel
+              });
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+      }
+    }
+    return {
+      findings,
+      stats: { isNextJS, isReact }
+    };
+  }
+};
+
+// src/scanners/python.ts
+import fg13 from "fast-glob";
+import fs10 from "fs";
+var PythonComplexityScanner = class {
+  constructor() {
+    this.name = "python-complexity";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const functions = this.extractFunctions(content);
+        for (const func of functions) {
+          const complexity = this.calculateComplexity(func.body);
+          if (complexity >= 20) {
+            findings.push({
+              id: `py-complexity-${rel}-${func.name}`,
+              severity: "critical",
+              category: "complexity",
+              message: `Function ${func.name} has cyclomatic complexity of ${complexity}`,
+              file: rel,
+              detail: `${complexity} decision points`
+            });
+          } else if (complexity >= 10) {
+            findings.push({
+              id: `py-complexity-${rel}-${func.name}`,
+              severity: "warning",
+              category: "complexity",
+              message: `Function ${func.name} has cyclomatic complexity of ${complexity}`,
+              file: rel,
+              detail: `${complexity} decision points`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+  extractFunctions(content) {
+    const functions = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const funcMatch = line.match(/^\s*def\s+(\w+)\s*\(/);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        const indent = line.match(/^\s*/)?.[0].length || 0;
+        let body = line + "\n";
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j];
+          const nextIndent = nextLine.match(/^\s*/)?.[0].length || 0;
+          if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
+            body += nextLine + "\n";
+            continue;
+          }
+          if (nextIndent <= indent) {
+            break;
+          }
+          body += nextLine + "\n";
+        }
+        functions.push({ name, body });
+      }
+    }
+    return functions;
+  }
+  calculateComplexity(code) {
+    let complexity = 1;
+    const patterns = [
+      /\bif\b/g,
+      /\belif\b/g,
+      /\bfor\b/g,
+      /\bwhile\b/g,
+      /\band\b/g,
+      /\bor\b/g,
+      /\bexcept\b/g,
+      /\bwith\b/g,
+      /\?/g
+      // Ternary
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) {
+        complexity += matches.length;
+      }
+    }
+    return complexity;
+  }
+};
+var PythonTypeHintsScanner = class {
+  constructor() {
+    this.name = "python-type-hints";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    let totalFunctions = 0;
+    let untypedFunctions = 0;
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const funcPattern = /def\s+(\w+)\s*\([^)]*\)(?:\s*->\s*\w+)?:/g;
+        const functions = Array.from(content.matchAll(funcPattern));
+        for (const match of functions) {
+          totalFunctions++;
+          const fullDef = match[0];
+          const hasParamTypes = /:\s*\w+/.test(fullDef);
+          const hasReturnType = /->/.test(fullDef);
+          if (!hasParamTypes && !hasReturnType) {
+            untypedFunctions++;
+          }
+        }
+      } catch {
+      }
+    }
+    if (totalFunctions > 0) {
+      const untypedPercent = Math.round(
+        untypedFunctions / totalFunctions * 100
+      );
+      if (untypedPercent > 70) {
+        findings.push({
+          id: "py-type-hints-low",
+          severity: "warning",
+          category: "type-safety",
+          message: `${untypedPercent}% of Python functions lack type hints`,
+          detail: `${untypedFunctions} of ${totalFunctions} functions`
+        });
+      }
+    }
+    return {
+      findings,
+      stats: {
+        totalFunctions,
+        untypedFunctions,
+        untypedPercent: totalFunctions > 0 ? Math.round(untypedFunctions / totalFunctions * 100) : 0
+      }
+    };
+  }
+};
+var PythonImportsScanner = class {
+  constructor() {
+    this.name = "python-imports";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: IGNORE_PATTERNS,
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const wildcardImports = content.match(/from\s+[\w.]+\s+import\s+\*/g);
+        if (wildcardImports && wildcardImports.length > 0) {
+          findings.push({
+            id: `py-wildcard-import-${rel}`,
+            severity: "warning",
+            category: "python-imports",
+            message: `${rel} uses wildcard imports (${wildcardImports.length} found)`,
+            file: rel,
+            detail: "Wildcard imports pollute namespace"
+          });
+        }
+        const deepRelative = content.match(/from\s+\.{3,}/g);
+        if (deepRelative && deepRelative.length > 0) {
+          findings.push({
+            id: `py-deep-relative-${rel}`,
+            severity: "info",
+            category: "python-imports",
+            message: `${rel} uses deep relative imports`,
+            file: rel,
+            detail: "Consider absolute imports"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+
+// src/languages/index.ts
+var LANGUAGE_CONFIGS = {
+  javascript: {
+    name: "JavaScript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//],
+    packageFiles: ["package.json"],
+    sourcePatterns: ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs"]
+  },
+  typescript: {
+    name: "TypeScript",
+    extensions: [".ts", ".tsx"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//],
+    packageFiles: ["package.json", "tsconfig.json"],
+    sourcePatterns: ["**/*.ts", "**/*.tsx"]
+  },
+  python: {
+    name: "Python",
+    extensions: [".py"],
+    commentPatterns: [/#.*/, /"""[\s\S]*?"""/, /'''[\s\S]*?'''/],
+    packageFiles: [
+      "requirements.txt",
+      "setup.py",
+      "pyproject.toml",
+      "Pipfile",
+      "poetry.lock"
+    ],
+    sourcePatterns: ["**/*.py"]
+  },
+  go: {
+    name: "Go",
+    extensions: [".go"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//],
+    packageFiles: ["go.mod", "go.sum"],
+    sourcePatterns: ["**/*.go"]
+  },
+  rust: {
+    name: "Rust",
+    extensions: [".rs"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//, /\/\/\/.*/, /\/\*\*[\s\S]*?\*\//],
+    packageFiles: ["Cargo.toml", "Cargo.lock"],
+    sourcePatterns: ["**/*.rs"]
+  },
+  java: {
+    name: "Java",
+    extensions: [".java"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//, /\/\*\*[\s\S]*?\*\//],
+    packageFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    sourcePatterns: ["**/*.java"]
+  },
+  csharp: {
+    name: "C#",
+    extensions: [".cs"],
+    commentPatterns: [/\/\/.*/, /\/\*[\s\S]*?\*\//, /\/\/\/.*/, /\/\*\*[\s\S]*?\*\//],
+    packageFiles: [".csproj", ".sln"],
+    sourcePatterns: ["**/*.cs"]
+  }
+};
+function detectProjectLanguage(rootDir, fs18) {
+  const detectedLanguages = [];
+  for (const [lang, config] of Object.entries(LANGUAGE_CONFIGS)) {
+    for (const packageFile of config.packageFiles) {
+      const fullPath = __require("path").join(rootDir, packageFile);
+      if (fs18.existsSync(fullPath)) {
+        detectedLanguages.push(lang);
+        break;
+      }
+    }
+  }
+  if (detectedLanguages.length === 0) {
+    detectedLanguages.push("javascript", "typescript");
+  }
+  return [...new Set(detectedLanguages)];
+}
+
+// src/scoring/index.ts
+function calculateHealth(findings) {
+  let score = 100;
+  for (const finding of findings) {
+    switch (finding.category) {
+      case "large-files":
+        if (finding.severity === "critical") {
+          score += HEALTH_DEDUCTIONS.extremeFile;
+        } else {
+          score += HEALTH_DEDUCTIONS.largeFile;
+        }
+        break;
+      case "todos":
+        score += HEALTH_DEDUCTIONS.todo * getTodoCount(finding);
+        break;
+      case "circular-deps":
+        score += HEALTH_DEDUCTIONS.circularDependency;
+        break;
+      case "unused-deps":
+        score += HEALTH_DEDUCTIONS.unusedDependency;
+        break;
+      case "dependencies":
+        if (finding.severity === "critical") {
+          score += HEALTH_DEDUCTIONS.excessiveDeps;
+        }
+        break;
+      case "structure":
+        if (finding.id === "deep-nesting") {
+          score += HEALTH_DEDUCTIONS.deepNesting;
+        }
+        if (finding.id === "util-explosion") {
+          score += HEALTH_DEDUCTIONS.utilExplosion;
+        }
+        break;
+      case "complexity":
+        if (finding.severity === "critical") {
+          score += HEALTH_DEDUCTIONS.veryComplexFunction;
+        } else if (finding.severity === "warning") {
+          score += HEALTH_DEDUCTIONS.complexFunction;
+        }
+        break;
+      case "duplicates":
+        score += HEALTH_DEDUCTIONS.duplicateCode;
+        break;
+      case "dead-exports":
+        score += HEALTH_DEDUCTIONS.deadExport;
+        break;
+      case "type-safety":
+        if (finding.severity === "critical") {
+          score += HEALTH_DEDUCTIONS.criticalTypeSafety;
+        } else if (finding.severity === "warning") {
+          score += HEALTH_DEDUCTIONS.typeSafetyIssue;
+        }
+        break;
+      case "git-churn":
+        score += HEALTH_DEDUCTIONS.gitChurn;
+        break;
+      case "pr-size":
+        score += HEALTH_DEDUCTIONS.largePRSize;
+        break;
+      case "secrets":
+      case "env-in-git":
+        score += HEALTH_DEDUCTIONS.secret;
+        break;
+      case "eval-usage":
+        score += HEALTH_DEDUCTIONS.evalUsage;
+        break;
+      case "test-coverage":
+        score += HEALTH_DEDUCTIONS.missingTest;
+        break;
+      case "nextjs-metadata":
+      case "nextjs-client-server":
+      case "react-error-boundary":
+        score += HEALTH_DEDUCTIONS.frameworkViolation;
+        break;
+    }
+  }
+  score = Math.max(0, Math.min(100, Math.round(score)));
+  return {
+    score,
+    grade: getGrade(score),
+    label: getLabel(score)
+  };
+}
+function getTodoCount(finding) {
+  const match = finding.message.match(/Found (\d+)/);
+  return match ? parseInt(match[1], 10) : 1;
+}
+function getGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function getLabel(score) {
+  if (score >= 90) return "Excellent";
+  if (score >= 80) return "Good";
+  if (score >= 70) return "Fair";
+  if (score >= 60) return "Risky";
+  return "Chaotic";
+}
+
+// src/ai/index.ts
+import Anthropic from "@anthropic-ai/sdk";
+import fs11 from "fs";
+import path9 from "path";
+import crypto from "crypto";
+var DEFAULT_MODEL = "claude-3-5-sonnet-20241022";
+var DEFAULT_MAX_TOKENS = 150;
+var DEFAULT_TEMPERATURE = 1;
+var CACHE_FILE = ".roast-ai-cache.json";
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+async function generateAIRoast(finding, config, rootDir) {
+  if (!config.enabled) {
+    return null;
+  }
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.warn(
+      "Warning: AI roasts enabled but ANTHROPIC_API_KEY not found. Set via environment variable or .roastrc.json"
+    );
+    return null;
+  }
+  if (config.cacheEnabled !== false) {
+    const cached = getCachedRoast(finding, rootDir, config.cachePath);
+    if (cached) {
+      return cached;
+    }
+  }
+  try {
+    const anthropic = new Anthropic({ apiKey });
+    const prompt = buildRoastPrompt(finding);
+    const response = await anthropic.messages.create({
+      model: config.model || DEFAULT_MODEL,
+      max_tokens: config.maxTokens || DEFAULT_MAX_TOKENS,
+      temperature: config.temperature || DEFAULT_TEMPERATURE,
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ]
+    });
+    const roast = response.content[0].type === "text" ? response.content[0].text : null;
+    if (roast && config.cacheEnabled !== false) {
+      cacheRoast(finding, roast, rootDir, config.cachePath);
+    }
+    return roast;
+  } catch (error) {
+    console.warn(
+      `Warning: Failed to generate AI roast: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+async function generateAIRoastsBatch(findings, config, rootDir, maxConcurrent = 3) {
+  const roasts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < findings.length; i += maxConcurrent) {
+    const batch = findings.slice(i, i + maxConcurrent);
+    const promises = batch.map(async (finding) => {
+      const roast = await generateAIRoast(finding, config, rootDir);
+      if (roast) {
+        roasts.set(finding.id, roast);
+      }
+    });
+    await Promise.all(promises);
+  }
+  return roasts;
+}
+function buildRoastPrompt(finding) {
+  const severityContext = finding.severity === "critical" ? "This is a critical issue that needs immediate attention." : finding.severity === "warning" ? "This is a warning-level issue." : "This is an informational finding.";
+  let context = `Generate a witty, humorous but constructive roast for this code issue.
+
+Category: ${finding.category}
+Severity: ${finding.severity}
+${severityContext}
+
+Issue: ${finding.message}`;
+  if (finding.file) {
+    context += `
+File: ${finding.file}`;
+  }
+  if (finding.detail) {
+    context += `
+Details: ${finding.detail}`;
+  }
+  context += `
+
+Requirements:
+- Be funny and witty, but not mean-spirited
+- Make it specific to the actual issue
+- Keep it under 2 sentences
+- Use developer humor (references to coffee, late nights, etc. are welcome)
+- Be constructive - the roast should make the developer want to fix the issue
+- Don't use generic statements - reference the specific problem
+
+Examples of good roasts:
+- For a 1,847-line file: "This file is doing more jobs than a Swiss Army knife. Pick a lane."
+- For circular dependencies: "These files are more codependent than a reality TV couple."
+- For 50 TODOs: "Your code has more TODOs than a grocery list. Maybe start with the ones from 2019?"
+
+Generate only the roast, no explanations or meta-commentary.`;
+  return context;
+}
+function getFindingHash(finding) {
+  const key = `${finding.category}-${finding.severity}-${finding.message}-${finding.file || ""}`;
+  return crypto.createHash("md5").update(key).digest("hex");
+}
+function getCachedRoast(finding, rootDir, cachePath) {
+  const cacheFile = path9.join(rootDir, cachePath || CACHE_FILE);
+  if (!fs11.existsSync(cacheFile)) {
+    return null;
+  }
+  try {
+    const content = fs11.readFileSync(cacheFile, "utf-8");
+    const cache = JSON.parse(content);
+    const findingHash = getFindingHash(finding);
+    const now = Date.now();
+    const cached = cache.find(
+      (c) => c.findingHash === findingHash && now - c.timestamp < CACHE_TTL
+    );
+    return cached ? cached.roast : null;
+  } catch {
+    return null;
+  }
+}
+function cacheRoast(finding, roast, rootDir, cachePath) {
+  const cacheFile = path9.join(rootDir, cachePath || CACHE_FILE);
+  try {
+    let cache = [];
+    if (fs11.existsSync(cacheFile)) {
+      const content = fs11.readFileSync(cacheFile, "utf-8");
+      cache = JSON.parse(content);
+    }
+    const findingHash = getFindingHash(finding);
+    cache = cache.filter((c) => c.findingHash !== findingHash);
+    cache.push({
+      findingHash,
+      roast,
+      timestamp: Date.now()
+    });
+    const now = Date.now();
+    cache = cache.filter((c) => now - c.timestamp < CACHE_TTL);
+    if (cache.length > 100) {
+      cache = cache.slice(-100);
+    }
+    fs11.writeFileSync(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+  } catch (error) {
+  }
+}
+
+// src/roasts/index.ts
+var largeFileRoasts = [
+  "This file has achieved sentience.",
+  "At this size, this module should have its own roadmap.",
+  "This file contains several geological layers.",
+  "Future archaeologists will study this file.",
+  "This file predates some of your dependencies.",
+  "Scrolling through this file counts as cardio.",
+  "This file has more lines than some microservices have total.",
+  "This is less a file and more of a lifestyle."
+];
+var todoRoasts = [
+  "Future You has requested fewer TODOs and more DO-NOs.",
+  "Your codebase has more promises than a politician in election season.",
+  "These TODOs have aged like fine wine \u2014 ignored and dusty.",
+  "Every TODO is a tiny apology to your future self.",
+  "These TODOs are now historical artifacts.",
+  "Someone left breadcrumbs. Nobody followed them back."
+];
+var dependencyRoasts = [
+  "This package.json reads like a phone book.",
+  "Your node_modules folder needs its own zip code.",
+  "This dependency appears to be paying rent for no reason.",
+  "Your left-pad insurance policy is extensive.",
+  "There are more dependencies here than features.",
+  "npm install probably takes a lunch break."
+];
+var circularRoasts = [
+  "These files are in a codependent relationship.",
+  "This import cycle is an infinite loop of regret.",
+  "These modules reference each other like they're in couples therapy.",
+  "A dependency circle \u2014 the software equivalent of a dog chasing its tail.",
+  "These files import each other like two mirrors facing each other."
+];
+var structureRoasts = [
+  "This folder structure would make a spelunker nervous.",
+  "Your project nesting goes deeper than the Mariana Trench.",
+  "The junk drawer has evolved into a junk warehouse.",
+  "Your utils folder has more career potential than a senior engineer.",
+  "Someone really committed to the folder-per-thought architecture."
+];
+var complexityRoasts = [
+  "This function has more branches than a forest.",
+  "Cyclomatic complexity called \u2014 it wants its title back.",
+  "This function does everything except make you coffee.",
+  "Reading this function requires a trail guide and emergency supplies.",
+  "This function's decision tree looks like a family tree from Game of Thrones."
+];
+var duplicateRoasts = [
+  "Copy-paste is not a design pattern.",
+  "This code has more twins than a soap opera.",
+  "Someone discovered Ctrl+C but not abstraction.",
+  "DRY principles died here.",
+  "This code clones itself like a biological virus."
+];
+var deadExportRoasts = [
+  "These exports are shouting into the void.",
+  "This function is export-only, like a concept car that never ships.",
+  "Nobody imports this. Nobody.",
+  "This export is as useful as a chocolate teapot.",
+  "These dead exports are the software equivalent of ghost towns."
+];
+var typeSafetyRoasts = [
+  "TypeScript is just JavaScript with extra steps at this rate.",
+  "The 'any' escape hatch has become the front door.",
+  "Your type safety is more like type suggestions.",
+  "@ts-ignore: because types are hard.",
+  "This codebase treats TypeScript like a linter, not a language."
+];
+var gitChurnRoasts = [
+  "This file changes more often than JavaScript frameworks.",
+  "Version control or version chaos? You decide.",
+  "This file has more revisions than a novel.",
+  "At this rate of change, git log is your documentation."
+];
+var securityRoasts = [
+  "Secrets in git. Because what could go wrong?",
+  "Your API keys are public. Consider them compromised.",
+  "eval() \u2014 when you want attackers to write your code for you.",
+  "Hardcoded secrets: the gift that keeps on giving (to hackers)."
+];
+var testCoverageRoasts = [
+  "Tests are optional, right? Right?",
+  "This code is production-ready. Trust me.",
+  "Writing tests is for people who make mistakes.",
+  "YOLO-driven development at its finest."
+];
+var frameworkRoasts = [
+  "Next.js best practices are more like Next.js suggestions, apparently.",
+  "Missing metadata \u2014 search engines love mystery pages.",
+  "Error boundaries are for people who expect errors.",
+  "Client hooks in server components: bold strategy."
+];
+var verdicts = {
+  excellent: [
+    "Your codebase is suspiciously clean. Are you hiding something?",
+    "Impressive. This codebase is either well-maintained or brand new.",
+    "Nearly flawless. Your team might actually read each other's PRs."
+  ],
+  good: [
+    "Solid work. A few rough edges, but nothing that keeps you up at night.",
+    "This codebase has good bones. The renovations can wait.",
+    "Above average. Your tech debt is manageable, not existential."
+  ],
+  fair: [
+    "Your codebase is at that stage where 'refactor sprint' keeps getting postponed.",
+    "Not terrible, not great. Like most software, it exists in a state of managed chaos.",
+    "Some files are applying for monolithic status. Intervention recommended."
+  ],
+  risky: [
+    "Your codebase is one bad merge away from a support group.",
+    "This repository has seen things. And done things. Questionable things.",
+    "The technical debt here could qualify for its own line of credit."
+  ],
+  chaotic: [
+    "This codebase is held together by hope and string literals.",
+    "Abandon all hope, ye who git clone here.",
+    "This isn't a codebase. It's an archaeological dig site."
+  ]
+};
+var pythonTypeHintsRoasts = [
+  "Type hints are optional in Python. So are brakes on a car, technically.",
+  "Dynamic typing is great until your production server discovers the wrong type at 3 AM.",
+  "Type hints: because debugging at runtime is what keeps us young."
+];
+var pythonImportRoasts = [
+  "Wildcard imports: because you like playing 'guess which namespace that came from.'",
+  "Deep relative imports: your codebase is spaghetti that imports other spaghetti.",
+  "from module import * \u2014 the programming equivalent of 'throw everything in and hope.'"
+];
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+async function generateRoasts(findings, aiConfig, rootDir) {
+  const roasts = [];
+  let aiRoasts = /* @__PURE__ */ new Map();
+  if (aiConfig?.enabled && rootDir) {
+    try {
+      const interestingFindings = [
+        ...findings.filter((f) => f.severity === "critical").slice(0, 3),
+        ...findings.filter((f) => f.severity === "warning").slice(0, 4),
+        ...findings.filter((f) => f.severity === "info").slice(0, 3)
+      ].slice(0, 10);
+      aiRoasts = await generateAIRoastsBatch(
+        interestingFindings,
+        aiConfig,
+        rootDir
+      );
+    } catch (error) {
+      console.warn("Warning: AI roast generation failed, using predefined roasts");
+    }
+  }
+  const largeFiles = findings.filter((f) => f.category === "large-files" && f.severity !== "info");
+  for (const finding of largeFiles.slice(0, 3)) {
+    if (!finding.file) continue;
+    const aiRoast = aiRoasts.get(finding.id);
+    roasts.push({
+      target: finding.file,
+      message: aiRoast || pick(largeFileRoasts),
+      category: "large-files"
+    });
+  }
+  const todos = findings.filter((f) => f.category === "todos");
+  if (todos.length > 0) {
+    roasts.push({
+      target: "TODOs",
+      message: pick(todoRoasts),
+      category: "todos"
+    });
+  }
+  const depFindings = findings.filter(
+    (f) => f.category === "dependencies" || f.category === "unused-deps"
+  );
+  if (depFindings.length > 0) {
+    const unusedDeps = findings.filter((f) => f.category === "unused-deps");
+    if (unusedDeps.length > 0) {
+      roasts.push({
+        target: unusedDeps[0].detail || "dependencies",
+        message: pick(dependencyRoasts),
+        category: "dependencies"
+      });
+    }
+    if (findings.some((f) => f.id === "excessive-deps" || f.id === "many-deps")) {
+      roasts.push({
+        target: "package.json",
+        message: pick(dependencyRoasts),
+        category: "dependencies"
+      });
+    }
+  }
+  const circular = findings.filter((f) => f.category === "circular-deps");
+  if (circular.length > 0) {
+    roasts.push({
+      target: circular[0].file || "modules",
+      message: pick(circularRoasts),
+      category: "circular-deps"
+    });
+  }
+  const structure = findings.filter((f) => f.category === "structure" && f.severity === "warning");
+  if (structure.length > 0) {
+    roasts.push({
+      target: structure[0].file || "project structure",
+      message: pick(structureRoasts),
+      category: "structure"
+    });
+  }
+  const complexity = findings.filter((f) => f.category === "complexity" && f.severity !== "info");
+  if (complexity.length > 0) {
+    roasts.push({
+      target: complexity[0].file || "functions",
+      message: pick(complexityRoasts),
+      category: "complexity"
+    });
+  }
+  const duplicates = findings.filter((f) => f.category === "duplicates");
+  if (duplicates.length > 0) {
+    roasts.push({
+      target: duplicates[0].file || "code",
+      message: pick(duplicateRoasts),
+      category: "duplicates"
+    });
+  }
+  const deadExports = findings.filter((f) => f.category === "dead-exports");
+  if (deadExports.length > 0) {
+    roasts.push({
+      target: deadExports[0].file || "exports",
+      message: pick(deadExportRoasts),
+      category: "dead-exports"
+    });
+  }
+  const typeSafety = findings.filter((f) => f.category === "type-safety" && f.severity !== "info");
+  if (typeSafety.length > 0) {
+    roasts.push({
+      target: typeSafety[0].file || "TypeScript",
+      message: pick(typeSafetyRoasts),
+      category: "type-safety"
+    });
+  }
+  const gitChurn = findings.filter((f) => f.category === "git-churn");
+  if (gitChurn.length > 0) {
+    roasts.push({
+      target: gitChurn[0].file || "repository",
+      message: pick(gitChurnRoasts),
+      category: "git-churn"
+    });
+  }
+  const security = findings.filter((f) => f.category === "secrets" || f.category === "env-in-git" || f.category === "eval-usage");
+  if (security.length > 0) {
+    roasts.push({
+      target: security[0].file || "security",
+      message: pick(securityRoasts),
+      category: "security"
+    });
+  }
+  const testCoverage = findings.filter((f) => f.category === "test-coverage");
+  if (testCoverage.length > 0) {
+    roasts.push({
+      target: "test coverage",
+      message: pick(testCoverageRoasts),
+      category: "test-coverage"
+    });
+  }
+  const framework = findings.filter((f) => f.category === "nextjs-metadata" || f.category === "nextjs-client-server" || f.category === "react-error-boundary");
+  if (framework.length > 0) {
+    roasts.push({
+      target: framework[0].file || "framework",
+      message: pick(frameworkRoasts),
+      category: "framework"
+    });
+  }
+  const pythonTypeHints = findings.filter((f) => f.category === "type-safety" && f.message.includes("Python"));
+  if (pythonTypeHints.length > 0) {
+    roasts.push({
+      target: "Python code",
+      message: pick(pythonTypeHintsRoasts),
+      category: "type-safety"
+    });
+  }
+  const pythonImports = findings.filter((f) => f.category === "python-imports");
+  if (pythonImports.length > 0) {
+    roasts.push({
+      target: pythonImports[0].file || "Python imports",
+      message: pick(pythonImportRoasts),
+      category: "python-imports"
+    });
+  }
+  return roasts;
+}
+function generateVerdict(health) {
+  if (health.score >= 90) return pick(verdicts.excellent);
+  if (health.score >= 80) return pick(verdicts.good);
+  if (health.score >= 70) return pick(verdicts.fair);
+  if (health.score >= 60) return pick(verdicts.risky);
+  return pick(verdicts.chaotic);
+}
+
+// src/report/index.ts
+import chalk3 from "chalk";
+import boxen from "boxen";
+
+// src/report/ascii-art.ts
+import chalk from "chalk";
+var ASCII_GRADES = {
+  A: `   \u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+  \u2588\u2588\u2551  \u2588\u2588\u2551
+  \u255A\u2550\u255D  \u255A\u2550\u255D`,
+  B: `  \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+  \u255A\u2550\u2550\u2550\u2550\u2550\u255D`,
+  C: `   \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
+  \u2588\u2588\u2551
+  \u2588\u2588\u2551
+  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+   \u255A\u2550\u2550\u2550\u2550\u2550\u255D`,
+  D: `  \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u2588\u2588\u2551  \u2588\u2588\u2551
+  \u2588\u2588\u2551  \u2588\u2588\u2551
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+  \u255A\u2550\u2550\u2550\u2550\u2550\u255D`,
+  F: `  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
+  \u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u255D
+  \u2588\u2588\u2551
+  \u255A\u2550\u255D`
+};
+function getAsciiGrade(grade) {
+  return ASCII_GRADES[grade] || ASCII_GRADES.F;
+}
+function renderAsciiGrade(health) {
+  const art = getAsciiGrade(health.grade);
+  const color = getScoreColor(health.score);
+  return color(art);
+}
+function getScoreColor(score) {
+  if (score >= 90) return chalk.green;
+  if (score >= 80) return chalk.greenBright;
+  if (score >= 70) return chalk.yellow;
+  if (score >= 60) return chalk.rgb(255, 165, 0);
+  return chalk.red;
+}
+
+// src/report/json.ts
+function renderJsonReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/report/badge.ts
+import fs12 from "fs";
+import chalk2 from "chalk";
+
+// src/utils/security.ts
+import path10 from "path";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+function isValidBranchName(branch) {
+  if (!branch || typeof branch !== "string") {
+    return false;
+  }
+  const validPattern = /^[a-zA-Z0-9/_.-]+$/;
+  return validPattern.test(branch) && !branch.includes("..") && !branch.startsWith("-") && !branch.includes(";") && !branch.includes("|") && !branch.includes("&") && !branch.includes("$") && !branch.includes("`");
+}
+function validateOutputPath(rootDir, filename) {
+  const resolved = path10.resolve(rootDir);
+  const outputPath = path10.resolve(rootDir, filename);
+  const isInside = outputPath.startsWith(resolved + path10.sep) || outputPath === resolved;
+  if (!isInside) {
+    throw new Error(
+      `Security: Output path "${filename}" escapes project directory`
+    );
+  }
+  return outputPath;
+}
+function sanitizeError(error) {
+  if (error instanceof Error) {
+    let message = error.message.replace(/[A-Z]:\\[^\s"']+/g, "<path>");
+    message = message.replace(/\/[^\s"']+/g, "<path>");
+    message = message.replace(/password[=:]\s*\S+/gi, "password=<redacted>");
+    message = message.replace(/token[=:]\s*\S+/gi, "token=<redacted>");
+    message = message.replace(/api[_-]?key[=:]\s*\S+/gi, "apikey=<redacted>");
+    return message;
+  }
+  return "An unexpected error occurred";
+}
+function escapeXml(unsafe) {
+  return String(unsafe).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function debounce(func, wait) {
+  let timeout = null;
+  return function(...args) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      func.apply(this, args);
+    }, wait);
+  };
+}
+
+// src/report/badge.ts
+function generateBadgeSvg(health) {
+  const color = getBadgeColor(health.score);
+  const score = escapeXml(health.score);
+  const svg = `<svg width="150" height="20" xmlns="http://www.w3.org/2000/svg">
+  <rect x="0" y="0" width="60" height="20" fill="#555" rx="3"/>
+  <rect x="60" y="0" width="90" height="20" fill="${color}" rx="3"/>
+  <text x="30" y="14" fill="#fff" font-family="Verdana" font-size="11" text-anchor="middle">Health</text>
+  <text x="105" y="14" fill="#fff" font-family="Verdana" font-size="11" text-anchor="middle">${score}/100</text>
+</svg>`;
+  return svg;
+}
+function getBadgeColor(score) {
+  if (score >= 90) return "#44cc11";
+  if (score >= 80) return "#97ca00";
+  if (score >= 70) return "#dfb317";
+  if (score >= 60) return "#fe7d37";
+  return "#e05d44";
+}
+function saveBadge(svgContent, rootDir) {
+  try {
+    const badgePath = validateOutputPath(rootDir, ".roast-badge.svg");
+    fs12.writeFileSync(badgePath, svgContent, "utf-8");
+    console.log(chalk2.green("\u2713") + " Badge saved to .roast-badge.svg");
+  } catch (error) {
+    console.error(chalk2.red("Error saving badge:"), error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+// src/report/markdown.ts
+function escapeMarkdown(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\_/g, "\\_").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\#/g, "\\#").replace(/\+/g, "\\+").replace(/\-/g, "\\-").replace(/\./g, "\\.").replace(/\!/g, "\\!").replace(/\|/g, "\\|");
+}
+function renderMarkdownHealthBar(score) {
+  const width = 30;
+  const filled = Math.round(score / 100 * width);
+  const empty = width - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty) + ` ${score}/100`;
+}
+function renderMarkdownFindings(findings) {
+  const sections = ["## Findings\n"];
+  const criticals = findings.filter((f) => f.severity === "critical");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const infos = findings.filter((f) => f.severity === "info");
+  if (criticals.length === 0 && warnings.length === 0 && infos.length === 0) {
+    sections.push("No issues found! \u{1F389}\n");
+    return sections.join("\n");
+  }
+  if (criticals.length > 0) {
+    sections.push(`### \u{1F534} Critical (${criticals.length})`);
+    sections.push("<details>");
+    sections.push("<summary>View critical issues</summary>\n");
+    for (const f of criticals) {
+      const location = f.file ? ` (${escapeMarkdown(f.file)})` : "";
+      sections.push(`- **${escapeMarkdown(f.category)}** - ${escapeMarkdown(f.message)}${location}`);
+    }
+    sections.push("\n</details>\n");
+  }
+  if (warnings.length > 0) {
+    sections.push(`### \u26A0\uFE0F Warnings (${warnings.length})`);
+    sections.push("<details>");
+    sections.push("<summary>View warnings</summary>\n");
+    for (const f of warnings) {
+      const location = f.file ? ` (${escapeMarkdown(f.file)})` : "";
+      sections.push(`- **${escapeMarkdown(f.category)}** - ${escapeMarkdown(f.message)}${location}`);
+    }
+    sections.push("\n</details>\n");
+  }
+  if (infos.length > 0) {
+    sections.push(`### \u2139\uFE0F Info (${infos.length})`);
+    sections.push("<details open>");
+    sections.push("<summary>View info</summary>\n");
+    for (const f of infos) {
+      const location = f.file ? ` (${escapeMarkdown(f.file)})` : "";
+      sections.push(`- **${escapeMarkdown(f.category)}** - ${escapeMarkdown(f.message)}${location}`);
+    }
+    sections.push("\n</details>\n");
+  }
+  return sections.join("\n");
+}
+function renderMarkdownReport(report) {
+  const sections = [];
+  sections.push(`# \u{1F525} Roast Report: ${escapeMarkdown(report.projectName)}
+`);
+  sections.push(`## Health Score: ${report.health.score}/100 (${report.health.grade})
+`);
+  sections.push(renderMarkdownHealthBar(report.health.score) + "\n");
+  sections.push("## Project Summary\n");
+  sections.push("| Metric | Value |");
+  sections.push("|--------|-------|");
+  sections.push(`| Files Scanned | ${report.stats.sourceFiles.toLocaleString()} |`);
+  sections.push(`| Total Files | ${report.stats.totalFiles.toLocaleString()} |`);
+  sections.push(`| Lines of Code | ${report.stats.totalLines.toLocaleString()} |`);
+  sections.push(`| Dependencies | ${report.stats.dependencies} |`);
+  sections.push(`| Dev Dependencies | ${report.stats.devDependencies} |
+`);
+  sections.push(renderMarkdownFindings(report.findings));
+  if (report.roasts.length > 0) {
+    sections.push("## \u{1F525} Roasts\n");
+    for (const roast of report.roasts) {
+      sections.push(`> **${escapeMarkdown(roast.target)}**`);
+      sections.push(`> ${escapeMarkdown(roast.message)}
+`);
+    }
+  }
+  if (report.fixes && report.fixes.length > 0) {
+    sections.push("## \u{1F4DD} Fix Suggestions\n");
+    sections.push("<details>");
+    sections.push("<summary>View actionable fixes</summary>\n");
+    for (const fix of report.fixes) {
+      const target = fix.finding.file || fix.finding.category;
+      sections.push(`- **${escapeMarkdown(target)}** - ${escapeMarkdown(fix.suggestion)}`);
+    }
+    sections.push("\n</details>\n");
+  }
+  sections.push("## Verdict\n");
+  sections.push(escapeMarkdown(report.verdict) + "\n");
+  sections.push("---");
+  sections.push("*Generated by [roast-my-codebase](https://github.com/your-username/roast-my-codebase)*");
+  return sections.join("\n");
+}
+
+// src/report/index.ts
+function renderReport(report, options) {
+  const sections = [];
+  if (options?.ascii) {
+    sections.push(renderAsciiGrade(report.health));
+    sections.push("");
+  }
+  sections.push(
+    boxen(chalk3.bold.white("  Roast My Codebase  ") + "  " + flame(), {
+      padding: { top: 0, bottom: 0, left: 2, right: 2 },
+      borderStyle: "double",
+      borderColor: "yellow",
+      textAlignment: "center"
+    })
+  );
+  sections.push("");
+  sections.push(chalk3.dim(`  Project: ${report.projectName}`));
+  sections.push("");
+  const scoreColor = getScoreColor2(report.health.score);
+  sections.push(
+    chalk3.bold("  Health Score: ") + scoreColor(
+      `${report.health.score}/100  ${report.health.grade}  ${report.health.label}`
+    )
+  );
+  sections.push("");
+  sections.push(renderHealthBar(report.health.score));
+  sections.push("");
+  sections.push(chalk3.bold.white("  Project Summary"));
+  sections.push(chalk3.dim("  " + "\u2500".repeat(40)));
+  sections.push(
+    `  ${chalk3.cyan("Files Scanned")}      ${report.stats.sourceFiles.toLocaleString()}`
+  );
+  sections.push(
+    `  ${chalk3.cyan("Total Files")}        ${report.stats.totalFiles.toLocaleString()}`
+  );
+  sections.push(
+    `  ${chalk3.cyan("Lines of Code")}      ${report.stats.totalLines.toLocaleString()}`
+  );
+  sections.push(
+    `  ${chalk3.cyan("Dependencies")}       ${report.stats.dependencies}`
+  );
+  sections.push(
+    `  ${chalk3.cyan("Dev Dependencies")}   ${report.stats.devDependencies}`
+  );
+  sections.push("");
+  const warnings = report.findings.filter((f) => f.severity === "warning");
+  const criticals = report.findings.filter((f) => f.severity === "critical");
+  const infos = report.findings.filter((f) => f.severity === "info");
+  if (criticals.length > 0 || warnings.length > 0 || infos.length > 0) {
+    sections.push(chalk3.bold.white("  Findings"));
+    sections.push(chalk3.dim("  " + "\u2500".repeat(40)));
+    if (criticals.length > 0) {
+      sections.push(
+        `  ${chalk3.red("\u25CF")} ${chalk3.red.bold(`${criticals.length} critical`)}`
+      );
+    }
+    if (warnings.length > 0) {
+      sections.push(
+        `  ${chalk3.yellow("\u25CF")} ${chalk3.yellow(`${warnings.length} warnings`)}`
+      );
+    }
+    if (infos.length > 0) {
+      sections.push(`  ${chalk3.blue("\u25CF")} ${chalk3.blue(`${infos.length} info`)}`);
+    }
+    sections.push("");
+    const keyFindings = [...criticals, ...warnings].slice(0, 8);
+    for (const finding of keyFindings) {
+      const icon = finding.severity === "critical" ? chalk3.red("\u2717") : chalk3.yellow("\u26A0");
+      sections.push(`  ${icon} ${chalk3.white(finding.message)}`);
+    }
+    sections.push("");
+  }
+  if (report.roasts.length > 0) {
+    sections.push(
+      boxen(chalk3.bold.yellow(" Roast Time ") + " " + flame(), {
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        borderStyle: "round",
+        borderColor: "yellow"
+      })
+    );
+    sections.push("");
+    for (const roast of report.roasts) {
+      sections.push(`  ${chalk3.bold.white(roast.target)}`);
+      sections.push(`  ${chalk3.yellow(roast.message)}`);
+      sections.push("");
+    }
+  }
+  if (report.fixes && report.fixes.length > 0) {
+    sections.push(
+      boxen(chalk3.bold.cyan(" Fix Suggestions ") + " \u{1F4DD}", {
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        borderStyle: "round",
+        borderColor: "cyan"
+      })
+    );
+    sections.push("");
+    for (const fix of report.fixes) {
+      const target = fix.finding.file || fix.finding.category;
+      sections.push(`  ${chalk3.cyan("\u{1F4DD}")} ${chalk3.dim(target)}`);
+      sections.push(`     ${chalk3.white(fix.suggestion)}`);
+      sections.push("");
+    }
+  }
+  sections.push(chalk3.dim("  " + "\u2500".repeat(40)));
+  sections.push("");
+  sections.push(chalk3.bold.white("  Verdict"));
+  sections.push("");
+  sections.push(`  ${chalk3.italic(report.verdict)}`);
+  sections.push("");
+  sections.push(
+    chalk3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
+  );
+  sections.push(
+    chalk3.dim("  roast-my-codebase \xB7 github.com/your-username/roast-my-codebase")
+  );
+  sections.push("");
+  return sections.join("\n");
+}
+function flame() {
+  return chalk3.redBright("\u{1F525}");
+}
+function getScoreColor2(score) {
+  if (score >= 90) return chalk3.green;
+  if (score >= 80) return chalk3.greenBright;
+  if (score >= 70) return chalk3.yellow;
+  if (score >= 60) return chalk3.rgb(255, 165, 0);
+  return chalk3.red;
+}
+function renderHealthBar(score) {
+  const width = 30;
+  const filled = Math.round(score / 100 * width);
+  const empty = width - filled;
+  const color = getScoreColor2(score);
+  const bar = color("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(empty));
+  return `  [${bar}]`;
+}
+
+// src/fixes/index.ts
+function generateFixSuggestions(findings) {
+  const suggestions = [];
+  for (const finding of findings) {
+    let suggestion = "";
+    let autoFixable = false;
+    let command;
+    switch (finding.category) {
+      case "large-files":
+        if (finding.severity === "critical") {
+          suggestion = `Split ${finding.file} into smaller modules by extracting logical components`;
+        } else {
+          suggestion = `Consider refactoring ${finding.file} to reduce complexity`;
+        }
+        autoFixable = false;
+        break;
+      case "complexity":
+        suggestion = `Refactor function by extracting nested logic into helper functions`;
+        autoFixable = false;
+        break;
+      case "duplicates":
+        suggestion = `Extract duplicated code into a shared utility function or module`;
+        autoFixable = false;
+        break;
+      case "dead-exports":
+        suggestion = `Remove unused export to clean up the API surface`;
+        autoFixable = true;
+        break;
+      case "circular-deps":
+        suggestion = `Break the cycle by introducing a shared interface/type file or inverting one dependency`;
+        autoFixable = false;
+        break;
+      case "unused-dependencies":
+        const packageName = finding.detail || finding.message.match(/`([^`]+)`/)?.[1];
+        suggestion = `Remove unused dependency: ${packageName}`;
+        command = `npm uninstall ${packageName}`;
+        autoFixable = true;
+        break;
+      case "type-safety":
+        if (finding.message.includes("any")) {
+          suggestion = `Replace 'any' with specific types or use 'unknown' for safer type narrowing`;
+        } else if (finding.message.includes("@ts-ignore")) {
+          suggestion = `Address the underlying type error instead of suppressing it`;
+        }
+        autoFixable = false;
+        break;
+      case "todos":
+        suggestion = `Add issue tracker references to TODO comments`;
+        autoFixable = true;
+        break;
+      case "structure":
+        if (finding.id === "deep-nesting") {
+          suggestion = `Flatten directory structure by grouping related files at higher levels`;
+        } else if (finding.id === "util-explosion") {
+          suggestion = `Consolidate utility files by grouping related functions`;
+        }
+        autoFixable = false;
+        break;
+    }
+    if (suggestion) {
+      suggestions.push({
+        findingId: finding.id,
+        finding,
+        suggestion,
+        autoFixable,
+        command
+      });
+    }
+  }
+  return suggestions;
+}
+
+// src/watch/index.ts
+import chokidar from "chokidar";
+import chalk4 from "chalk";
+async function startWatchMode(rootDir, scanners, onScan) {
+  const state = {
+    lastScore: 0,
+    lastFindings: [],
+    runCount: 0
+  };
+  const runScan = async () => {
+    const allFindings = [];
+    let stats;
+    for (const scanner of scanners) {
+      const result = await scanner.scan(rootDir);
+      allFindings.push(...result.findings);
+      if (result.stats) {
+        stats = result.stats;
+      }
+    }
+    const health = calculateHealth(allFindings);
+    const delta = state.runCount > 0 ? health.score - state.lastScore : null;
+    state.lastScore = health.score;
+    state.lastFindings = allFindings;
+    state.runCount++;
+    onScan(allFindings, health, delta, stats);
+  };
+  await runScan();
+  const watcher = chokidar.watch(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], {
+    cwd: rootDir,
+    ignored: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**"],
+    ignoreInitial: true,
+    persistent: true
+  });
+  console.log(chalk4.dim("\n\u{1F440} Watching for changes... (Press Ctrl+C to stop)\n"));
+  const debouncedScan = debounce(async (filePath) => {
+    console.log(chalk4.dim(`
+\u{1F4DD} Changed: ${filePath}`));
+    await runScan();
+  }, 500);
+  watcher.on("change", (filePath) => {
+    debouncedScan(filePath);
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    process.exit(0);
+  });
+}
+function renderWatchSummary(health, delta, findingCounts) {
+  const deltaStr = delta !== null ? delta > 0 ? chalk4.green(` +${delta}`) : delta < 0 ? chalk4.red(` ${delta}`) : chalk4.dim(" \xB10") : "";
+  console.log(`
+  Health: ${health.score}/100${deltaStr} ${health.grade} ${health.label}`);
+  if (findingCounts.critical > 0) {
+    console.log(`  ${chalk4.red("\u2717")} ${findingCounts.critical} critical`);
+  }
+  if (findingCounts.warning > 0) {
+    console.log(`  ${chalk4.yellow("\u26A0")} ${findingCounts.warning} warnings`);
+  }
+  if (findingCounts.info > 0) {
+    console.log(`  ${chalk4.blue("\u25CF")} ${findingCounts.info} info`);
+  }
+  console.log("");
+}
+
+// src/compare/index.ts
+import path11 from "path";
+import fs13 from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { randomBytes } from "crypto";
+import { tmpdir } from "os";
+import chalk5 from "chalk";
+async function compareWithBranch(rootDir, branchName, scanFunc) {
+  if (!isValidBranchName(branchName)) {
+    throw new Error(
+      `Invalid branch name: "${branchName}". Branch names must contain only alphanumeric characters, slashes, dashes, underscores, and dots.`
+    );
+  }
+  const gitCheck = spawnSync3("git", ["rev-parse", "--git-dir"], {
+    cwd: rootDir,
+    stdio: "ignore"
+  });
+  if (gitCheck.status !== 0) {
+    throw new Error("Not in a git repository. --compare requires git.");
+  }
+  const branchCheck = spawnSync3("git", ["rev-parse", "--verify", branchName], {
+    cwd: rootDir,
+    stdio: "ignore"
+  });
+  if (branchCheck.status !== 0) {
+    throw new Error(`Branch "${branchName}" not found.`);
+  }
+  console.log(chalk5.dim(`Scanning current working directory...`));
+  const currentResult = await scanFunc(rootDir);
+  const randomId = randomBytes(8).toString("hex");
+  const worktreePath = path11.join(tmpdir(), `.roast-worktree-${randomId}`);
+  console.log(chalk5.dim(`Checking out ${branchName} to temporary worktree...`));
+  let cleanupAttempted = false;
+  const cleanupWorktree = async (retries = 3) => {
+    if (cleanupAttempted) return;
+    cleanupAttempted = true;
+    for (let i = 0; i < retries; i++) {
+      const result = spawnSync3("git", ["worktree", "remove", worktreePath, "--force"], {
+        cwd: rootDir,
+        stdio: "ignore"
+      });
+      if (result.status === 0) return;
+      await new Promise((resolve) => setTimeout(resolve, 100 * (i + 1)));
+    }
+    if (fs13.existsSync(worktreePath)) {
+      try {
+        fs13.rmSync(worktreePath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+  try {
+    const addWorktree = spawnSync3("git", ["worktree", "add", worktreePath, branchName], {
+      cwd: rootDir,
+      stdio: "ignore"
+    });
+    if (addWorktree.status !== 0) {
+      throw new Error(`Failed to create worktree for branch "${branchName}".`);
+    }
+    console.log(chalk5.dim(`Scanning ${branchName}...`));
+    const branchResult = await scanFunc(worktreePath);
+    const currentFindingIds = new Set(currentResult.findings.map((f) => f.id));
+    const branchFindingIds = new Set(branchResult.findings.map((f) => f.id));
+    const newFindings = currentResult.findings.filter(
+      (f) => !branchFindingIds.has(f.id)
+    );
+    const resolvedFindings = branchResult.findings.filter(
+      (f) => !currentFindingIds.has(f.id)
+    );
+    const unchangedCount = currentResult.findings.filter(
+      (f) => branchFindingIds.has(f.id)
+    ).length;
+    const result = {
+      currentScore: currentResult.health.score,
+      branchScore: branchResult.health.score,
+      scoreDelta: currentResult.health.score - branchResult.health.score,
+      newFindings,
+      resolvedFindings,
+      unchangedCount
+    };
+    await cleanupWorktree();
+    return result;
+  } catch (error) {
+    await cleanupWorktree();
+    throw error;
+  }
+}
+function renderComparison(comparison, branchName) {
+  console.log("");
+  console.log(chalk5.bold.white("  Comparison Results"));
+  console.log(chalk5.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  const deltaColor = comparison.scoreDelta > 0 ? chalk5.green : comparison.scoreDelta < 0 ? chalk5.red : chalk5.dim;
+  const deltaSign = comparison.scoreDelta > 0 ? "+" : "";
+  console.log(`  Current:   ${comparison.currentScore}/100`);
+  console.log(`  ${branchName.padEnd(8)}: ${comparison.branchScore}/100`);
+  console.log(`  Delta:     ${deltaColor(deltaSign + comparison.scoreDelta)}`);
+  console.log("");
+  if (comparison.newFindings.length > 0) {
+    console.log(chalk5.red(`  \u2717 ${comparison.newFindings.length} new issues:`));
+    for (const finding of comparison.newFindings.slice(0, 5)) {
+      console.log(`    ${chalk5.red("+")} ${finding.message}`);
+    }
+    if (comparison.newFindings.length > 5) {
+      console.log(`    ${chalk5.dim(`...and ${comparison.newFindings.length - 5} more`)}`);
+    }
+    console.log("");
+  }
+  if (comparison.resolvedFindings.length > 0) {
+    console.log(chalk5.green(`  \u2713 ${comparison.resolvedFindings.length} issues resolved:`));
+    for (const finding of comparison.resolvedFindings.slice(0, 5)) {
+      console.log(`    ${chalk5.green("-")} ${finding.message}`);
+    }
+    if (comparison.resolvedFindings.length > 5) {
+      console.log(`    ${chalk5.dim(`...and ${comparison.resolvedFindings.length - 5} more`)}`);
+    }
+    console.log("");
+  }
+  console.log(chalk5.dim(`  ${comparison.unchangedCount} unchanged issues`));
+  console.log("");
+}
+
+// src/config/index.ts
+import fs14 from "fs";
+import path12 from "path";
+
+// src/config/validation.ts
+function validateConfig(userConfig) {
+  if (typeof userConfig !== "object" || userConfig === null) {
+    throw new Error("Invalid config: must be an object");
+  }
+  const validated = {};
+  const config = userConfig;
+  if ("thresholds" in config && typeof config.thresholds === "object" && config.thresholds !== null) {
+    const thresholds = config.thresholds;
+    validated.thresholds = {};
+    if ("largeFile" in thresholds && typeof thresholds.largeFile === "number" && thresholds.largeFile > 0) {
+      validated.thresholds.largeFile = thresholds.largeFile;
+    }
+    if ("extremeFile" in thresholds && typeof thresholds.extremeFile === "number" && thresholds.extremeFile > 0) {
+      validated.thresholds.extremeFile = thresholds.extremeFile;
+    }
+    if ("highChurn" in thresholds && typeof thresholds.highChurn === "number" && thresholds.highChurn > 0) {
+      validated.thresholds.highChurn = thresholds.highChurn;
+    }
+    if ("criticalChurn" in thresholds && typeof thresholds.criticalChurn === "number" && thresholds.criticalChurn > 0) {
+      validated.thresholds.criticalChurn = thresholds.criticalChurn;
+    }
+    if ("largePR" in thresholds && typeof thresholds.largePR === "number" && thresholds.largePR > 0) {
+      validated.thresholds.largePR = thresholds.largePR;
+    }
+    if ("criticalPR" in thresholds && typeof thresholds.criticalPR === "number" && thresholds.criticalPR > 0) {
+      validated.thresholds.criticalPR = thresholds.criticalPR;
+    }
+  }
+  if ("scanners" in config && typeof config.scanners === "object" && config.scanners !== null) {
+    const scanners = config.scanners;
+    validated.scanners = {};
+    if ("disabled" in scanners && Array.isArray(scanners.disabled)) {
+      validated.scanners.disabled = scanners.disabled.filter(
+        (item) => typeof item === "string"
+      );
+    }
+  }
+  if ("ignore" in config && Array.isArray(config.ignore)) {
+    validated.ignore = config.ignore.filter((item) => typeof item === "string");
+  }
+  if ("deductions" in config && typeof config.deductions === "object" && config.deductions !== null) {
+    const deductions = config.deductions;
+    validated.deductions = {};
+    for (const [key, value] of Object.entries(deductions)) {
+      if (typeof key === "string" && typeof value === "number") {
+        if (key !== "__proto__" && key !== "constructor" && key !== "prototype") {
+          validated.deductions[key] = value;
+        }
+      }
+    }
+  }
+  if ("plugins" in config && Array.isArray(config.plugins)) {
+    validated.plugins = config.plugins.filter((item) => typeof item === "string");
+  }
+  if ("ai" in config && typeof config.ai === "object" && config.ai !== null) {
+    const ai = config.ai;
+    validated.ai = {};
+    if ("enabled" in ai && typeof ai.enabled === "boolean") {
+      validated.ai.enabled = ai.enabled;
+    }
+    if ("apiKey" in ai && typeof ai.apiKey === "string") {
+      validated.ai.apiKey = ai.apiKey;
+    }
+    if ("model" in ai && typeof ai.model === "string") {
+      validated.ai.model = ai.model;
+    }
+    if ("maxTokens" in ai && typeof ai.maxTokens === "number" && ai.maxTokens > 0) {
+      validated.ai.maxTokens = ai.maxTokens;
+    }
+    if ("temperature" in ai && typeof ai.temperature === "number" && ai.temperature >= 0 && ai.temperature <= 2) {
+      validated.ai.temperature = ai.temperature;
+    }
+    if ("cacheEnabled" in ai && typeof ai.cacheEnabled === "boolean") {
+      validated.ai.cacheEnabled = ai.cacheEnabled;
+    }
+    if ("cachePath" in ai && typeof ai.cachePath === "string") {
+      validated.ai.cachePath = ai.cachePath;
+    }
+  }
+  return validated;
+}
+function safeJsonParse(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && ("__proto__" in parsed || "constructor" in parsed || "prototype" in parsed)) {
+      console.warn("Warning: Detected prototype pollution attempt in JSON");
+      const cleaned = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (key !== "__proto__" && key !== "constructor" && key !== "prototype") {
+          cleaned[key] = value;
+        }
+      }
+      return cleaned;
+    }
+    return parsed;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/config/index.ts
+var DEFAULT_CONFIG = {
+  thresholds: {
+    largeFile: 500,
+    extremeFile: 2e3,
+    highChurn: 50,
+    criticalChurn: 100,
+    largePR: 20,
+    criticalPR: 40
+  },
+  scanners: {
+    disabled: []
+  },
+  ignore: [],
+  deductions: {},
+  plugins: []
+};
+function loadConfig(rootDir) {
+  const configPath = path12.join(rootDir, ".roastrc.json");
+  if (!fs14.existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = fs14.readFileSync(configPath, "utf-8");
+    const parsed = safeJsonParse(content);
+    if (!parsed) {
+      console.warn("Warning: Failed to parse .roastrc.json");
+      return DEFAULT_CONFIG;
+    }
+    const userConfig = validateConfig(parsed);
+    return {
+      thresholds: {
+        ...DEFAULT_CONFIG.thresholds,
+        ...userConfig.thresholds
+      },
+      scanners: {
+        disabled: [
+          ...DEFAULT_CONFIG.scanners?.disabled || [],
+          ...userConfig.scanners?.disabled || []
+        ]
+      },
+      ignore: [
+        ...DEFAULT_CONFIG.ignore || [],
+        ...userConfig.ignore || []
+      ],
+      deductions: {
+        ...DEFAULT_CONFIG.deductions,
+        ...userConfig.deductions
+      },
+      plugins: [
+        ...DEFAULT_CONFIG.plugins || [],
+        ...userConfig.plugins || []
+      ]
+    };
+  } catch (error) {
+    console.warn(`Warning: Failed to load .roastrc.json: ${error}`);
+    return DEFAULT_CONFIG;
+  }
+}
+
+// src/interactive/index.ts
+import { confirm, select } from "@inquirer/prompts";
+import chalk6 from "chalk";
+
+// src/interactive/fixes.ts
+import fs15 from "fs";
+import path13 from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+async function applyAutoFix(finding, fix, rootDir, dryRun = false) {
+  switch (finding.category) {
+    case "unused-dependencies":
+      return fixUnusedDependency(finding, rootDir, dryRun);
+    case "todos":
+      return fixTodoComment(finding, rootDir, dryRun);
+    case "dead-exports":
+      return fixDeadExport(finding, rootDir, dryRun);
+    default:
+      return {
+        success: false,
+        message: `No auto-fix available for category: ${finding.category}`
+      };
+  }
+}
+function fixUnusedDependency(finding, rootDir, dryRun) {
+  const match = finding.message.match(/`([^`]+)`/);
+  if (!match) {
+    return {
+      success: false,
+      message: "Could not extract package name from finding"
+    };
+  }
+  const packageName = match[1];
+  const pkgPath = path13.join(rootDir, "package.json");
+  try {
+    if (dryRun) {
+      return {
+        success: true,
+        message: `Would run: npm uninstall ${packageName}`
+      };
+    }
+    const result = spawnSync4("npm", ["uninstall", packageName], {
+      cwd: rootDir,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    if (result.status === 0) {
+      return {
+        success: true,
+        message: `Removed unused dependency: ${packageName}`
+      };
+    } else {
+      return {
+        success: false,
+        message: `Failed to remove ${packageName}: ${result.stderr}`
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: `Error removing dependency: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function fixTodoComment(finding, rootDir, dryRun) {
+  if (!finding.file) {
+    return {
+      success: false,
+      message: "No file specified for TODO fix"
+    };
+  }
+  const filePath = path13.join(rootDir, finding.file);
+  try {
+    const content = fs15.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const todoPattern = /\/\/\s*(TODO|FIXME|HACK|XXX):\s*(.+)/i;
+    let modified = false;
+    const newLines = lines.map((line) => {
+      const match = line.match(todoPattern);
+      if (match && !line.includes("Issue:") && !line.includes("#")) {
+        modified = true;
+        const indent = line.match(/^\s*/)?.[0] || "";
+        return `${indent}// ${match[1]}: ${match[2]} (Issue: #TODO - create issue)`;
+      }
+      return line;
+    });
+    if (!modified) {
+      return {
+        success: false,
+        message: "No TODOs found to fix"
+      };
+    }
+    if (dryRun) {
+      const changedLines = newLines.filter(
+        (line, i) => line !== lines[i]
+      ).length;
+      return {
+        success: true,
+        message: `Would add issue references to ${changedLines} TODO comment(s)`
+      };
+    }
+    fs15.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    return {
+      success: true,
+      message: `Added issue references to TODO comments in ${finding.file}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Error fixing TODOs: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function fixDeadExport(finding, rootDir, dryRun) {
+  if (!finding.file) {
+    return {
+      success: false,
+      message: "No file specified for dead export fix"
+    };
+  }
+  const match = finding.message.match(/`([^`]+)`/);
+  if (!match) {
+    return {
+      success: false,
+      message: "Could not extract export name from finding"
+    };
+  }
+  const exportName = match[1];
+  const filePath = path13.join(rootDir, finding.file);
+  try {
+    const content = fs15.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const exportPattern = new RegExp(
+      `export\\s+(const|let|var|function|class|type|interface)\\s+${exportName}\\b`,
+      "i"
+    );
+    let modified = false;
+    const newLines = lines.filter((line) => {
+      if (exportPattern.test(line)) {
+        modified = true;
+        return false;
+      }
+      return true;
+    });
+    if (!modified) {
+      return {
+        success: false,
+        message: `Export ${exportName} not found in ${finding.file}`
+      };
+    }
+    if (dryRun) {
+      return {
+        success: true,
+        message: `Would remove dead export: ${exportName} from ${finding.file}`
+      };
+    }
+    fs15.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    return {
+      success: true,
+      message: `Removed dead export: ${exportName} from ${finding.file}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Error fixing dead export: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/interactive/index.ts
+async function runInteractiveMode(report, rootDir, dryRun = false) {
+  const session = {
+    totalFindings: 0,
+    fixedCount: 0,
+    skippedCount: 0,
+    errorCount: 0
+  };
+  console.log(chalk6.bold.cyan("\n\u{1F527} Interactive Fix Mode\n"));
+  console.log(chalk6.dim("Let's fix these issues together!\n"));
+  const fixableFindings = report.findings.filter(
+    (f) => report.fixes?.some((fix) => fix.findingId === f.id)
+  );
+  const nonFixableFindings = report.findings.filter(
+    (f) => !report.fixes?.some((fix) => fix.findingId === f.id)
+  );
+  session.totalFindings = fixableFindings.length;
+  if (fixableFindings.length === 0) {
+    console.log(chalk6.green("\u2713 No fixable issues found!\n"));
+    if (nonFixableFindings.length > 0) {
+      console.log(
+        chalk6.yellow(
+          `\u26A0 ${nonFixableFindings.length} issues require manual fixes.
+`
+        )
+      );
+    }
+    return session;
+  }
+  console.log(
+    chalk6.white(
+      `Found ${chalk6.bold(fixableFindings.length)} fixable issues.
+`
+    )
+  );
+  const critical = fixableFindings.filter((f) => f.severity === "critical");
+  const warnings = fixableFindings.filter((f) => f.severity === "warning");
+  const info = fixableFindings.filter((f) => f.severity === "info");
+  console.log(chalk6.red(`  \u{1F534} ${critical.length} critical`));
+  console.log(chalk6.yellow(`  \u26A0\uFE0F  ${warnings.length} warnings`));
+  console.log(chalk6.blue(`  \u2139\uFE0F  ${info.length} info
+`));
+  const shouldContinue = await confirm({
+    message: "Start fixing issues?",
+    default: true
+  });
+  if (!shouldContinue) {
+    console.log(chalk6.dim("\nExiting interactive mode.\n"));
+    return session;
+  }
+  const orderedFindings = [...critical, ...warnings, ...info];
+  for (let i = 0; i < orderedFindings.length; i++) {
+    const finding = orderedFindings[i];
+    const fix = report.fixes?.find((f) => f.findingId === finding.id);
+    if (!fix) continue;
+    console.log(chalk6.dim(`
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+    console.log(
+      chalk6.white(
+        `Issue ${i + 1}/${orderedFindings.length} - ${getSeverityIcon(finding.severity)}`
+      )
+    );
+    console.log(chalk6.dim(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`));
+    console.log(chalk6.bold(finding.message));
+    if (finding.file) {
+      console.log(chalk6.dim(`  File: ${finding.file}`));
+    }
+    if (finding.detail) {
+      console.log(chalk6.dim(`  Detail: ${finding.detail}`));
+    }
+    console.log();
+    console.log(chalk6.cyan("\u{1F4A1} Fix suggestion:"));
+    console.log(chalk6.white(`  ${fix.suggestion}`));
+    console.log();
+    const isAutoFixable = fix.autoFixable || false;
+    if (isAutoFixable) {
+      console.log(chalk6.green("\u2713 This can be fixed automatically!\n"));
+      const action = await select({
+        message: "What would you like to do?",
+        choices: [
+          {
+            name: dryRun ? "Preview fix (dry run)" : "Apply fix automatically",
+            value: "apply",
+            description: dryRun ? "Show what would be fixed" : "Let the tool fix this for you"
+          },
+          {
+            name: "Show details",
+            value: "details",
+            description: "See more information about this issue"
+          },
+          {
+            name: "Skip",
+            value: "skip",
+            description: "Leave this for later"
+          },
+          {
+            name: "Exit interactive mode",
+            value: "exit",
+            description: "Stop fixing issues"
+          }
+        ]
+      });
+      if (action === "exit") {
+        console.log(
+          chalk6.dim(`
+Fixed ${session.fixedCount} issues. Goodbye!
+`)
+        );
+        break;
+      }
+      if (action === "skip") {
+        session.skippedCount++;
+        console.log(chalk6.yellow("\u23ED  Skipped\n"));
+        continue;
+      }
+      if (action === "details") {
+        await showFindingDetails(finding, fix);
+        i--;
+        continue;
+      }
+      if (action === "apply") {
+        try {
+          const result = await applyAutoFix(finding, fix, rootDir, dryRun);
+          if (result.success) {
+            session.fixedCount++;
+            if (dryRun) {
+              console.log(chalk6.green("\n\u2713 Preview:"));
+              console.log(chalk6.dim(result.message));
+            } else {
+              console.log(chalk6.green(`
+\u2713 ${result.message}`));
+            }
+          } else {
+            session.errorCount++;
+            console.log(chalk6.red(`
+\u2717 ${result.message}`));
+          }
+        } catch (error) {
+          session.errorCount++;
+          console.log(
+            chalk6.red(
+              `
+\u2717 Failed to apply fix: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
+    } else {
+      console.log(
+        chalk6.yellow("\u26A0 This requires manual intervention.\n")
+      );
+      const action = await select({
+        message: "What would you like to do?",
+        choices: [
+          {
+            name: "Mark as done (I fixed it manually)",
+            value: "done",
+            description: "You've fixed this issue yourself"
+          },
+          {
+            name: "Show details",
+            value: "details",
+            description: "See more information about this issue"
+          },
+          {
+            name: "Skip",
+            value: "skip",
+            description: "Leave this for later"
+          },
+          {
+            name: "Exit interactive mode",
+            value: "exit",
+            description: "Stop fixing issues"
+          }
+        ]
+      });
+      if (action === "exit") {
+        console.log(
+          chalk6.dim(`
+Fixed ${session.fixedCount} issues. Goodbye!
+`)
+        );
+        break;
+      }
+      if (action === "skip") {
+        session.skippedCount++;
+        console.log(chalk6.yellow("\u23ED  Skipped\n"));
+        continue;
+      }
+      if (action === "details") {
+        await showFindingDetails(finding, fix);
+        i--;
+        continue;
+      }
+      if (action === "done") {
+        session.fixedCount++;
+        console.log(chalk6.green("\u2713 Marked as done\n"));
+      }
+    }
+  }
+  console.log(chalk6.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk6.bold.cyan("\n\u{1F4CA} Interactive Session Summary\n"));
+  console.log(chalk6.white(`  Total issues: ${session.totalFindings}`));
+  console.log(chalk6.green(`  \u2713 Fixed: ${session.fixedCount}`));
+  console.log(chalk6.yellow(`  \u23ED  Skipped: ${session.skippedCount}`));
+  if (session.errorCount > 0) {
+    console.log(chalk6.red(`  \u2717 Errors: ${session.errorCount}`));
+  }
+  console.log();
+  if (session.fixedCount > 0 && !dryRun) {
+    console.log(
+      chalk6.green(`\u{1F389} Great work! You've improved your codebase.
+`)
+    );
+  }
+  return session;
+}
+async function showFindingDetails(finding, fix) {
+  console.log(chalk6.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk6.bold.cyan("\u{1F4CB} Detailed Information\n"));
+  console.log(chalk6.white("Finding:"));
+  console.log(`  ID: ${chalk6.dim(finding.id)}`);
+  console.log(`  Category: ${chalk6.dim(finding.category)}`);
+  console.log(`  Severity: ${getSeverityBadge(finding.severity)}`);
+  if (finding.file) {
+    console.log(`  File: ${chalk6.dim(finding.file)}`);
+  }
+  console.log();
+  console.log(chalk6.white("Message:"));
+  console.log(`  ${finding.message}`);
+  if (finding.detail) {
+    console.log();
+    console.log(chalk6.white("Details:"));
+    console.log(`  ${finding.detail}`);
+  }
+  console.log();
+  console.log(chalk6.white("Fix Suggestion:"));
+  console.log(`  ${fix.suggestion}`);
+  console.log();
+  if (fix.command) {
+    console.log(chalk6.white("Command:"));
+    console.log(chalk6.dim(`  ${fix.command}`));
+    console.log();
+  }
+  await confirm({
+    message: "Press Enter to continue",
+    default: true
+  });
+}
+function getSeverityIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk6.red("\u{1F534} Critical");
+    case "warning":
+      return chalk6.yellow("\u26A0\uFE0F  Warning");
+    case "info":
+      return chalk6.blue("\u2139\uFE0F  Info");
+    default:
+      return severity;
+  }
+}
+function getSeverityBadge(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk6.bgRed.white.bold(" CRITICAL ");
+    case "warning":
+      return chalk6.bgYellow.black.bold(" WARNING ");
+    case "info":
+      return chalk6.bgBlue.white.bold(" INFO ");
+    default:
+      return severity;
+  }
+}
+
+// src/history/index.ts
+import fs16 from "fs";
+import path14 from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+var HISTORY_FILE = ".roast-history.json";
+function loadHistory(rootDir) {
+  const historyPath = path14.join(rootDir, HISTORY_FILE);
+  if (!fs16.existsSync(historyPath)) {
+    return null;
+  }
+  try {
+    const content = fs16.readFileSync(historyPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Warning: Failed to load health history: ${error}`);
+    return null;
+  }
+}
+function saveHistory(rootDir, history) {
+  const historyPath = path14.join(rootDir, HISTORY_FILE);
+  try {
+    fs16.writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
+  } catch (error) {
+    console.warn(`Warning: Failed to save health history: ${error}`);
+  }
+}
+function createSnapshot(health, findings, rootDir) {
+  let commitHash;
+  let commitMessage;
+  try {
+    const hashResult = spawnSync5("git", ["rev-parse", "--short", "HEAD"], {
+      cwd: rootDir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    if (hashResult.status === 0) {
+      commitHash = hashResult.stdout.trim();
+      const messageResult = spawnSync5(
+        "git",
+        ["log", "-1", "--pretty=%B"],
+        {
+          cwd: rootDir,
+          encoding: "utf-8",
+          stdio: "pipe"
+        }
+      );
+      if (messageResult.status === 0) {
+        commitMessage = messageResult.stdout.trim().split("\n")[0];
+      }
+    }
+  } catch {
+  }
+  const categoryCounts = {};
+  findings.forEach((finding) => {
+    categoryCounts[finding.category] = (categoryCounts[finding.category] || 0) + 1;
+  });
+  return {
+    timestamp: Date.now(),
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    score: health.score,
+    grade: health.grade,
+    totalFindings: findings.length,
+    criticalCount: findings.filter((f) => f.severity === "critical").length,
+    warningCount: findings.filter((f) => f.severity === "warning").length,
+    infoCount: findings.filter((f) => f.severity === "info").length,
+    categoryCounts,
+    commitHash,
+    commitMessage
+  };
+}
+function addSnapshot(rootDir, projectName, snapshot) {
+  let history = loadHistory(rootDir);
+  if (!history) {
+    history = {
+      projectName,
+      snapshots: []
+    };
+  }
+  history.snapshots.push(snapshot);
+  if (history.snapshots.length > 100) {
+    history.snapshots = history.snapshots.slice(-100);
+  }
+  saveHistory(rootDir, history);
+  return history;
+}
+function analyzeTrend(history, days = 30) {
+  if (history.snapshots.length < 2) {
+    return null;
+  }
+  const now = Date.now();
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const recentSnapshots = history.snapshots.filter(
+    (s) => s.timestamp >= cutoff
+  );
+  if (recentSnapshots.length < 2) {
+    return null;
+  }
+  const scores = recentSnapshots.map((s) => s.score);
+  const firstScore = recentSnapshots[0].score;
+  const lastScore = recentSnapshots[recentSnapshots.length - 1].score;
+  const scoreChange = lastScore - firstScore;
+  const averageScore = scores.reduce((sum, score) => sum + score, 0) / scores.length;
+  const bestScore = Math.max(...scores);
+  const worstScore = Math.min(...scores);
+  const actualDays = (recentSnapshots[recentSnapshots.length - 1].timestamp - recentSnapshots[0].timestamp) / (24 * 60 * 60 * 1e3);
+  const improvementRate = actualDays > 0 ? scoreChange / actualDays : 0;
+  let trend;
+  if (scoreChange > 5) {
+    trend = "improving";
+  } else if (scoreChange < -5) {
+    trend = "declining";
+  } else {
+    trend = "stable";
+  }
+  return {
+    trend,
+    scoreChange,
+    periodDays: Math.round(actualDays),
+    averageScore: Math.round(averageScore * 10) / 10,
+    bestScore,
+    worstScore,
+    improvementRate: Math.round(improvementRate * 100) / 100
+  };
+}
+function getSnapshotsByPeriod(history, days) {
+  const now = Date.now();
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  return history.snapshots.filter((s) => s.timestamp >= cutoff);
+}
+function generateTrendChart(snapshots, width = 50, height = 10) {
+  if (snapshots.length < 2) {
+    return "Not enough data for chart";
+  }
+  const scores = snapshots.map((s) => s.score);
+  const minScore = Math.min(...scores, 0);
+  const maxScore = Math.max(...scores, 100);
+  const range = maxScore - minScore;
+  const lines = [];
+  for (let i = height; i >= 0; i--) {
+    const value = minScore + range * i / height;
+    let line = `${Math.round(value).toString().padStart(3)} \u2524`;
+    for (let j = 0; j < width; j++) {
+      const snapshotIndex = Math.floor(j / width * snapshots.length);
+      const snapshot = snapshots[snapshotIndex];
+      const normalizedScore = (snapshot.score - minScore) / range * height;
+      if (Math.abs(normalizedScore - i) < 0.5) {
+        line += "\u25CF";
+      } else if (normalizedScore > i) {
+        line += " ";
+      } else {
+        line += " ";
+      }
+    }
+    lines.push(line);
+  }
+  const firstDate = new Date(snapshots[0].timestamp);
+  const lastDate = new Date(snapshots[snapshots.length - 1].timestamp);
+  const xAxis = "    \u2514" + "\u2500".repeat(width) + "\u2192";
+  lines.push(xAxis);
+  const dateLabel = "     " + firstDate.toLocaleDateString().padEnd(width - 15) + lastDate.toLocaleDateString();
+  lines.push(dateLabel);
+  return lines.join("\n");
+}
+function getCategoryTrends(history, days = 30) {
+  const recentSnapshots = getSnapshotsByPeriod(history, days);
+  if (recentSnapshots.length < 2) {
+    return {};
+  }
+  const firstSnapshot = recentSnapshots[0];
+  const lastSnapshot = recentSnapshots[recentSnapshots.length - 1];
+  const trends = {};
+  const allCategories = /* @__PURE__ */ new Set([
+    ...Object.keys(firstSnapshot.categoryCounts),
+    ...Object.keys(lastSnapshot.categoryCounts)
+  ]);
+  allCategories.forEach((category) => {
+    const firstCount = firstSnapshot.categoryCounts[category] || 0;
+    const lastCount = lastSnapshot.categoryCounts[category] || 0;
+    trends[category] = lastCount - firstCount;
+  });
+  return trends;
+}
+
+// src/history/render.ts
+import chalk7 from "chalk";
+function renderHistoryReport(history, days = 30) {
+  const output = [];
+  output.push(chalk7.bold.cyan("\n\u{1F4CA} Health History Report\n"));
+  output.push(chalk7.dim("\u2500".repeat(60)));
+  output.push("");
+  output.push(chalk7.white(`Project: ${history.projectName}`));
+  output.push(
+    chalk7.white(`Total snapshots: ${history.snapshots.length}`)
+  );
+  output.push("");
+  if (history.snapshots.length === 0) {
+    output.push(chalk7.yellow("No health data recorded yet."));
+    output.push(
+      chalk7.dim("Run with --track flag to start tracking health over time.")
+    );
+    return output.join("\n");
+  }
+  const latest = history.snapshots[history.snapshots.length - 1];
+  output.push(chalk7.bold("Current Health"));
+  output.push(
+    `  Score: ${getScoreColor3(latest.score)}${latest.score}/100${chalk7.reset()} (${latest.grade})`
+  );
+  output.push(`  Findings: ${latest.totalFindings}`);
+  output.push(
+    `  ${chalk7.red("\u25CF")} ${latest.criticalCount} critical  ${chalk7.yellow("\u25CF")} ${latest.warningCount} warnings  ${chalk7.blue("\u25CF")} ${latest.infoCount} info`
+  );
+  if (latest.commitHash) {
+    output.push(chalk7.dim(`  Commit: ${latest.commitHash}`));
+  }
+  output.push("");
+  const trend = analyzeTrend(history, days);
+  if (trend) {
+    output.push(chalk7.bold(`Trend Analysis (Last ${trend.periodDays} days)`));
+    output.push("");
+    const trendIcon = getTrendIcon(trend.trend);
+    const trendColor = getTrendColor(trend.trend);
+    output.push(
+      `  ${trendIcon} ${trendColor(trend.trend.toUpperCase())} ${chalk7.dim(`(${trend.scoreChange > 0 ? "+" : ""}${trend.scoreChange} points)`)}`
+    );
+    output.push("");
+    output.push(chalk7.white("  Statistics:"));
+    output.push(`    Average score: ${trend.averageScore}/100`);
+    output.push(`    Best score: ${chalk7.green(trend.bestScore)}/100`);
+    output.push(`    Worst score: ${chalk7.red(trend.worstScore)}/100`);
+    output.push(
+      `    Improvement rate: ${trend.improvementRate > 0 ? chalk7.green("+") : chalk7.red("")}${trend.improvementRate} points/day`
+    );
+    output.push("");
+    output.push(chalk7.bold("  Score Trend"));
+    output.push("");
+    const recentSnapshots = history.snapshots.filter(
+      (s) => s.timestamp >= Date.now() - days * 24 * 60 * 60 * 1e3
+    );
+    const chart = generateTrendChart(recentSnapshots, 50, 8);
+    output.push(
+      chart.split("\n").map((line) => "  " + line).join("\n")
+    );
+    output.push("");
+    const categoryTrends = getCategoryTrends(history, days);
+    const improving = Object.entries(categoryTrends).filter(([_, change]) => change < 0).sort(([_, a], [__, b]) => a - b);
+    const declining = Object.entries(categoryTrends).filter(([_, change]) => change > 0).sort(([_, a], [__, b]) => b - a);
+    if (improving.length > 0 || declining.length > 0) {
+      output.push(chalk7.bold("  Category Changes"));
+      output.push("");
+      if (improving.length > 0) {
+        output.push(chalk7.green("  \u2193 Improving:"));
+        improving.slice(0, 5).forEach(([category, change]) => {
+          output.push(
+            `    ${chalk7.green("\u2713")} ${category}: ${chalk7.green(change)} issues`
+          );
+        });
+        if (improving.length > 5) {
+          output.push(chalk7.dim(`    ...and ${improving.length - 5} more`));
+        }
+        output.push("");
+      }
+      if (declining.length > 0) {
+        output.push(chalk7.red("  \u2191 Declining:"));
+        declining.slice(0, 5).forEach(([category, change]) => {
+          output.push(
+            `    ${chalk7.red("\u2717")} ${category}: ${chalk7.red("+" + change)} issues`
+          );
+        });
+        if (declining.length > 5) {
+          output.push(chalk7.dim(`    ...and ${declining.length - 5} more`));
+        }
+        output.push("");
+      }
+    }
+  }
+  const recentCount = Math.min(10, history.snapshots.length);
+  output.push(chalk7.bold(`Recent Snapshots (Last ${recentCount})`));
+  output.push("");
+  history.snapshots.slice(-recentCount).reverse().forEach((snapshot) => {
+    const date = new Date(snapshot.timestamp);
+    const dateStr = date.toLocaleString();
+    const scoreColor = getScoreColor3(snapshot.score);
+    output.push(
+      `  ${dateStr} - ${scoreColor}${snapshot.score}${chalk7.reset()} (${snapshot.grade}) - ${snapshot.totalFindings} issues`
+    );
+    if (snapshot.commitHash) {
+      output.push(
+        chalk7.dim(`    ${snapshot.commitHash}: ${snapshot.commitMessage}`)
+      );
+    }
+  });
+  output.push("");
+  output.push(chalk7.dim("\u2500".repeat(60)));
+  output.push("");
+  return output.join("\n");
+}
+function renderTrendSummary(history, days = 7) {
+  const trend = analyzeTrend(history, days);
+  if (!trend) {
+    return chalk7.dim("No trend data available yet");
+  }
+  const trendIcon = getTrendIcon(trend.trend);
+  const trendColor = getTrendColor(trend.trend);
+  const changeStr = trend.scoreChange > 0 ? chalk7.green(`+${trend.scoreChange}`) : trend.scoreChange < 0 ? chalk7.red(`${trend.scoreChange}`) : chalk7.dim("\xB10");
+  return `${trendIcon} ${trendColor(trend.trend)} (${changeStr} over ${trend.periodDays} days)`;
+}
+function getScoreColor3(score) {
+  if (score >= 90) return chalk7.green;
+  if (score >= 80) return chalk7.greenBright;
+  if (score >= 70) return chalk7.yellow;
+  if (score >= 60) return chalk7.hex("#FFA500");
+  return chalk7.red;
+}
+function getTrendIcon(trend) {
+  switch (trend) {
+    case "improving":
+      return chalk7.green("\u2197");
+    case "declining":
+      return chalk7.red("\u2198");
+    case "stable":
+      return chalk7.blue("\u2192");
+  }
+}
+function getTrendColor(trend) {
+  switch (trend) {
+    case "improving":
+      return chalk7.green;
+    case "declining":
+      return chalk7.red;
+    case "stable":
+      return chalk7.blue;
+  }
+}
+
+// src/cli/index.ts
+function loadPackageVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  let dir = path15.dirname(__filename);
+  while (dir !== path15.dirname(dir)) {
+    const pkgPath = path15.join(dir, "package.json");
+    if (fs17.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name === "roast-my-codebase") return pkg.version;
+    }
+    dir = path15.dirname(dir);
+  }
+  return "1.0.0";
+}
+function createCli() {
+  const program2 = new Command();
+  program2.name("roast-my-codebase").description("Get roasted. Get better. Ship faster.").version(loadPackageVersion()).argument("[path]", "path to scan", ".").option("--json", "Output results as JSON").option("--markdown", "Output results as markdown").option("--markdown-file", "Save markdown report to .roast-report.md").option("--fix", "Show actionable fix suggestions").option("--ai-roasts", "Generate AI-powered contextual roasts (requires ANTHROPIC_API_KEY)").option("--interactive", "Interactive mode - walk through fixing issues").option("--dry-run", "Preview fixes without applying them (use with --interactive)").option("--track", "Track health over time in .roast-history.json").option("--history [days]", "Show health history (default: last 30 days)", parseInt).option("--watch", "Watch for file changes and re-run analysis").option("--compare <branch>", "Compare current codebase with a git branch").option("--badge", "Generate health badge SVG (.roast-badge.svg)").option("--ascii", "Show ASCII art grade in output").option(
+    "--threshold <score>",
+    "Exit with code 1 if health score is below threshold (use with --json)",
+    parseInt
+  ).action(async (targetPath, options) => {
+    const rootDir = path15.resolve(targetPath);
+    if (!fs17.existsSync(rootDir)) {
+      console.error(`Error: "${rootDir}" does not exist.`);
+      process.exit(1);
+    }
+    if (!fs17.statSync(rootDir).isDirectory()) {
+      console.error(`Error: "${rootDir}" is not a directory.`);
+      process.exit(1);
+    }
+    if (options.history !== void 0) {
+      const history = loadHistory(rootDir);
+      if (!history) {
+        console.log(
+          chalk8.yellow("\n\u26A0 No health history found.\n")
+        );
+        console.log(
+          chalk8.dim("Run with --track flag to start tracking health over time.\n")
+        );
+        process.exit(0);
+      }
+      const days = typeof options.history === "number" ? options.history : 30;
+      console.log(renderHistoryReport(history, days));
+      process.exit(0);
+    }
+    const config = loadConfig(rootDir);
+    const aiConfig = {
+      enabled: options.aiRoasts || config.ai?.enabled || false,
+      apiKey: config.ai?.apiKey,
+      model: config.ai?.model,
+      maxTokens: config.ai?.maxTokens,
+      temperature: config.ai?.temperature,
+      cacheEnabled: config.ai?.cacheEnabled,
+      cachePath: config.ai?.cachePath
+    };
+    const runScanners = async (scanRootDir) => {
+      const allFindings = [];
+      const fileScanner = new FileScanner();
+      const fileResult = await fileScanner.scan(scanRootDir);
+      allFindings.push(...fileResult.findings);
+      const todoScanner = new TodoScanner();
+      const todoResult = await todoScanner.scan(scanRootDir);
+      allFindings.push(...todoResult.findings);
+      const depScanner = new DependencyScanner();
+      const depResult = await depScanner.scan(scanRootDir);
+      allFindings.push(...depResult.findings);
+      const circularScanner = new CircularDependencyScanner();
+      const circularResult = await circularScanner.scan(scanRootDir);
+      allFindings.push(...circularResult.findings);
+      const structureScanner = new StructureScanner();
+      const structureResult = await structureScanner.scan(scanRootDir);
+      allFindings.push(...structureResult.findings);
+      const complexityScanner = new ComplexityScanner();
+      const complexityResult = await complexityScanner.scan(scanRootDir);
+      allFindings.push(...complexityResult.findings);
+      const duplicateScanner = new DuplicateScanner();
+      const duplicateResult = await duplicateScanner.scan(scanRootDir);
+      allFindings.push(...duplicateResult.findings);
+      const deadExportScanner = new DeadExportScanner();
+      const deadExportResult = await deadExportScanner.scan(scanRootDir);
+      allFindings.push(...deadExportResult.findings);
+      const typeSafetyScanner = new TypeSafetyScanner();
+      const typeSafetyResult = await typeSafetyScanner.scan(scanRootDir);
+      allFindings.push(...typeSafetyResult.findings);
+      const testCoverageScanner = new TestCoverageScanner();
+      const testCoverageResult = await testCoverageScanner.scan(scanRootDir);
+      allFindings.push(...testCoverageResult.findings);
+      const gitInsightsScanner = new GitInsightsScanner();
+      const gitInsightsResult = await gitInsightsScanner.scan(scanRootDir);
+      allFindings.push(...gitInsightsResult.findings);
+      const securityScanner = new SecurityScanner();
+      const securityResult = await securityScanner.scan(scanRootDir);
+      allFindings.push(...securityResult.findings);
+      const frameworkScanner = new FrameworkScanner();
+      const frameworkResult = await frameworkScanner.scan(scanRootDir);
+      allFindings.push(...frameworkResult.findings);
+      const health = calculateHealth(allFindings);
+      return { findings: allFindings, health };
+    };
+    if (options.compare) {
+      try {
+        const comparison = await compareWithBranch(rootDir, options.compare, runScanners);
+        renderComparison(comparison, options.compare);
+      } catch (error) {
+        console.error(`
+Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+      return;
+    }
+    if (options.watch) {
+      const scanners = [
+        new FileScanner(),
+        new TodoScanner(),
+        new DependencyScanner(),
+        new CircularDependencyScanner(),
+        new StructureScanner(),
+        new ComplexityScanner(),
+        new DuplicateScanner(),
+        new DeadExportScanner(),
+        new TypeSafetyScanner(),
+        new TestCoverageScanner(),
+        new GitInsightsScanner(),
+        new SecurityScanner(),
+        new FrameworkScanner(),
+        new TypeSafetyScanner()
+      ];
+      const projectName = getProjectName(rootDir);
+      let isFirstRun = true;
+      await startWatchMode(rootDir, scanners, async (findings, health, delta, stats) => {
+        if (isFirstRun) {
+          const roasts = await generateRoasts(findings, aiConfig, rootDir);
+          const verdict = generateVerdict(health);
+          const fixes = options.fix ? generateFixSuggestions(findings) : void 0;
+          const report = {
+            projectName,
+            stats,
+            health,
+            findings,
+            roasts,
+            verdict,
+            fixes
+          };
+          console.log(renderReport(report, { ascii: options.ascii }));
+          isFirstRun = false;
+        } else {
+          const findingCounts = {
+            critical: findings.filter((f) => f.severity === "critical").length,
+            warning: findings.filter((f) => f.severity === "warning").length,
+            info: findings.filter((f) => f.severity === "info").length
+          };
+          renderWatchSummary(health, delta, findingCounts);
+        }
+      });
+      return;
+    }
+    console.log("");
+    const spinner = ora({
+      text: "Scanning your codebase...",
+      spinner: "dots"
+    }).start();
+    try {
+      const allFindings = [];
+      const fileScanner = new FileScanner();
+      const fileResult = await fileScanner.scan(rootDir);
+      allFindings.push(...fileResult.findings);
+      const stats = fileResult.stats;
+      spinner.text = "Detecting TODOs...";
+      const todoScanner = new TodoScanner();
+      const todoResult = await todoScanner.scan(rootDir);
+      allFindings.push(...todoResult.findings);
+      spinner.text = "Analyzing dependencies...";
+      const depScanner = new DependencyScanner();
+      const depResult = await depScanner.scan(rootDir);
+      allFindings.push(...depResult.findings);
+      spinner.text = "Checking for circular dependencies...";
+      const circularScanner = new CircularDependencyScanner();
+      const circularResult = await circularScanner.scan(rootDir);
+      allFindings.push(...circularResult.findings);
+      spinner.text = "Analyzing project structure...";
+      const structureScanner = new StructureScanner();
+      const structureResult = await structureScanner.scan(rootDir);
+      allFindings.push(...structureResult.findings);
+      spinner.text = "Calculating code complexity...";
+      const complexityScanner = new ComplexityScanner();
+      const complexityResult = await complexityScanner.scan(rootDir);
+      allFindings.push(...complexityResult.findings);
+      spinner.text = "Detecting duplicate code...";
+      const duplicateScanner = new DuplicateScanner();
+      const duplicateResult = await duplicateScanner.scan(rootDir);
+      allFindings.push(...duplicateResult.findings);
+      spinner.text = "Finding dead exports...";
+      const deadExportScanner = new DeadExportScanner();
+      const deadExportResult = await deadExportScanner.scan(rootDir);
+      allFindings.push(...deadExportResult.findings);
+      spinner.text = "Auditing type safety...";
+      const typeSafetyScanner = new TypeSafetyScanner();
+      const typeSafetyResult = await typeSafetyScanner.scan(rootDir);
+      allFindings.push(...typeSafetyResult.findings);
+      spinner.text = "Checking test coverage...";
+      const testCoverageScanner = new TestCoverageScanner();
+      const testCoverageResult = await testCoverageScanner.scan(rootDir);
+      allFindings.push(...testCoverageResult.findings);
+      spinner.text = "Analyzing git history...";
+      const gitInsightsScanner = new GitInsightsScanner();
+      const gitInsightsResult = await gitInsightsScanner.scan(rootDir);
+      allFindings.push(...gitInsightsResult.findings);
+      spinner.text = "Scanning security surface...";
+      const securityScanner = new SecurityScanner();
+      const securityResult = await securityScanner.scan(rootDir);
+      allFindings.push(...securityResult.findings);
+      spinner.text = "Checking framework best practices...";
+      const frameworkScanner = new FrameworkScanner();
+      const frameworkResult = await frameworkScanner.scan(rootDir);
+      allFindings.push(...frameworkResult.findings);
+      const detectedLanguages = detectProjectLanguage(rootDir, fs17);
+      if (detectedLanguages.includes("python")) {
+        spinner.text = "Analyzing Python complexity...";
+        const pyComplexityScanner = new PythonComplexityScanner();
+        const pyComplexityResult = await pyComplexityScanner.scan(rootDir);
+        allFindings.push(...pyComplexityResult.findings);
+        spinner.text = "Checking Python type hints...";
+        const pyTypeHintsScanner = new PythonTypeHintsScanner();
+        const pyTypeHintsResult = await pyTypeHintsScanner.scan(rootDir);
+        allFindings.push(...pyTypeHintsResult.findings);
+        spinner.text = "Analyzing Python imports...";
+        const pyImportsScanner = new PythonImportsScanner();
+        const pyImportsResult = await pyImportsScanner.scan(rootDir);
+        allFindings.push(...pyImportsResult.findings);
+      }
+      spinner.stop();
+      const health = calculateHealth(allFindings);
+      const roasts = await generateRoasts(allFindings, aiConfig, rootDir);
+      const verdict = generateVerdict(health);
+      const projectName = getProjectName(rootDir);
+      const fixes = options.fix ? generateFixSuggestions(allFindings) : void 0;
+      const report = {
+        projectName,
+        stats,
+        health,
+        findings: allFindings,
+        roasts,
+        verdict,
+        fixes
+      };
+      if (options.track) {
+        const snapshot = createSnapshot(health, allFindings, rootDir);
+        const history = addSnapshot(rootDir, projectName, snapshot);
+        console.log(chalk8.green("\n\u2713 Health snapshot saved to .roast-history.json"));
+        const trendSummary = renderTrendSummary(history, 7);
+        if (trendSummary) {
+          console.log(chalk8.dim("  Last 7 days: ") + trendSummary);
+        }
+        console.log();
+      }
+      if (options.interactive) {
+        console.log(renderReport(report, { ascii: options.ascii }));
+        await runInteractiveMode(report, rootDir, options.dryRun || false);
+        return;
+      }
+      if (options.json) {
+        console.log(renderJsonReport(report));
+        if (options.threshold !== void 0 && report.health.score < options.threshold) {
+          process.exit(1);
+        }
+      } else if (options.markdown || options.markdownFile) {
+        const markdownOutput = renderMarkdownReport(report);
+        if (options.markdownFile) {
+          try {
+            const outputPath = validateOutputPath(rootDir, ".roast-report.md");
+            fs17.writeFileSync(outputPath, markdownOutput, "utf-8");
+            console.log(`
+\u2713 Markdown report saved to ${outputPath}
+`);
+          } catch (error) {
+            console.error(`Failed to save markdown report: ${sanitizeError(error)}`);
+            process.exit(1);
+          }
+        } else {
+          console.log(markdownOutput);
+        }
+      } else {
+        console.log(renderReport(report, { ascii: options.ascii }));
+      }
+      if (options.badge) {
+        const badgeSvg = generateBadgeSvg(health);
+        saveBadge(badgeSvg, rootDir);
+      }
+    } catch (error) {
+      spinner.stop();
+      console.error("Analysis failed:", sanitizeError(error));
+      if (process.env.DEBUG) {
+        try {
+          const debugPath = path15.join(rootDir, ".roast-debug.log");
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          const errorStr = error instanceof Error ? error.stack : String(error);
+          fs17.appendFileSync(debugPath, `${timestamp}: ${errorStr}
+`);
+          console.log(`Debug info saved to ${debugPath}`);
+        } catch {
+        }
+      }
+      process.exit(1);
+    }
+  });
+  return program2;
+}
+function getProjectName(rootDir) {
+  const pkgPath = path15.join(rootDir, "package.json");
+  try {
+    const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+    return pkg.name || path15.basename(rootDir);
+  } catch {
+    return path15.basename(rootDir);
+  }
+}
+
+// src/index.ts
+var program = createCli();
+program.parse();