roast-my-codebase 1.0.0 → 1.1.2

package/dist/index.js

@@ -9,7 +9,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/cli/index.ts
 import { Command } from "commander";
 import path15 from "path";
-import fs17 from "fs";
+import fs21 from "fs";
 import { fileURLToPath } from "url";
 import ora from "ora";
 import chalk8 from "chalk";
@@ -161,7 +161,7 @@ var FileScanner = class {
     let devDependencies = 0;
     try {
       const pkg = await import("fs").then(
-        (fs18) => JSON.parse(fs18.readFileSync(pkgPath, "utf-8"))
+        (fs22) => JSON.parse(fs22.readFileSync(pkgPath, "utf-8"))
       );
       dependencies = Object.keys(pkg.dependencies || {}).length;
       devDependencies = Object.keys(pkg.devDependencies || {}).length;
@@ -1728,86 +1728,1237 @@ var FrameworkScanner = class {
         }
       }
     }
-    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;
+    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*\([^)]{0,500}\)(?:\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 };
+  }
+};
+var PythonDocstringScanner = class {
+  constructor() {
+    this.name = "python-docstrings";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/*test*/**", "**/tests/**", "**/setup.py"],
+      absolute: true
+    });
+    let totalPublicFunctions = 0;
+    let undocumentedFunctions = 0;
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const funcMatch = line.match(/^\s*def\s+([a-zA-Z]\w*)\s*\(/);
+          if (funcMatch && !funcMatch[1].startsWith("_")) {
+            totalPublicFunctions++;
+            const nextNonEmpty = this.getNextNonEmptyLine(lines, i + 1);
+            if (!nextNonEmpty || !nextNonEmpty.includes('"""') && !nextNonEmpty.includes("'''")) {
+              undocumentedFunctions++;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    if (totalPublicFunctions > 0) {
+      const undocPercent = Math.round(undocumentedFunctions / totalPublicFunctions * 100);
+      if (undocPercent > 70) {
+        findings.push({
+          id: "py-docstrings-low",
+          severity: "warning",
+          category: "python-docstrings",
+          message: `${undocPercent}% of public functions lack docstrings`,
+          detail: `${undocumentedFunctions} of ${totalPublicFunctions} public functions undocumented`
+        });
+      } else if (undocPercent > 40) {
+        findings.push({
+          id: "py-docstrings-moderate",
+          severity: "info",
+          category: "python-docstrings",
+          message: `${undocPercent}% of public functions lack docstrings`,
+          detail: `${undocumentedFunctions} of ${totalPublicFunctions} public functions undocumented`
+        });
+      }
+    }
+    return {
+      findings,
+      stats: { totalPublicFunctions, undocumentedFunctions }
+    };
+  }
+  getNextNonEmptyLine(lines, startIdx) {
+    for (let i = startIdx; i < Math.min(startIdx + 3, lines.length); i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.length > 0) return trimmed;
+    }
+    return null;
+  }
+};
+var PythonCodeSmellScanner = class {
+  constructor() {
+    this.name = "python-code-smells";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/*test*/**", "**/tests/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const bareExcepts = content.match(/^\s*except\s*:/gm);
+        if (bareExcepts && bareExcepts.length > 0) {
+          findings.push({
+            id: `py-bare-except-${rel}`,
+            severity: "warning",
+            category: "python-smells",
+            message: `${rel} uses bare except: ${bareExcepts.length} time(s)`,
+            file: rel,
+            detail: "Bare except catches SystemExit, KeyboardInterrupt \u2014 use except Exception:"
+          });
+        }
+        const mutableDefaults = content.match(
+          /def\s+\w+\s*\([^)]*(?:=\s*(?:\[\]|\{\}|\bset\(\)))[^)]*\)/g
+        );
+        if (mutableDefaults && mutableDefaults.length > 0) {
+          findings.push({
+            id: `py-mutable-default-${rel}`,
+            severity: "warning",
+            category: "python-smells",
+            message: `${rel} has ${mutableDefaults.length} mutable default argument(s)`,
+            file: rel,
+            detail: "Mutable defaults are shared across calls \u2014 use None and create inside function"
+          });
+        }
+        const globals = content.match(/^\s*global\s+\w+/gm);
+        if (globals && globals.length >= 3) {
+          findings.push({
+            id: `py-globals-${rel}`,
+            severity: "warning",
+            category: "python-smells",
+            message: `${rel} uses global statement ${globals.length} times`,
+            file: rel,
+            detail: "Excessive globals indicate poor encapsulation"
+          });
+        }
+        const lines = content.split("\n");
+        let longLineCount = 0;
+        for (const line of lines) {
+          if (line.length > 120 && !line.trim().startsWith("#") && !line.includes("http")) {
+            longLineCount++;
+          }
+        }
+        if (longLineCount >= 20) {
+          findings.push({
+            id: `py-long-lines-${rel}`,
+            severity: "info",
+            category: "python-smells",
+            message: `${rel} has ${longLineCount} lines exceeding 120 characters`,
+            file: rel,
+            detail: "Consider reformatting with black or ruff"
+          });
+        }
+        let maxDepth = 0;
+        let currentDepth = 0;
+        for (const line of lines) {
+          if (line.match(/^\s*def\s+/)) {
+            const indent = (line.match(/^\s*/)?.[0].length || 0) / 4;
+            currentDepth = indent;
+            if (currentDepth > maxDepth) maxDepth = currentDepth;
+          }
+        }
+        if (maxDepth >= 3) {
+          findings.push({
+            id: `py-nested-functions-${rel}`,
+            severity: "info",
+            category: "python-smells",
+            message: `${rel} has functions nested ${maxDepth} levels deep`,
+            file: rel,
+            detail: "Deeply nested functions are hard to test and reason about"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+var PythonSecurityScanner = class {
+  constructor() {
+    this.name = "python-security";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/*test*/**", "**/tests/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const evalExec = content.match(/\b(?:eval|exec)\s*\(/g);
+        if (evalExec && evalExec.length > 0) {
+          findings.push({
+            id: `py-eval-${rel}`,
+            severity: "critical",
+            category: "python-security",
+            message: `${rel} uses eval()/exec() ${evalExec.length} time(s)`,
+            file: rel,
+            detail: "eval/exec can execute arbitrary code \u2014 use ast.literal_eval for data"
+          });
+        }
+        if (/\bpickle\.(?:load|loads)\s*\(/.test(content)) {
+          findings.push({
+            id: `py-pickle-${rel}`,
+            severity: "warning",
+            category: "python-security",
+            message: `${rel} uses pickle deserialization`,
+            file: rel,
+            detail: "Pickle can execute arbitrary code during deserialization \u2014 use json or msgpack"
+          });
+        }
+        if (/subprocess\.\w+\([^)]*shell\s*=\s*True/s.test(content)) {
+          findings.push({
+            id: `py-shell-true-${rel}`,
+            severity: "warning",
+            category: "python-security",
+            message: `${rel} uses subprocess with shell=True`,
+            file: rel,
+            detail: "shell=True enables shell injection \u2014 pass args as a list instead"
+          });
+        }
+        const secretPatterns = content.match(
+          /(?:password|passwd|secret|api_key|token)\s*=\s*['"][^'"]{8,}['"]/gi
+        );
+        if (secretPatterns && secretPatterns.length > 0) {
+          findings.push({
+            id: `py-hardcoded-secret-${rel}`,
+            severity: "critical",
+            category: "python-security",
+            message: `${rel} may have hardcoded secrets (${secretPatterns.length} found)`,
+            file: rel,
+            detail: "Use environment variables or a secrets manager"
+          });
+        }
+        const sqlInjection = content.match(
+          /(?:execute|cursor\.execute)\s*\(\s*(?:f['"]|['"].*%|['"].*\.format)/g
+        );
+        if (sqlInjection && sqlInjection.length > 0) {
+          findings.push({
+            id: `py-sql-injection-${rel}`,
+            severity: "critical",
+            category: "python-security",
+            message: `${rel} has potential SQL injection (${sqlInjection.length} found)`,
+            file: rel,
+            detail: "Use parameterized queries instead of string formatting"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+var PythonClassDesignScanner = class {
+  constructor() {
+    this.name = "python-class-design";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg13(["**/*.py"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/*test*/**", "**/tests/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs10.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const lines = content.split("\n");
+        const classes = this.extractClasses(lines);
+        for (const cls of classes) {
+          if (cls.methodCount >= 20) {
+            findings.push({
+              id: `py-god-class-${rel}-${cls.name}`,
+              severity: "warning",
+              category: "python-design",
+              message: `Class ${cls.name} in ${rel} has ${cls.methodCount} methods`,
+              file: rel,
+              detail: "Consider splitting into smaller, focused classes"
+            });
+          }
+          if (cls.methodCount === 0 && cls.lineCount > 3) {
+            findings.push({
+              id: `py-dataclass-candidate-${rel}-${cls.name}`,
+              severity: "info",
+              category: "python-design",
+              message: `Class ${cls.name} in ${rel} has no methods \u2014 consider @dataclass`,
+              file: rel
+            });
+          }
+        }
+        const deepInheritance = content.match(
+          // eslint-disable-next-line security/detect-unsafe-regex
+          /class\s+\w+\s*\(\s*\w+(?:\.\w+)*(?:\s*,\s*\w+(?:\.\w+)*){3,}\s*\)/g
+        );
+        if (deepInheritance) {
+          findings.push({
+            id: `py-multi-inherit-${rel}`,
+            severity: "info",
+            category: "python-design",
+            message: `${rel} has classes with 4+ parent classes`,
+            file: rel,
+            detail: "Deep multiple inheritance creates complex MRO \u2014 prefer composition"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+  extractClasses(lines) {
+    const classes = [];
+    for (let i = 0; i < lines.length; i++) {
+      const classMatch = lines[i].match(/^class\s+(\w+)/);
+      if (classMatch) {
+        const name = classMatch[1];
+        const classIndent = lines[i].match(/^\s*/)?.[0].length || 0;
+        let methodCount = 0;
+        let lineCount = 0;
+        for (let j = i + 1; j < lines.length; j++) {
+          const line = lines[j];
+          if (line.trim() === "") {
+            lineCount++;
+            continue;
+          }
+          const indent = line.match(/^\s*/)?.[0].length || 0;
+          if (indent <= classIndent && line.trim().length > 0) break;
+          lineCount++;
+          if (line.match(/^\s+def\s+/)) methodCount++;
+        }
+        classes.push({ name, methodCount, lineCount });
+      }
+    }
+    return classes;
+  }
+};
+
+// src/scanners/go.ts
+import fg14 from "fast-glob";
+import fs11 from "fs";
+var GoComplexityScanner = class {
+  constructor() {
+    this.name = "go-complexity";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg14(["**/*.go"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/vendor/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs11.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: `go-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: `go-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(/^func\s+(?:\([^)]{0,200}\)\s+)?(\w+)\s*\(/);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        let braceCount = 0;
+        let body = "";
+        let started = false;
+        for (let j = i; j < lines.length; j++) {
+          body += lines[j] + "\n";
+          for (const ch of lines[j]) {
+            if (ch === "{") {
+              braceCount++;
+              started = true;
+            }
+            if (ch === "}") {
+              braceCount--;
+            }
+          }
+          if (started && braceCount <= 0) break;
+        }
+        functions.push({ name, body });
+      }
+    }
+    return functions;
+  }
+  calculateComplexity(code) {
+    let complexity = 1;
+    const patterns = [
+      /\bif\b/g,
+      /\belse if\b/g,
+      /\bfor\b/g,
+      /\bcase\b/g,
+      /\b&&\b/g,
+      /\b\|\|\b/g,
+      /\bselect\b/g
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) complexity += matches.length;
+    }
+    return complexity;
+  }
+};
+var GoErrorHandlingScanner = class {
+  constructor() {
+    this.name = "go-error-handling";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg14(["**/*.go"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/vendor/**", "**/*_test.go"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs11.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const ignoredErrors = content.match(/\b_\s*=\s*\w+\([^)]*\)/g);
+        const blankErrCount = ignoredErrors ? ignoredErrors.length : 0;
+        if (blankErrCount >= 5) {
+          findings.push({
+            id: `go-ignored-errors-${rel}`,
+            severity: "warning",
+            category: "go-error-handling",
+            message: `${rel} ignores ${blankErrCount} error returns with blank identifier`,
+            file: rel,
+            detail: "Ignored errors can mask bugs in production"
+          });
+        } else if (blankErrCount >= 3) {
+          findings.push({
+            id: `go-ignored-errors-${rel}`,
+            severity: "info",
+            category: "go-error-handling",
+            message: `${rel} ignores ${blankErrCount} error returns`,
+            file: rel
+          });
+        }
+        const panicCalls = content.match(/\bpanic\s*\(/g);
+        if (panicCalls && panicCalls.length > 0) {
+          findings.push({
+            id: `go-panic-${rel}`,
+            severity: "warning",
+            category: "go-error-handling",
+            message: `${rel} uses panic() ${panicCalls.length} time(s)`,
+            file: rel,
+            detail: "Prefer returning errors over panic in library code"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+var GoLintScanner = class {
+  constructor() {
+    this.name = "go-lint";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg14(["**/*.go"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/vendor/**"],
+      absolute: true
+    });
+    let totalExported = 0;
+    let undocumentedExported = 0;
+    for (const file of files) {
+      try {
+        const content = fs11.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const exportedMatch = line.match(
+            /^(?:func|type|var|const)\s+([A-Z]\w*)/
+          );
+          if (exportedMatch) {
+            totalExported++;
+            const prevLine = i > 0 ? lines[i - 1].trim() : "";
+            if (!prevLine.startsWith("//")) {
+              undocumentedExported++;
+            }
+          }
+        }
+        const initFuncs = content.match(/^func\s+init\s*\(\s*\)/gm);
+        if (initFuncs && initFuncs.length > 1) {
+          findings.push({
+            id: `go-multi-init-${rel}`,
+            severity: "info",
+            category: "go-lint",
+            message: `${rel} has ${initFuncs.length} init() functions`,
+            file: rel,
+            detail: "Multiple init() functions can make initialization order unclear"
+          });
+        }
+      } catch {
+      }
+    }
+    if (totalExported > 0) {
+      const undocPercent = Math.round(undocumentedExported / totalExported * 100);
+      if (undocPercent > 50) {
+        findings.push({
+          id: "go-undocumented-exports",
+          severity: "warning",
+          category: "go-lint",
+          message: `${undocPercent}% of exported symbols lack documentation comments`,
+          detail: `${undocumentedExported} of ${totalExported} exported symbols`
+        });
+      }
+    }
+    return { findings };
+  }
+};
+
+// src/scanners/rust.ts
+import fg15 from "fast-glob";
+import fs12 from "fs";
+var RustComplexityScanner = class {
+  constructor() {
+    this.name = "rust-complexity";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg15(["**/*.rs"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs12.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: `rust-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: `rust-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*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        let braceCount = 0;
+        let body = "";
+        let started = false;
+        for (let j = i; j < lines.length; j++) {
+          body += lines[j] + "\n";
+          for (const ch of lines[j]) {
+            if (ch === "{") {
+              braceCount++;
+              started = true;
+            }
+            if (ch === "}") {
+              braceCount--;
+            }
+          }
+          if (started && braceCount <= 0) break;
+        }
+        functions.push({ name, body });
+      }
+    }
+    return functions;
+  }
+  calculateComplexity(code) {
+    let complexity = 1;
+    const patterns = [
+      /\bif\b/g,
+      /\belse if\b/g,
+      /\bfor\b/g,
+      /\bwhile\b/g,
+      /\bloop\b/g,
+      /\bmatch\b/g,
+      /=>/g,
+      /&&/g,
+      /\|\|/g,
+      /\?/g
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) complexity += matches.length;
+    }
+    return complexity;
+  }
+};
+var RustUnsafeScanner = class {
+  constructor() {
+    this.name = "rust-unsafe";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg15(["**/*.rs"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**"],
+      absolute: true
+    });
+    let totalUnsafeBlocks = 0;
+    for (const file of files) {
+      try {
+        const content = fs12.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const unsafeBlocks = content.match(/\bunsafe\s*\{/g);
+        const unsafeFns = content.match(/\bunsafe\s+fn\b/g);
+        const fileUnsafe = (unsafeBlocks?.length || 0) + (unsafeFns?.length || 0);
+        totalUnsafeBlocks += fileUnsafe;
+        if (fileUnsafe >= 5) {
+          findings.push({
+            id: `rust-unsafe-heavy-${rel}`,
+            severity: "warning",
+            category: "rust-unsafe",
+            message: `${rel} has ${fileUnsafe} unsafe blocks/functions`,
+            file: rel,
+            detail: "Heavy unsafe usage increases risk of memory safety issues"
+          });
+        }
+      } catch {
+      }
+    }
+    if (totalUnsafeBlocks >= 20) {
+      findings.push({
+        id: "rust-unsafe-total",
+        severity: "warning",
+        category: "rust-unsafe",
+        message: `Project has ${totalUnsafeBlocks} total unsafe blocks/functions`,
+        detail: "Consider wrapping unsafe code in safe abstractions"
+      });
+    }
+    return { findings };
+  }
+};
+var RustClippyHintsScanner = class {
+  constructor() {
+    this.name = "rust-clippy-hints";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg15(["**/*.rs"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs12.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const unwraps = content.match(/\.unwrap\(\)/g);
+        if (unwraps && unwraps.length >= 10) {
+          findings.push({
+            id: `rust-unwrap-heavy-${rel}`,
+            severity: "warning",
+            category: "rust-clippy",
+            message: `${rel} uses .unwrap() ${unwraps.length} times`,
+            file: rel,
+            detail: "Prefer .expect(), ?, or proper error handling over .unwrap()"
+          });
+        }
+        const clones = content.match(/\.clone\(\)/g);
+        if (clones && clones.length >= 15) {
+          findings.push({
+            id: `rust-clone-heavy-${rel}`,
+            severity: "info",
+            category: "rust-clippy",
+            message: `${rel} uses .clone() ${clones.length} times`,
+            file: rel,
+            detail: "Excessive cloning may indicate ownership issues"
+          });
+        }
+        const deadCodeAllows = content.match(/#\[allow\(dead_code\)]/g);
+        if (deadCodeAllows && deadCodeAllows.length >= 3) {
+          findings.push({
+            id: `rust-dead-code-${rel}`,
+            severity: "info",
+            category: "rust-clippy",
+            message: `${rel} suppresses dead_code warnings ${deadCodeAllows.length} times`,
+            file: rel,
+            detail: "Consider removing unused code instead of suppressing warnings"
+          });
+        }
+        const todos = content.match(/\b(?:todo|unimplemented)!\s*\(/g);
+        if (todos && todos.length > 0) {
+          findings.push({
+            id: `rust-todo-macro-${rel}`,
+            severity: "info",
+            category: "rust-clippy",
+            message: `${rel} has ${todos.length} todo!()/unimplemented!() macro(s)`,
+            file: rel,
+            detail: "These will panic at runtime if reached"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+
+// src/scanners/java.ts
+import fg16 from "fast-glob";
+import fs13 from "fs";
+var JavaComplexityScanner = class {
+  constructor() {
+    this.name = "java-complexity";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg16(["**/*.java"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**", "**/build/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs13.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const methods = this.extractMethods(content);
+        for (const method of methods) {
+          const complexity = this.calculateComplexity(method.body);
+          if (complexity >= 20) {
+            findings.push({
+              id: `java-complexity-${rel}-${method.name}`,
+              severity: "critical",
+              category: "complexity",
+              message: `Method ${method.name} has cyclomatic complexity of ${complexity}`,
+              file: rel,
+              detail: `${complexity} decision points`
+            });
+          } else if (complexity >= 10) {
+            findings.push({
+              id: `java-complexity-${rel}-${method.name}`,
+              severity: "warning",
+              category: "complexity",
+              message: `Method ${method.name} has cyclomatic complexity of ${complexity}`,
+              file: rel,
+              detail: `${complexity} decision points`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+  extractMethods(content) {
+    const methods = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const methodMatch = line.match(
+        // eslint-disable-next-line security/detect-unsafe-regex
+        /^\s*(?:public|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:\w+(?:<[^>]{0,100}>)?)\s+(\w+)\s*\(/
+      );
+      if (methodMatch && !line.includes("class ") && !line.includes("interface ")) {
+        const name = methodMatch[1];
+        let braceCount = 0;
+        let body = "";
+        let started = false;
+        for (let j = i; j < lines.length; j++) {
+          body += lines[j] + "\n";
+          for (const ch of lines[j]) {
+            if (ch === "{") {
+              braceCount++;
+              started = true;
+            }
+            if (ch === "}") {
+              braceCount--;
+            }
+          }
+          if (started && braceCount <= 0) break;
+        }
+        methods.push({ name, body });
+      }
+    }
+    return methods;
+  }
+  calculateComplexity(code) {
+    let complexity = 1;
+    const patterns = [
+      /\bif\s*\(/g,
+      /\belse if\s*\(/g,
+      /\bfor\s*\(/g,
+      /\bwhile\s*\(/g,
+      /\bcase\s+/g,
+      /\bcatch\s*\(/g,
+      /&&/g,
+      /\|\|/g,
+      /\?[^?]/g
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) complexity += matches.length;
+    }
+    return complexity;
+  }
+};
+var JavaCodeSmellScanner = class {
+  constructor() {
+    this.name = "java-code-smells";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg16(["**/*.java"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**", "**/build/**", "**/*Test.java", "**/*Tests.java"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs13.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const methodCount = (content.match(
+          // eslint-disable-next-line security/detect-unsafe-regex
+          /^\s*(?:public|private|protected)\s+(?:static\s+)?(?:\w+)\s+\w+\s*\(/gm
+        ) || []).length;
+        if (methodCount >= 30) {
+          findings.push({
+            id: `java-god-class-${rel}`,
+            severity: "warning",
+            category: "java-smells",
+            message: `${rel} has ${methodCount} methods \u2014 possible God class`,
+            file: rel,
+            detail: "Consider splitting into smaller, focused classes"
+          });
+        }
+        const rawTypes = content.match(/\b(?:List|Map|Set|Collection|Iterator)\s+\w+/g);
+        if (rawTypes && rawTypes.length >= 3) {
+          findings.push({
+            id: `java-raw-types-${rel}`,
+            severity: "info",
+            category: "java-smells",
+            message: `${rel} uses raw types ${rawTypes.length} times`,
+            file: rel,
+            detail: "Use parameterized types for type safety (e.g., List<String>)"
+          });
+        }
+        const suppressions = content.match(/@SuppressWarnings/g);
+        if (suppressions && suppressions.length >= 3) {
+          findings.push({
+            id: `java-suppressions-${rel}`,
+            severity: "info",
+            category: "java-smells",
+            message: `${rel} suppresses ${suppressions.length} warnings`,
+            file: rel,
+            detail: "Fix warnings instead of suppressing them"
+          });
+        }
+        const sysout = content.match(/System\.(out|err)\.(println|print|printf)\s*\(/g);
+        if (sysout && sysout.length >= 3) {
+          findings.push({
+            id: `java-sysout-${rel}`,
+            severity: "info",
+            category: "java-smells",
+            message: `${rel} uses System.out/err ${sysout.length} times`,
+            file: rel,
+            detail: "Use a logging framework (SLF4J, Log4j) instead"
+          });
+        }
+        const emptyCatch = content.match(/catch\s*\([^)]*\)\s*\{\s*\}/g);
+        if (emptyCatch && emptyCatch.length > 0) {
+          findings.push({
+            id: `java-empty-catch-${rel}`,
+            severity: "warning",
+            category: "java-smells",
+            message: `${rel} has ${emptyCatch.length} empty catch block(s)`,
+            file: rel,
+            detail: "Empty catch blocks silently swallow exceptions"
+          });
+        }
+      } catch {
+      }
+    }
+    return { findings };
+  }
+};
+var JavaNamingScanner = class {
+  constructor() {
+    this.name = "java-naming";
+  }
+  async scan(rootDir) {
+    const findings = [];
+    const files = await fg16(["**/*.java"], {
+      cwd: rootDir,
+      ignore: [...IGNORE_PATTERNS, "**/target/**", "**/build/**"],
+      absolute: true
+    });
+    for (const file of files) {
+      try {
+        const content = fs13.readFileSync(file, "utf-8");
+        const rel = relativePath(rootDir, file);
+        const fileName = rel.split("/").pop() || "";
+        const classMatch = content.match(/public\s+(?:class|interface|enum)\s+(\w+)/);
+        if (classMatch) {
+          const className = classMatch[1];
+          const expectedFile = `${className}.java`;
+          if (fileName !== expectedFile) {
+            findings.push({
+              id: `java-naming-mismatch-${rel}`,
+              severity: "warning",
+              category: "java-naming",
+              message: `Class ${className} doesn't match file name ${fileName}`,
+              file: rel
+            });
           }
         }
+        const badConstants = content.match(
+          /\bstatic\s+final\s+\w+\s+([a-z]\w*)\s*=/g
+        );
+        if (badConstants && badConstants.length >= 3) {
+          findings.push({
+            id: `java-constant-naming-${rel}`,
+            severity: "info",
+            category: "java-naming",
+            message: `${rel} has ${badConstants.length} constants not in UPPER_SNAKE_CASE`,
+            file: rel
+          });
+        }
+      } catch {
       }
     }
-    return {
-      findings,
-      stats: { isNextJS, isReact }
-    };
+    return { findings };
   }
 };
 
-// src/scanners/python.ts
-import fg13 from "fast-glob";
-import fs10 from "fs";
-var PythonComplexityScanner = class {
+// src/scanners/csharp.ts
+import fg17 from "fast-glob";
+import fs14 from "fs";
+var CSharpComplexityScanner = class {
   constructor() {
-    this.name = "python-complexity";
+    this.name = "csharp-complexity";
   }
   async scan(rootDir) {
     const findings = [];
-    const files = await fg13(["**/*.py"], {
+    const files = await fg17(["**/*.cs"], {
       cwd: rootDir,
-      ignore: IGNORE_PATTERNS,
+      ignore: [...IGNORE_PATTERNS, "**/bin/**", "**/obj/**"],
       absolute: true
     });
     for (const file of files) {
       try {
-        const content = fs10.readFileSync(file, "utf-8");
+        const content = fs14.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);
+        const methods = this.extractMethods(content);
+        for (const method of methods) {
+          const complexity = this.calculateComplexity(method.body);
           if (complexity >= 20) {
             findings.push({
-              id: `py-complexity-${rel}-${func.name}`,
+              id: `csharp-complexity-${rel}-${method.name}`,
               severity: "critical",
               category: "complexity",
-              message: `Function ${func.name} has cyclomatic complexity of ${complexity}`,
+              message: `Method ${method.name} has cyclomatic complexity of ${complexity}`,
               file: rel,
               detail: `${complexity} decision points`
             });
           } else if (complexity >= 10) {
             findings.push({
-              id: `py-complexity-${rel}-${func.name}`,
+              id: `csharp-complexity-${rel}-${method.name}`,
               severity: "warning",
               category: "complexity",
-              message: `Function ${func.name} has cyclomatic complexity of ${complexity}`,
+              message: `Method ${method.name} has cyclomatic complexity of ${complexity}`,
               file: rel,
               detail: `${complexity} decision points`
             });
@@ -1818,146 +2969,174 @@ var PythonComplexityScanner = class {
     }
     return { findings };
   }
-  extractFunctions(content) {
-    const functions = [];
+  extractMethods(content) {
+    const methods = [];
     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;
+      const methodMatch = line.match(
+        // eslint-disable-next-line security/detect-unsafe-regex
+        /^\s*(?:public|private|protected|internal)?\s*(?:static\s+)?(?:async\s+)?(?:virtual\s+)?(?:override\s+)?(?:\w+(?:<[^>]{0,100}>)?)\s+(\w+)\s*\(/
+      );
+      if (methodMatch && !line.includes("class ") && !line.includes("interface ") && !line.includes("namespace ")) {
+        const name = methodMatch[1];
+        let braceCount = 0;
+        let body = "";
+        let started = false;
+        for (let j = i; j < lines.length; j++) {
+          body += lines[j] + "\n";
+          for (const ch of lines[j]) {
+            if (ch === "{") {
+              braceCount++;
+              started = true;
+            }
+            if (ch === "}") {
+              braceCount--;
+            }
           }
-          body += nextLine + "\n";
+          if (started && braceCount <= 0) break;
         }
-        functions.push({ name, body });
+        methods.push({ name, body });
       }
     }
-    return functions;
+    return methods;
   }
   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
+      /\bif\s*\(/g,
+      /\belse if\s*\(/g,
+      /\bfor\s*\(/g,
+      /\bforeach\s*\(/g,
+      /\bwhile\s*\(/g,
+      /\bcase\s+/g,
+      /\bcatch\s*\(/g,
+      /&&/g,
+      /\|\|/g,
+      /\?\?/g,
+      /\?[^?.\s]/g
     ];
     for (const pattern of patterns) {
       const matches = code.match(pattern);
-      if (matches) {
-        complexity += matches.length;
-      }
+      if (matches) complexity += matches.length;
     }
     return complexity;
   }
 };
-var PythonTypeHintsScanner = class {
+var CSharpCodeSmellScanner = class {
   constructor() {
-    this.name = "python-type-hints";
+    this.name = "csharp-code-smells";
   }
   async scan(rootDir) {
     const findings = [];
-    const files = await fg13(["**/*.py"], {
+    const files = await fg17(["**/*.cs"], {
       cwd: rootDir,
-      ignore: IGNORE_PATTERNS,
+      ignore: [...IGNORE_PATTERNS, "**/bin/**", "**/obj/**", "**/*Test*.cs", "**/Migrations/**"],
       absolute: true
     });
-    let totalFunctions = 0;
-    let untypedFunctions = 0;
     for (const file of files) {
       try {
-        const content = fs10.readFileSync(file, "utf-8");
+        const content = fs14.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++;
-          }
+        const methodCount = (content.match(
+          // eslint-disable-next-line security/detect-unsafe-regex
+          /^\s*(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:\w+)\s+\w+\s*\(/gm
+        ) || []).length;
+        if (methodCount >= 30) {
+          findings.push({
+            id: `csharp-god-class-${rel}`,
+            severity: "warning",
+            category: "csharp-smells",
+            message: `${rel} has ${methodCount} methods \u2014 possible God class`,
+            file: rel,
+            detail: "Consider applying Single Responsibility Principle"
+          });
+        }
+        const regions = content.match(/#region/g);
+        if (regions && regions.length >= 5) {
+          findings.push({
+            id: `csharp-regions-${rel}`,
+            severity: "info",
+            category: "csharp-smells",
+            message: `${rel} has ${regions.length} #region blocks`,
+            file: rel,
+            detail: "Excessive regions often hide classes that are too large"
+          });
+        }
+        const emptyCatch = content.match(/catch\s*(?:\([^)]{0,100}\))?\s*\{\s*\}/g);
+        if (emptyCatch && emptyCatch.length > 0) {
+          findings.push({
+            id: `csharp-empty-catch-${rel}`,
+            severity: "warning",
+            category: "csharp-smells",
+            message: `${rel} has ${emptyCatch.length} empty catch block(s)`,
+            file: rel,
+            detail: "Empty catch blocks silently swallow exceptions"
+          });
+        }
+        const consoleWrites = content.match(/Console\.(Write|WriteLine)\s*\(/g);
+        if (consoleWrites && consoleWrites.length >= 3) {
+          findings.push({
+            id: `csharp-console-${rel}`,
+            severity: "info",
+            category: "csharp-smells",
+            message: `${rel} uses Console.Write* ${consoleWrites.length} times`,
+            file: rel,
+            detail: "Use ILogger/logging framework instead of Console output"
+          });
+        }
+        const pragmas = content.match(/#pragma\s+warning\s+disable/g);
+        if (pragmas && pragmas.length >= 3) {
+          findings.push({
+            id: `csharp-pragma-${rel}`,
+            severity: "info",
+            category: "csharp-smells",
+            message: `${rel} disables ${pragmas.length} compiler warnings`,
+            file: rel,
+            detail: "Fix warnings instead of suppressing them"
+          });
         }
       } 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
-      }
-    };
+    return { findings };
   }
 };
-var PythonImportsScanner = class {
+var CSharpAsyncScanner = class {
   constructor() {
-    this.name = "python-imports";
+    this.name = "csharp-async";
   }
   async scan(rootDir) {
     const findings = [];
-    const files = await fg13(["**/*.py"], {
+    const files = await fg17(["**/*.cs"], {
       cwd: rootDir,
-      ignore: IGNORE_PATTERNS,
+      ignore: [...IGNORE_PATTERNS, "**/bin/**", "**/obj/**"],
       absolute: true
     });
     for (const file of files) {
       try {
-        const content = fs10.readFileSync(file, "utf-8");
+        const content = fs14.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) {
+        const asyncVoid = content.match(/\basync\s+void\s+\w+/g);
+        if (asyncVoid && asyncVoid.length > 0) {
           findings.push({
-            id: `py-wildcard-import-${rel}`,
+            id: `csharp-async-void-${rel}`,
             severity: "warning",
-            category: "python-imports",
-            message: `${rel} uses wildcard imports (${wildcardImports.length} found)`,
+            category: "csharp-async",
+            message: `${rel} has ${asyncVoid.length} async void method(s)`,
             file: rel,
-            detail: "Wildcard imports pollute namespace"
+            detail: "async void cannot be awaited and exceptions are unobservable. Use async Task instead."
           });
         }
-        const deepRelative = content.match(/from\s+\.{3,}/g);
-        if (deepRelative && deepRelative.length > 0) {
+        const syncOverAsync = content.match(/\.(?:Result|Wait\(\))/g);
+        if (syncOverAsync && syncOverAsync.length >= 3) {
           findings.push({
-            id: `py-deep-relative-${rel}`,
-            severity: "info",
-            category: "python-imports",
-            message: `${rel} uses deep relative imports`,
+            id: `csharp-sync-over-async-${rel}`,
+            severity: "warning",
+            category: "csharp-async",
+            message: `${rel} has ${syncOverAsync.length} sync-over-async calls (.Result/.Wait())`,
             file: rel,
-            detail: "Consider absolute imports"
+            detail: "Use await instead of .Result/.Wait() to avoid deadlocks"
           });
         }
       } catch {
@@ -2025,12 +3204,12 @@ var LANGUAGE_CONFIGS = {
     sourcePatterns: ["**/*.cs"]
   }
 };
-function detectProjectLanguage(rootDir, fs18) {
+function detectProjectLanguage(rootDir, fs22) {
   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)) {
+      if (fs22.existsSync(fullPath)) {
         detectedLanguages.push(lang);
         break;
       }
@@ -2147,7 +3326,7 @@ function getLabel(score) {
 
 // src/ai/index.ts
 import Anthropic from "@anthropic-ai/sdk";
-import fs11 from "fs";
+import fs15 from "fs";
 import path9 from "path";
 import crypto from "crypto";
 var DEFAULT_MODEL = "claude-3-5-sonnet-20241022";
@@ -2253,11 +3432,11 @@ function getFindingHash(finding) {
 }
 function getCachedRoast(finding, rootDir, cachePath) {
   const cacheFile = path9.join(rootDir, cachePath || CACHE_FILE);
-  if (!fs11.existsSync(cacheFile)) {
+  if (!fs15.existsSync(cacheFile)) {
     return null;
   }
   try {
-    const content = fs11.readFileSync(cacheFile, "utf-8");
+    const content = fs15.readFileSync(cacheFile, "utf-8");
     const cache = JSON.parse(content);
     const findingHash = getFindingHash(finding);
     const now = Date.now();
@@ -2273,8 +3452,8 @@ 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");
+    if (fs15.existsSync(cacheFile)) {
+      const content = fs15.readFileSync(cacheFile, "utf-8");
       cache = JSON.parse(content);
     }
     const findingHash = getFindingHash(finding);
@@ -2289,7 +3468,7 @@ function cacheRoast(finding, roast, rootDir, cachePath) {
     if (cache.length > 100) {
       cache = cache.slice(-100);
     }
-    fs11.writeFileSync(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+    fs15.writeFileSync(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
   } catch (error) {
   }
 }
@@ -2424,6 +3603,71 @@ var pythonImportRoasts = [
   "Deep relative imports: your codebase is spaghetti that imports other spaghetti.",
   "from module import * \u2014 the programming equivalent of 'throw everything in and hope.'"
 ];
+var pythonDocstringRoasts = [
+  "Docstrings are optional. So is understanding your code in 6 months.",
+  "Your functions are mysteries wrapped in enigmas. Add a docstring.",
+  "Self-documenting code is a myth. Your future self will thank you for docstrings."
+];
+var pythonSmellRoasts = [
+  "Bare except: catching everything including your dignity.",
+  "Mutable default arguments: the gift that keeps on mutating.",
+  "This much global state makes singletons look elegant.",
+  "Your functions are nested deeper than your tech debt."
+];
+var pythonSecurityRoasts = [
+  "eval() in Python: because you want hackers to feel welcome.",
+  "pickle.load() from untrusted data is just exec() with extra steps.",
+  "shell=True with user input: RCE as a feature, not a bug.",
+  "SQL string formatting: Little Bobby Tables approves.",
+  "Hardcoded secrets in Python: because .env files are too mainstream."
+];
+var pythonDesignRoasts = [
+  "This class has more methods than a Swiss Army knife has tools.",
+  "A class with no methods is just a dict wearing a trench coat. Use @dataclass.",
+  "4+ parent classes: your MRO looks like a family tree from the Habsburgs."
+];
+var goErrorHandlingRoasts = [
+  "Ignoring errors in Go is like ignoring check engine lights.",
+  "_ = dangerousOperation() \u2014 the Go equivalent of 'it's fine.'",
+  "Your error handling strategy appears to be 'hope.'",
+  "panic() in production: because graceful degradation is overrated."
+];
+var goLintRoasts = [
+  "Unexported symbols don't need docs. Exported ones do. Guess which you forgot.",
+  "Multiple init() functions: because one confusing startup sequence wasn't enough.",
+  "Go proverbs say 'a little copying is better than a little dependency.' You took that personally."
+];
+var rustUnsafeRoasts = [
+  "unsafe {} \u2014 Rust's way of saying 'I know what I'm doing.' Do you, though?",
+  "This much unsafe code defeats the purpose of choosing Rust.",
+  "The borrow checker can't save you if you keep bypassing it."
+];
+var rustClippyRoasts = [
+  ".unwrap() everywhere: living dangerously, one None at a time.",
+  "This much .clone() suggests a fundamental misunderstanding of ownership.",
+  "todo!() in production: the Rust equivalent of 'I'll fix it later.'"
+];
+var javaSmellRoasts = [
+  "This class has more methods than a phone book has entries.",
+  "System.out.println in production \u2014 logging frameworks exist, you know.",
+  "Empty catch blocks: because exceptions are just suggestions.",
+  "God classes: when Single Responsibility Principle is just a suggestion."
+];
+var javaNamingRoasts = [
+  "AbstractSingletonProxyFactoryBean called. It wants its naming convention back.",
+  "Java naming conventions aren't optional. Even Java thinks so.",
+  "Your constant naming is more chaotic than your class hierarchy."
+];
+var csharpSmellRoasts = [
+  "#region is not architecture. It's a rug to sweep complexity under.",
+  "Console.WriteLine in production? ILogger is right there.",
+  "This class is so large it needs its own table of contents."
+];
+var csharpAsyncRoasts = [
+  "async void: the fire-and-forget-and-pray pattern.",
+  ".Result and .Wait() \u2014 deadlocks as a service.",
+  "Sync-over-async: because who needs scalability anyway."
+];
 function pick(arr) {
   return arr[Math.floor(Math.random() * arr.length)];
 }
@@ -2580,6 +3824,102 @@ async function generateRoasts(findings, aiConfig, rootDir) {
       category: "python-imports"
     });
   }
+  const pythonDocstrings = findings.filter((f) => f.category === "python-docstrings");
+  if (pythonDocstrings.length > 0) {
+    roasts.push({
+      target: "Python documentation",
+      message: pick(pythonDocstringRoasts),
+      category: "python-docstrings"
+    });
+  }
+  const pythonSmells = findings.filter((f) => f.category === "python-smells");
+  if (pythonSmells.length > 0) {
+    roasts.push({
+      target: pythonSmells[0].file || "Python code",
+      message: pick(pythonSmellRoasts),
+      category: "python-smells"
+    });
+  }
+  const pythonSecurity = findings.filter((f) => f.category === "python-security");
+  if (pythonSecurity.length > 0) {
+    roasts.push({
+      target: pythonSecurity[0].file || "Python security",
+      message: pick(pythonSecurityRoasts),
+      category: "python-security"
+    });
+  }
+  const pythonDesign = findings.filter((f) => f.category === "python-design");
+  if (pythonDesign.length > 0) {
+    roasts.push({
+      target: pythonDesign[0].file || "Python classes",
+      message: pick(pythonDesignRoasts),
+      category: "python-design"
+    });
+  }
+  const goErrors = findings.filter((f) => f.category === "go-error-handling");
+  if (goErrors.length > 0) {
+    roasts.push({
+      target: goErrors[0].file || "Go code",
+      message: pick(goErrorHandlingRoasts),
+      category: "go-error-handling"
+    });
+  }
+  const goLint = findings.filter((f) => f.category === "go-lint");
+  if (goLint.length > 0) {
+    roasts.push({
+      target: "Go conventions",
+      message: pick(goLintRoasts),
+      category: "go-lint"
+    });
+  }
+  const rustUnsafe = findings.filter((f) => f.category === "rust-unsafe");
+  if (rustUnsafe.length > 0) {
+    roasts.push({
+      target: rustUnsafe[0].file || "Rust code",
+      message: pick(rustUnsafeRoasts),
+      category: "rust-unsafe"
+    });
+  }
+  const rustClippy = findings.filter((f) => f.category === "rust-clippy");
+  if (rustClippy.length > 0) {
+    roasts.push({
+      target: rustClippy[0].file || "Rust code",
+      message: pick(rustClippyRoasts),
+      category: "rust-clippy"
+    });
+  }
+  const javaSmells = findings.filter((f) => f.category === "java-smells");
+  if (javaSmells.length > 0) {
+    roasts.push({
+      target: javaSmells[0].file || "Java code",
+      message: pick(javaSmellRoasts),
+      category: "java-smells"
+    });
+  }
+  const javaNaming = findings.filter((f) => f.category === "java-naming");
+  if (javaNaming.length > 0) {
+    roasts.push({
+      target: javaNaming[0].file || "Java code",
+      message: pick(javaNamingRoasts),
+      category: "java-naming"
+    });
+  }
+  const csharpSmells = findings.filter((f) => f.category === "csharp-smells");
+  if (csharpSmells.length > 0) {
+    roasts.push({
+      target: csharpSmells[0].file || "C# code",
+      message: pick(csharpSmellRoasts),
+      category: "csharp-smells"
+    });
+  }
+  const csharpAsync = findings.filter((f) => f.category === "csharp-async");
+  if (csharpAsync.length > 0) {
+    roasts.push({
+      target: csharpAsync[0].file || "C# code",
+      message: pick(csharpAsyncRoasts),
+      category: "csharp-async"
+    });
+  }
   return roasts;
 }
 function generateVerdict(health) {
@@ -2650,7 +3990,7 @@ function renderJsonReport(report) {
 }
 
 // src/report/badge.ts
-import fs12 from "fs";
+import fs16 from "fs";
 import chalk2 from "chalk";
 
 // src/utils/security.ts
@@ -2722,7 +4062,7 @@ function getBadgeColor(score) {
 function saveBadge(svgContent, rootDir) {
   try {
     const badgePath = validateOutputPath(rootDir, ".roast-badge.svg");
-    fs12.writeFileSync(badgePath, svgContent, "utf-8");
+    fs16.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));
@@ -3097,7 +4437,7 @@ function renderWatchSummary(health, delta, findingCounts) {
 
 // src/compare/index.ts
 import path11 from "path";
-import fs13 from "fs";
+import fs17 from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
 import { randomBytes } from "crypto";
 import { tmpdir } from "os";
@@ -3139,9 +4479,9 @@ async function compareWithBranch(rootDir, branchName, scanFunc) {
       if (result.status === 0) return;
       await new Promise((resolve) => setTimeout(resolve, 100 * (i + 1)));
     }
-    if (fs13.existsSync(worktreePath)) {
+    if (fs17.existsSync(worktreePath)) {
       try {
-        fs13.rmSync(worktreePath, { recursive: true, force: true });
+        fs17.rmSync(worktreePath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -3217,7 +4557,7 @@ function renderComparison(comparison, branchName) {
 }
 
 // src/config/index.ts
-import fs14 from "fs";
+import fs18 from "fs";
 import path12 from "path";
 
 // src/config/validation.ts
@@ -3340,11 +4680,11 @@ var DEFAULT_CONFIG = {
 };
 function loadConfig(rootDir) {
   const configPath = path12.join(rootDir, ".roastrc.json");
-  if (!fs14.existsSync(configPath)) {
+  if (!fs18.existsSync(configPath)) {
     return DEFAULT_CONFIG;
   }
   try {
-    const content = fs14.readFileSync(configPath, "utf-8");
+    const content = fs18.readFileSync(configPath, "utf-8");
     const parsed = safeJsonParse(content);
     if (!parsed) {
       console.warn("Warning: Failed to parse .roastrc.json");
@@ -3386,7 +4726,7 @@ import { confirm, select } from "@inquirer/prompts";
 import chalk6 from "chalk";
 
 // src/interactive/fixes.ts
-import fs15 from "fs";
+import fs19 from "fs";
 import path13 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 async function applyAutoFix(finding, fix, rootDir, dryRun = false) {
@@ -3453,7 +4793,7 @@ function fixTodoComment(finding, rootDir, dryRun) {
   }
   const filePath = path13.join(rootDir, finding.file);
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs19.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const todoPattern = /\/\/\s*(TODO|FIXME|HACK|XXX):\s*(.+)/i;
     let modified = false;
@@ -3481,7 +4821,7 @@ function fixTodoComment(finding, rootDir, dryRun) {
         message: `Would add issue references to ${changedLines} TODO comment(s)`
       };
     }
-    fs15.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    fs19.writeFileSync(filePath, newLines.join("\n"), "utf-8");
     return {
       success: true,
       message: `Added issue references to TODO comments in ${finding.file}`
@@ -3510,7 +4850,7 @@ function fixDeadExport(finding, rootDir, dryRun) {
   const exportName = match[1];
   const filePath = path13.join(rootDir, finding.file);
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs19.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`,
@@ -3536,7 +4876,7 @@ function fixDeadExport(finding, rootDir, dryRun) {
         message: `Would remove dead export: ${exportName} from ${finding.file}`
       };
     }
-    fs15.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    fs19.writeFileSync(filePath, newLines.join("\n"), "utf-8");
     return {
       success: true,
       message: `Removed dead export: ${exportName} from ${finding.file}`
@@ -3825,17 +5165,17 @@ function getSeverityBadge(severity) {
 }
 
 // src/history/index.ts
-import fs16 from "fs";
+import fs20 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)) {
+  if (!fs20.existsSync(historyPath)) {
     return null;
   }
   try {
-    const content = fs16.readFileSync(historyPath, "utf-8");
+    const content = fs20.readFileSync(historyPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.warn(`Warning: Failed to load health history: ${error}`);
@@ -3845,7 +5185,7 @@ function loadHistory(rootDir) {
 function saveHistory(rootDir, history) {
   const historyPath = path14.join(rootDir, HISTORY_FILE);
   try {
-    fs16.writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
+    fs20.writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
   } catch (error) {
     console.warn(`Warning: Failed to save health history: ${error}`);
   }
@@ -4164,8 +5504,8 @@ function loadPackageVersion() {
   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 (fs21.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
       if (pkg.name === "roast-my-codebase") return pkg.version;
     }
     dir = path15.dirname(dir);
@@ -4180,11 +5520,11 @@ function createCli() {
     parseInt
   ).action(async (targetPath, options) => {
     const rootDir = path15.resolve(targetPath);
-    if (!fs17.existsSync(rootDir)) {
+    if (!fs21.existsSync(rootDir)) {
       console.error(`Error: "${rootDir}" does not exist.`);
       process.exit(1);
     }
-    if (!fs17.statSync(rootDir).isDirectory()) {
+    if (!fs21.statSync(rootDir).isDirectory()) {
       console.error(`Error: "${rootDir}" is not a directory.`);
       process.exit(1);
     }
@@ -4373,7 +5713,7 @@ Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
       const frameworkScanner = new FrameworkScanner();
       const frameworkResult = await frameworkScanner.scan(rootDir);
       allFindings.push(...frameworkResult.findings);
-      const detectedLanguages = detectProjectLanguage(rootDir, fs17);
+      const detectedLanguages = detectProjectLanguage(rootDir, fs21);
       if (detectedLanguages.includes("python")) {
         spinner.text = "Analyzing Python complexity...";
         const pyComplexityScanner = new PythonComplexityScanner();
@@ -4387,6 +5727,62 @@ Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
         const pyImportsScanner = new PythonImportsScanner();
         const pyImportsResult = await pyImportsScanner.scan(rootDir);
         allFindings.push(...pyImportsResult.findings);
+        spinner.text = "Checking Python docstrings...";
+        const pyDocstrings = new PythonDocstringScanner();
+        allFindings.push(...(await pyDocstrings.scan(rootDir)).findings);
+        spinner.text = "Detecting Python code smells...";
+        const pySmells = new PythonCodeSmellScanner();
+        allFindings.push(...(await pySmells.scan(rootDir)).findings);
+        spinner.text = "Scanning Python security...";
+        const pySecurity = new PythonSecurityScanner();
+        allFindings.push(...(await pySecurity.scan(rootDir)).findings);
+        spinner.text = "Analyzing Python class design...";
+        const pyDesign = new PythonClassDesignScanner();
+        allFindings.push(...(await pyDesign.scan(rootDir)).findings);
+      }
+      if (detectedLanguages.includes("go")) {
+        spinner.text = "Analyzing Go complexity...";
+        const goComplexity = new GoComplexityScanner();
+        allFindings.push(...(await goComplexity.scan(rootDir)).findings);
+        spinner.text = "Checking Go error handling...";
+        const goErrors = new GoErrorHandlingScanner();
+        allFindings.push(...(await goErrors.scan(rootDir)).findings);
+        spinner.text = "Checking Go conventions...";
+        const goLint = new GoLintScanner();
+        allFindings.push(...(await goLint.scan(rootDir)).findings);
+      }
+      if (detectedLanguages.includes("rust")) {
+        spinner.text = "Analyzing Rust complexity...";
+        const rustComplexity = new RustComplexityScanner();
+        allFindings.push(...(await rustComplexity.scan(rootDir)).findings);
+        spinner.text = "Checking Rust unsafe usage...";
+        const rustUnsafe = new RustUnsafeScanner();
+        allFindings.push(...(await rustUnsafe.scan(rootDir)).findings);
+        spinner.text = "Running Rust clippy hints...";
+        const rustClippy = new RustClippyHintsScanner();
+        allFindings.push(...(await rustClippy.scan(rootDir)).findings);
+      }
+      if (detectedLanguages.includes("java")) {
+        spinner.text = "Analyzing Java complexity...";
+        const javaComplexity = new JavaComplexityScanner();
+        allFindings.push(...(await javaComplexity.scan(rootDir)).findings);
+        spinner.text = "Checking Java code smells...";
+        const javaSmells = new JavaCodeSmellScanner();
+        allFindings.push(...(await javaSmells.scan(rootDir)).findings);
+        spinner.text = "Checking Java naming conventions...";
+        const javaNaming = new JavaNamingScanner();
+        allFindings.push(...(await javaNaming.scan(rootDir)).findings);
+      }
+      if (detectedLanguages.includes("csharp")) {
+        spinner.text = "Analyzing C# complexity...";
+        const csharpComplexity = new CSharpComplexityScanner();
+        allFindings.push(...(await csharpComplexity.scan(rootDir)).findings);
+        spinner.text = "Checking C# code smells...";
+        const csharpSmells = new CSharpCodeSmellScanner();
+        allFindings.push(...(await csharpSmells.scan(rootDir)).findings);
+        spinner.text = "Checking C# async patterns...";
+        const csharpAsync = new CSharpAsyncScanner();
+        allFindings.push(...(await csharpAsync.scan(rootDir)).findings);
       }
       spinner.stop();
       const health = calculateHealth(allFindings);
@@ -4428,7 +5824,7 @@ Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
         if (options.markdownFile) {
           try {
             const outputPath = validateOutputPath(rootDir, ".roast-report.md");
-            fs17.writeFileSync(outputPath, markdownOutput, "utf-8");
+            fs21.writeFileSync(outputPath, markdownOutput, "utf-8");
             console.log(`
 \u2713 Markdown report saved to ${outputPath}
 `);
@@ -4454,7 +5850,7 @@ Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
           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}
+          fs21.appendFileSync(debugPath, `${timestamp}: ${errorStr}
 `);
           console.log(`Debug info saved to ${debugPath}`);
         } catch {
@@ -4468,7 +5864,7 @@ Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
 function getProjectName(rootDir) {
   const pkgPath = path15.join(rootDir, "package.json");
   try {
-    const pkg = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
     return pkg.name || path15.basename(rootDir);
   } catch {
     return path15.basename(rootDir);