@aiready/core 0.23.2 → 0.23.4

package/dist/index.js

@@ -127,12 +127,17 @@ __export(index_exports, {
   getProjectSizeTier: () => getProjectSizeTier,
   getRating: () => getRating,
   getRatingDisplay: () => getRatingDisplay,
+  getRatingSlug: () => getRatingSlug,
   getRatingWithContext: () => getRatingWithContext,
   getRecommendedThreshold: () => getRecommendedThreshold,
   getRepoMetadata: () => getRepoMetadata,
   getSafetyIcon: () => getSafetyIcon,
   getScoreBar: () => getScoreBar,
+  getSeverityBadge: () => getSeverityBadge,
   getSeverityColor: () => getSeverityColor,
+  getSeverityEnum: () => getSeverityEnum,
+  getSeverityLevel: () => getSeverityLevel,
+  getSeverityValue: () => getSeverityValue,
   getSupportedLanguages: () => getSupportedLanguages,
   getToolWeight: () => getToolWeight,
   getWasmPath: () => getWasmPath,
@@ -328,33 +333,28 @@ var UnifiedReportSchema = import_zod.z.object({
 // src/types.ts
 var GLOBAL_INFRA_OPTIONS = [
   "rootDir",
-  // Essential for every tool
   "include",
   "exclude",
-  "onProgress",
-  "progressCallback",
-  "includeTests",
-  "useSmartDefaults",
-  "streamResults",
-  "batchSize",
-  "costConfig",
   "tools",
-  "toolConfigs"
+  "scoring"
+];
+var GLOBAL_SCAN_OPTIONS = [
+  "rootDir",
+  "include",
+  "exclude",
+  "config",
+  "threshold",
+  "output",
+  "format",
+  "parallel",
+  "showBreakdown"
 ];
 var COMMON_FINE_TUNING_OPTIONS = [
   "maxDepth",
   "minSimilarity",
-  "minLines",
-  "minCohesion",
-  // AI Signal Clarity options
-  "checkMagicLiterals",
-  "checkBooleanTraps",
-  "checkAmbiguousNames",
-  "checkUndocumentedExports",
-  "checkImplicitSideEffects",
-  "checkDeepCallbacks"
+  "threshold",
+  "showBreakdown"
 ];
-var GLOBAL_SCAN_OPTIONS = [...GLOBAL_INFRA_OPTIONS];
 
 // src/types/language.ts
 var Language = /* @__PURE__ */ ((Language3) => {
@@ -645,7 +645,7 @@ async function scanFiles(options) {
     try {
       const txt = await (0, import_promises.readFile)(ignoreFilePath, "utf-8");
       ignoreFromFile = txt.split(/\r?\n/).map((s) => s.trim()).filter(Boolean).filter((l) => !l.startsWith("#")).filter((l) => !l.startsWith("!"));
-    } catch (e) {
+    } catch {
       ignoreFromFile = [];
     }
   }
@@ -699,7 +699,7 @@ async function scanFiles(options) {
         return !ig.ignores(rel);
       });
       return filtered;
-    } catch (e) {
+    } catch {
       return files;
     }
   }
@@ -707,14 +707,14 @@ async function scanFiles(options) {
 }
 async function scanEntries(options) {
   const files = await scanFiles(options);
-  const { rootDir, include = ["**/*"], exclude, includeTests } = options;
+  const { rootDir, exclude, includeTests } = options;
   const ignoreFilePath = (0, import_path.join)(rootDir || ".", ".aireadyignore");
   let ignoreFromFile = [];
   if ((0, import_fs.existsSync)(ignoreFilePath)) {
     try {
       const txt = await (0, import_promises.readFile)(ignoreFilePath, "utf-8");
       ignoreFromFile = txt.split(/\r?\n/).map((s) => s.trim()).filter(Boolean).filter((l) => !l.startsWith("#")).filter((l) => !l.startsWith("!"));
-    } catch (e) {
+    } catch {
       ignoreFromFile = [];
     }
   }
@@ -783,6 +783,7 @@ function isSourceFile(filePath) {
 // src/utils/cli-helpers.ts
 var import_fs2 = require("fs");
 var import_path2 = require("path");
+var import_chalk = __toESM(require("chalk"));
 function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
   let outputPath;
   if (userPath) {
@@ -850,22 +851,72 @@ function emitProgress(processed, total, toolId, message, onProgress, throttleCou
     onProgress(processed, total, `${message} (${processed}/${total})`);
   }
 }
-function getSeverityColor(severity, chalk) {
+function getSeverityColor(severity, chalkInstance = import_chalk.default) {
   switch (severity.toLowerCase()) {
     case "critical":
     case "high-risk":
     case "blind-risk":
-      return chalk.red;
+      return chalkInstance.red;
     case "major":
     case "moderate-risk":
-      return chalk.yellow;
+      return chalkInstance.yellow;
     case "minor":
     case "safe":
-      return chalk.green;
+      return chalkInstance.green;
+    case "info":
+      return chalkInstance.blue;
+    default:
+      return chalkInstance.white;
+  }
+}
+function getSeverityValue(s) {
+  if (!s) return 0;
+  switch (s.toLowerCase()) {
+    case "critical":
+      return 4;
+    case "major":
+      return 3;
+    case "minor":
+      return 2;
     case "info":
-      return chalk.blue;
+      return 1;
     default:
-      return chalk.white;
+      return 0;
+  }
+}
+function getSeverityLevel(s) {
+  return getSeverityValue(s);
+}
+function getSeverityBadge(severity, chalkInstance = import_chalk.default) {
+  const val = getSeverityValue(
+    typeof severity === "string" ? severity : severity
+  );
+  switch (val) {
+    case 4:
+      return chalkInstance.bgRed.white.bold(" CRITICAL ");
+    case 3:
+      return chalkInstance.bgYellow.black.bold(" MAJOR ");
+    case 2:
+      return chalkInstance.bgBlue.white.bold(" MINOR ");
+    case 1:
+      return chalkInstance.bgCyan.black(" INFO ");
+    default:
+      return chalkInstance.bgCyan.black(" INFO ");
+  }
+}
+function getSeverityEnum(s) {
+  const level = getSeverityLevel(s);
+  switch (level) {
+    case 4:
+      return "critical";
+    case 3:
+      return "major";
+    case 2:
+      return "minor";
+    case 1:
+      return "info";
+    default:
+      return "info";
   }
 }
 function findLatestReport(dirPath) {
@@ -1314,94 +1365,6 @@ var TypeScriptParser = class {
   }
 };
 
-// src/parsers/tree-sitter-utils.ts
-var Parser = __toESM(require("web-tree-sitter"));
-var path = __toESM(require("path"));
-var fs = __toESM(require("fs"));
-var isTreeSitterInitialized = false;
-async function initTreeSitter() {
-  if (isTreeSitterInitialized) return;
-  try {
-    const wasmPath = getWasmPath("web-tree-sitter");
-    await Parser.Parser.init({
-      locateFile() {
-        return wasmPath || "web-tree-sitter.wasm";
-      }
-    });
-    isTreeSitterInitialized = true;
-  } catch (error) {
-    console.error("Failed to initialize web-tree-sitter:", error);
-    isTreeSitterInitialized = true;
-  }
-}
-function findInPnpmStore(startDir, fileName, depth = 0) {
-  if (depth > 8) return null;
-  const pnpmDir = path.join(startDir, "node_modules", ".pnpm");
-  if (fs.existsSync(pnpmDir)) {
-    return findFileRecursively(pnpmDir, fileName, 0);
-  }
-  const parent = path.dirname(startDir);
-  if (parent === startDir) return null;
-  return findInPnpmStore(parent, fileName, depth + 1);
-}
-function findFileRecursively(dir, fileName, depth) {
-  if (depth > 6) return null;
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === fileName) {
-        return path.join(dir, entry.name);
-      }
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const found = findFileRecursively(
-          path.join(dir, entry.name),
-          fileName,
-          depth + 1
-        );
-        if (found) return found;
-      }
-    }
-  } catch (err) {
-  }
-  return null;
-}
-function getWasmPath(language) {
-  const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
-  const immediatePaths = [
-    path.join(process.cwd(), wasmFileName),
-    path.join(__dirname, wasmFileName),
-    path.join(__dirname, "assets", wasmFileName)
-  ];
-  for (const p of immediatePaths) {
-    if (fs.existsSync(p)) return p;
-  }
-  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
-  if (pnpmPath) return pnpmPath;
-  const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
-  if (pnpmPathCwd) return pnpmPathCwd;
-  console.warn(
-    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
-  );
-  return null;
-}
-async function setupParser(language) {
-  await initTreeSitter();
-  const wasmPath = getWasmPath(language);
-  if (!wasmPath) {
-    return null;
-  }
-  try {
-    const parser = new Parser.Parser();
-    const Lang = await Parser.Language.load(wasmPath);
-    parser.setLanguage(Lang);
-    return parser;
-  } catch (error) {
-    return null;
-  }
-}
-
 // src/parsers/metadata-utils.ts
 function analyzeNodeMetadata(node, code, options) {
   const metadata = {
@@ -1497,11 +1460,97 @@ function analyzeNodeMetadata(node, code, options) {
   return metadata;
 }
 
-// src/parsers/python-parser.ts
-var PythonParser = class {
+// src/parsers/tree-sitter-utils.ts
+var Parser = __toESM(require("web-tree-sitter"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var isTreeSitterInitialized = false;
+async function initTreeSitter() {
+  if (isTreeSitterInitialized) return;
+  try {
+    const wasmPath = getWasmPath("web-tree-sitter");
+    await Parser.Parser.init({
+      locateFile() {
+        return wasmPath || "web-tree-sitter.wasm";
+      }
+    });
+    isTreeSitterInitialized = true;
+  } catch (error) {
+    console.error("Failed to initialize web-tree-sitter:", error);
+    isTreeSitterInitialized = true;
+  }
+}
+function findInPnpmStore(startDir, fileName, depth = 0) {
+  if (depth > 8) return null;
+  const pnpmDir = path.join(startDir, "node_modules", ".pnpm");
+  if (fs.existsSync(pnpmDir)) {
+    return findFileRecursively(pnpmDir, fileName, 0);
+  }
+  const parent = path.dirname(startDir);
+  if (parent === startDir) return null;
+  return findInPnpmStore(parent, fileName, depth + 1);
+}
+function findFileRecursively(dir, fileName, depth) {
+  if (depth > 6) return null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === fileName) {
+        return path.join(dir, entry.name);
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = findFileRecursively(
+          path.join(dir, entry.name),
+          fileName,
+          depth + 1
+        );
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getWasmPath(language) {
+  const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
+  const immediatePaths = [
+    path.join(process.cwd(), wasmFileName),
+    path.join(__dirname, wasmFileName),
+    path.join(__dirname, "assets", wasmFileName)
+  ];
+  for (const p of immediatePaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
+  if (pnpmPath) return pnpmPath;
+  const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
+  if (pnpmPathCwd) return pnpmPathCwd;
+  console.warn(
+    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
+  );
+  return null;
+}
+async function setupParser(language) {
+  await initTreeSitter();
+  const wasmPath = getWasmPath(language);
+  if (!wasmPath) {
+    return null;
+  }
+  try {
+    const parser = new Parser.Parser();
+    const Lang = await Parser.Language.load(wasmPath);
+    parser.setLanguage(Lang);
+    return parser;
+  } catch {
+    return null;
+  }
+}
+
+// src/parsers/base-parser.ts
+var BaseLanguageParser = class {
   constructor() {
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
     this.parser = null;
     this.initialized = false;
   }
@@ -1510,19 +1559,19 @@ var PythonParser = class {
    */
   async initialize() {
     if (this.initialized) return;
-    this.parser = await setupParser("python");
-    this.initialized = true;
+    try {
+      this.parser = await setupParser(this.getParserName());
+      this.initialized = true;
+    } catch (error) {
+      console.warn(`Failed to initialize ${this.language} parser:`, error);
+    }
   }
-  async getAST(code, filePath) {
+  async getAST(code, _filePath) {
+    void _filePath;
     if (!this.initialized) await this.initialize();
     if (!this.parser) return null;
     return this.parser.parse(code);
   }
-  analyzeMetadata(node, code) {
-    return analyzeNodeMetadata(node, code, {
-      sideEffectSignatures: ["print(", "input(", "open("]
-    });
-  }
   parse(code, filePath) {
     if (!this.initialized || !this.parser) {
       return this.parseRegex(code, filePath);
@@ -1532,19 +1581,42 @@ var PythonParser = class {
       if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
         return this.parseRegex(code, filePath);
       }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode, code);
+      const imports = this.extractImportsAST(tree.rootNode);
+      const exports2 = this.extractExportsAST(tree.rootNode, code);
       return {
         exports: exports2,
         imports,
-        language: "python" /* Python */,
+        language: this.language,
         warnings: []
       };
     } catch (error) {
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
+      );
       return this.parseRegex(code, filePath);
     }
   }
+  canHandle(filePath) {
+    const lowerPath = filePath.toLowerCase();
+    return this.extensions.some((ext) => lowerPath.endsWith(ext));
+  }
+};
+
+// src/parsers/python-parser.ts
+var PythonParser = class extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "python" /* Python */;
+    this.extensions = [".py"];
+  }
+  getParserName() {
+    return "python";
+  }
+  analyzeMetadata(node, code) {
+    return analyzeNodeMetadata(node, code, {
+      sideEffectSignatures: ["print(", "input(", "open("]
+    });
+  }
   extractImportsAST(rootNode) {
     const imports = [];
     const processImportNode = (node) => {
@@ -1730,10 +1802,11 @@ var PythonParser = class {
         ]
       };
     } catch (error) {
-      throw new ParseError(
-        `Failed to parse Python file ${filePath}: ${error.message}`,
-        filePath
+      const wrapper = new Error(
+        `Failed to parse Python file ${filePath}: ${error.message}`
       );
+      wrapper.cause = error;
+      throw wrapper;
     }
   }
   getNamingConventions() {
@@ -1764,6 +1837,7 @@ var PythonParser = class {
     return filePath.toLowerCase().endsWith(".py");
   }
   extractImportsRegex(code, _filePath) {
+    void _filePath;
     const imports = [];
     const lines = code.split("\n");
     const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
@@ -1814,6 +1888,7 @@ var PythonParser = class {
     return imports;
   }
   extractExportsRegex(code, _filePath) {
+    void _filePath;
     const exports2 = [];
     const lines = code.split("\n");
     const funcRegex = /^def\s+([a-zA-Z0-9_]+)\s*\(/;
@@ -1978,25 +2053,14 @@ function extractParameterNames(node) {
 }
 
 // src/parsers/java-parser.ts
-var JavaParser = class {
+var JavaParser = class extends BaseLanguageParser {
   constructor() {
+    super(...arguments);
     this.language = "java" /* Java */;
     this.extensions = [".java"];
-    this.parser = null;
-    this.initialized = false;
   }
-  /**
-   * Initialize the tree-sitter parser
-   */
-  async initialize() {
-    if (this.initialized) return;
-    this.parser = await setupParser("java");
-    this.initialized = true;
-  }
-  async getAST(code, filePath) {
-    if (!this.initialized) await this.initialize();
-    if (!this.parser) return null;
-    return this.parser.parse(code);
+  getParserName() {
+    return "java";
   }
   analyzeMetadata(node, code) {
     return analyzeGeneralMetadata(node, code, {
@@ -2008,32 +2072,7 @@ var JavaParser = class {
       ]
     });
   }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      return this.parseRegex(code, filePath);
-    }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
-        return this.parseRegex(code, filePath);
-      }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode, code);
-      return {
-        exports: exports2,
-        imports,
-        language: "java" /* Java */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
-    }
-  }
-  parseRegex(code, filePath) {
+  parseRegex(code) {
     const lines = code.split("\n");
     const exports2 = [];
     const imports = [];
@@ -2107,10 +2146,8 @@ var JavaParser = class {
     for (const node of rootNode.children) {
       if (node.type === "import_declaration") {
         const sourceArr = [];
-        let isStatic = false;
         let isWildcard = false;
         for (const child of node.children) {
-          if (child.type === "static") isStatic = true;
           if (child.type === "scoped_identifier" || child.type === "identifier") {
             sourceArr.push(child.text);
           }
@@ -2221,55 +2258,21 @@ var JavaParser = class {
 };
 
 // src/parsers/csharp-parser.ts
-var CSharpParser = class {
+var CSharpParser = class extends BaseLanguageParser {
   constructor() {
+    super(...arguments);
     this.language = "csharp" /* CSharp */;
     this.extensions = [".cs"];
-    this.parser = null;
-    this.initialized = false;
   }
-  /**
-   * Initialize the tree-sitter parser
-   */
-  async initialize() {
-    if (this.initialized) return;
-    this.parser = await setupParser("c_sharp");
-    this.initialized = true;
-  }
-  async getAST(code, filePath) {
-    if (!this.initialized) await this.initialize();
-    if (!this.parser) return null;
-    return this.parser.parse(code);
+  getParserName() {
+    return "c_sharp";
   }
   analyzeMetadata(node, code) {
     return analyzeGeneralMetadata(node, code, {
       sideEffectSignatures: ["Console.Write", "File.Write", "Logging."]
     });
   }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      return this.parseRegex(code, filePath);
-    }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree) throw new Error("Parser.parse(code) returned null");
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode, code);
-      return {
-        exports: exports2,
-        imports,
-        language: "csharp" /* CSharp */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
-    }
-  }
-  parseRegex(code, filePath) {
+  parseRegex(code) {
     const lines = code.split("\n");
     const exports2 = [];
     const imports = [];
@@ -2465,57 +2468,21 @@ var CSharpParser = class {
 };
 
 // src/parsers/go-parser.ts
-var GoParser = class {
+var GoParser = class extends BaseLanguageParser {
   constructor() {
+    super(...arguments);
     this.language = "go" /* Go */;
     this.extensions = [".go"];
-    this.parser = null;
-    this.initialized = false;
-  }
-  /**
-   * Initialize the tree-sitter parser
-   */
-  async initialize() {
-    if (this.initialized) return;
-    this.parser = await setupParser("go");
-    this.initialized = true;
   }
-  async getAST(code, filePath) {
-    if (!this.initialized) await this.initialize();
-    if (!this.parser) return null;
-    return this.parser.parse(code);
+  getParserName() {
+    return "go";
   }
   analyzeMetadata(node, code) {
     return analyzeGeneralMetadata(node, code, {
       sideEffectSignatures: ["<-", "fmt.Print", "fmt.Fprintf", "os.Exit"]
     });
   }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      return this.parseRegex(code, filePath);
-    }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
-        return this.parseRegex(code, filePath);
-      }
-      const rootNode = tree.rootNode;
-      const imports = this.extractImportsAST(rootNode);
-      const exports2 = this.extractExportsAST(rootNode, code);
-      return {
-        exports: exports2,
-        imports,
-        language: "go" /* Go */,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
-    }
-  }
-  parseRegex(code, filePath) {
+  parseRegex(code) {
     const lines = code.split("\n");
     const exports2 = [];
     const imports = [];
@@ -2841,48 +2808,7 @@ function getSupportedLanguages() {
   return ParserFactory.getInstance().getSupportedLanguages();
 }
 
-// src/utils/ast-parser.ts
-function parseFileExports(code, filePath) {
-  const parser = getParser(filePath);
-  if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
-    try {
-      const result = parser.parse(code, filePath);
-      return {
-        exports: result.exports.map((e) => ({
-          name: e.name,
-          type: e.type,
-          imports: e.imports || [],
-          dependencies: e.dependencies || [],
-          typeReferences: e.typeReferences || [],
-          loc: e.loc ? {
-            start: { line: e.loc.start.line, column: e.loc.start.column },
-            end: { line: e.loc.end.line, column: e.loc.end.column }
-          } : void 0
-        })),
-        imports: result.imports.map((i) => ({
-          source: i.source,
-          specifiers: i.specifiers,
-          isTypeOnly: i.isTypeOnly || false
-        }))
-      };
-    } catch (e) {
-      return { exports: [], imports: [] };
-    }
-  }
-  try {
-    const ast = (0, import_typescript_estree2.parse)(code, {
-      loc: true,
-      range: true,
-      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
-      filePath
-    });
-    const imports = extractFileImports(ast);
-    const exports2 = extractExportsWithDependencies(ast, imports);
-    return { exports: exports2, imports };
-  } catch (error) {
-    return { exports: [], imports: [] };
-  }
-}
+// src/utils/ast-visitor.ts
 function extractFileImports(ast) {
   const imports = [];
   for (const node of ast.body) {
@@ -2940,22 +2866,23 @@ function extractExportsWithDependencies(ast, fileImports) {
   }
   return exports2;
 }
-function extractFromDeclaration(declaration) {
+function extractFromDeclaration(node) {
+  if (!node) return [];
   const results = [];
-  if (declaration.type === "FunctionDeclaration" && "id" in declaration && declaration.id) {
-    results.push({ name: declaration.id.name, type: "function" });
-  } else if (declaration.type === "ClassDeclaration" && "id" in declaration && declaration.id) {
-    results.push({ name: declaration.id.name, type: "class" });
-  } else if (declaration.type === "VariableDeclaration") {
-    for (const declarator of declaration.declarations) {
-      if (declarator.id.type === "Identifier") {
-        results.push({ name: declarator.id.name, type: "const" });
+  if (node.type === "FunctionDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "function" });
+  } else if (node.type === "ClassDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "class" });
+  } else if (node.type === "VariableDeclaration") {
+    for (const decl of node.declarations) {
+      if (decl.id.type === "Identifier") {
+        results.push({ name: decl.id.name, type: "const" });
       }
     }
-  } else if (declaration.type === "TSTypeAliasDeclaration") {
-    results.push({ name: declaration.id.name, type: "type" });
-  } else if (declaration.type === "TSInterfaceDeclaration") {
-    results.push({ name: declaration.id.name, type: "interface" });
+  } else if (node.type === "TSInterfaceDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "interface" });
+  } else if (node.type === "TSTypeAliasDeclaration" && node.id) {
+    results.push({ name: node.id.name, type: "type" });
   }
   return results;
 }
@@ -2983,16 +2910,6 @@ function findUsedImports(node, importedNames) {
   visit(node);
   return Array.from(usedImports);
 }
-function calculateImportSimilarity(export1, export2) {
-  if (export1.imports.length === 0 && export2.imports.length === 0) {
-    return 1;
-  }
-  const set1 = new Set(export1.imports);
-  const set2 = new Set(export2.imports);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
 function extractTypeReferences(node) {
   const types = /* @__PURE__ */ new Set();
   function visit(n) {
@@ -3030,13 +2947,70 @@ function extractTypeReferences(node) {
   visit(node);
   return Array.from(types);
 }
-function parseCode(code, language) {
+
+// src/utils/ast-parser.ts
+function parseFileExports(code, filePath) {
+  const parser = getParser(filePath);
+  if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
+    try {
+      const result = parser.parse(code, filePath);
+      return {
+        exports: result.exports.map((e) => ({
+          name: e.name,
+          type: e.type,
+          imports: e.imports || [],
+          dependencies: e.dependencies || [],
+          typeReferences: e.typeReferences || [],
+          loc: e.loc ? {
+            start: { line: e.loc.start.line, column: e.loc.start.column },
+            end: { line: e.loc.end.line, column: e.loc.end.column }
+          } : void 0
+        })),
+        imports: result.imports.map((i) => ({
+          source: i.source,
+          specifiers: i.specifiers,
+          isTypeOnly: i.isTypeOnly || false
+        }))
+      };
+    } catch {
+      return { exports: [], imports: [] };
+    }
+  }
+  try {
+    const ast = (0, import_typescript_estree2.parse)(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      filePath
+    });
+    const imports = extractFileImports(ast);
+    const exports2 = extractExportsWithDependencies(ast, imports);
+    return { exports: exports2, imports };
+  } catch {
+    return { exports: [], imports: [] };
+  }
+}
+function calculateImportSimilarity(export1, export2) {
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1;
+  }
+  const set1 = new Set(export1.imports);
+  const set2 = new Set(export2.imports);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function parseCode(_code, _language) {
+  void _code;
+  void _language;
   return null;
 }
-function extractFunctions(ast) {
+function extractFunctions(_ast) {
+  void _ast;
   return [];
 }
-function extractImports(ast) {
+function extractImports(_ast) {
+  void _ast;
   return [];
 }
 
@@ -3093,14 +3067,14 @@ async function loadConfig(rootDir) {
         return config;
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        const e = new Error(
+        const configError = new Error(
           `Failed to load config from ${configPath}: ${errorMessage}`
         );
         try {
-          e.cause = error instanceof Error ? error : void 0;
+          configError.cause = error instanceof Error ? error : void 0;
         } catch {
         }
-        throw e;
+        throw configError;
       }
     }
     const parent = (0, import_path3.dirname)(currentDir);
@@ -3113,28 +3087,28 @@ async function loadConfig(rootDir) {
 }
 function mergeConfigWithDefaults(userConfig, defaults) {
   if (!userConfig) return defaults;
-  const result = { ...defaults };
+  const mergedConfig = { ...defaults };
   if (userConfig.scan) {
-    if (userConfig.scan.include) result.include = userConfig.scan.include;
-    if (userConfig.scan.exclude) result.exclude = userConfig.scan.exclude;
+    if (userConfig.scan.include) mergedConfig.include = userConfig.scan.include;
+    if (userConfig.scan.exclude) mergedConfig.exclude = userConfig.scan.exclude;
   }
   const toolOverrides = userConfig.tools && !Array.isArray(userConfig.tools) && typeof userConfig.tools === "object" ? userConfig.tools : userConfig.toolConfigs;
   if (toolOverrides) {
-    if (!result.toolConfigs) result.toolConfigs = {};
+    if (!mergedConfig.toolConfigs) mergedConfig.toolConfigs = {};
     for (const [toolName, toolConfig] of Object.entries(toolOverrides)) {
       if (typeof toolConfig === "object" && toolConfig !== null) {
-        result[toolName] = { ...result[toolName], ...toolConfig };
-        result.toolConfigs[toolName] = {
-          ...result.toolConfigs[toolName],
+        mergedConfig[toolName] = { ...mergedConfig[toolName], ...toolConfig };
+        mergedConfig.toolConfigs[toolName] = {
+          ...mergedConfig.toolConfigs[toolName],
           ...toolConfig
         };
       }
     }
   }
   if (userConfig.output) {
-    result.output = { ...result.output, ...userConfig.output };
+    mergedConfig.output = { ...mergedConfig.output, ...userConfig.output };
   }
-  return result;
+  return mergedConfig;
 }
 
 // src/utils/visualization.ts
@@ -3503,6 +3477,13 @@ function getRating(score) {
   if (score >= 40) return "Needs Work" /* NeedsWork */;
   return "Critical" /* Critical */;
 }
+function getRatingSlug(score) {
+  if (score >= 90) return "excellent";
+  if (score >= 75) return "good";
+  if (score >= 60) return "fair";
+  if (score >= 40) return "needs-work";
+  return "critical";
+}
 function getRatingWithContext(score, fileCount, modelTier = "standard") {
   const threshold = getRecommendedThreshold(fileCount, modelTier);
   const normalized = score - threshold + 70;
@@ -3772,7 +3753,10 @@ function predictAcceptanceRate(toolOutputs) {
       impact: Math.round((50 - aiSignalClarity.score) * 2e-3 * 100)
     });
   }
-  const totalImpact = factors.reduce((sum, f) => sum + f.impact / 100, 0);
+  const totalImpact = factors.reduce(
+    (sum, f) => sum + f.impact / 100,
+    0
+  );
   const rate = Math.max(0.05, Math.min(0.8, baseRate + totalImpact));
   let confidence = 0.35;
   if (toolOutputs.size >= 4) confidence = 0.75;
@@ -5112,12 +5096,17 @@ function emitIssuesAsAnnotations(issues) {
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getRepoMetadata,
   getSafetyIcon,
   getScoreBar,
+  getSeverityBadge,
   getSeverityColor,
+  getSeverityEnum,
+  getSeverityLevel,
+  getSeverityValue,
   getSupportedLanguages,
   getToolWeight,
   getWasmPath,