@aiready/core 0.23.2 → 0.23.3

package/dist/index.mjs

@@ -38,12 +38,13 @@ import {
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-5HIXDC3X.mjs";
+} from "./chunk-NGHT7JOG.mjs";
 
 // src/types/contract.ts
 function validateSpokeOutput(toolName, output) {
@@ -447,6 +448,7 @@ import {
   statSync
 } from "fs";
 import { join as join2, dirname as dirname2, resolve as resolvePath } from "path";
+import chalk from "chalk";
 function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
   let outputPath;
   if (userPath) {
@@ -514,22 +516,72 @@ function emitProgress(processed, total, toolId, message, onProgress, throttleCou
     onProgress(processed, total, `${message} (${processed}/${total})`);
   }
 }
-function getSeverityColor(severity, chalk) {
+function getSeverityColor(severity, chalkInstance = chalk) {
   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 chalk.blue;
+      return chalkInstance.blue;
     default:
-      return chalk.white;
+      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 1;
+    default:
+      return 0;
+  }
+}
+function getSeverityLevel(s) {
+  return getSeverityValue(s);
+}
+function getSeverityBadge(severity, chalkInstance = chalk) {
+  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) {
@@ -978,94 +1030,6 @@ var TypeScriptParser = class {
   }
 };
 
-// src/parsers/tree-sitter-utils.ts
-import * as Parser from "web-tree-sitter";
-import * as path from "path";
-import * as fs from "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 = {
@@ -1161,11 +1125,97 @@ function analyzeNodeMetadata(node, code, options) {
   return metadata;
 }
 
-// src/parsers/python-parser.ts
-var PythonParser = class {
+// src/parsers/tree-sitter-utils.ts
+import * as Parser from "web-tree-sitter";
+import * as path from "path";
+import * as fs from "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/base-parser.ts
+var BaseLanguageParser = class {
   constructor() {
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
     this.parser = null;
     this.initialized = false;
   }
@@ -1174,19 +1224,18 @@ 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) {
     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);
@@ -1196,19 +1245,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 exports = this.extractExportsAST(rootNode, code);
+      const imports = this.extractImportsAST(tree.rootNode);
+      const exports = this.extractExportsAST(tree.rootNode, code);
       return {
         exports,
         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) => {
@@ -1642,25 +1714,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, {
@@ -1672,31 +1733,6 @@ 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 exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        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) {
     const lines = code.split("\n");
     const exports = [];
@@ -1885,54 +1921,20 @@ 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 exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        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) {
     const lines = code.split("\n");
     const exports = [];
@@ -2129,56 +2131,20 @@ 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 exports = this.extractExportsAST(rootNode, code);
-      return {
-        exports,
-        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) {
     const lines = code.split("\n");
     const exports = [];
@@ -2505,48 +2471,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 = parse2(code, {
-      loc: true,
-      range: true,
-      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
-      filePath
-    });
-    const imports = extractFileImports(ast);
-    const exports = extractExportsWithDependencies(ast, imports);
-    return { exports, imports };
-  } catch (error) {
-    return { exports: [], imports: [] };
-  }
-}
+// src/utils/ast-visitor.ts
 function extractFileImports(ast) {
   const imports = [];
   for (const node of ast.body) {
@@ -2604,22 +2529,23 @@ function extractExportsWithDependencies(ast, fileImports) {
   }
   return exports;
 }
-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;
 }
@@ -2647,16 +2573,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) {
@@ -2694,6 +2610,59 @@ function extractTypeReferences(node) {
   visit(node);
   return Array.from(types);
 }
+
+// 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 = parse2(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      filePath
+    });
+    const imports = extractFileImports(ast);
+    const exports = extractExportsWithDependencies(ast, imports);
+    return { exports, imports };
+  } catch (error) {
+    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) {
   return null;
 }
@@ -2757,14 +2726,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 = dirname4(currentDir);
@@ -2777,28 +2746,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/business/pricing-models.ts
@@ -3011,7 +2980,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;
@@ -4350,12 +4322,17 @@ export {
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getRepoMetadata,
   getSafetyIcon,
   getScoreBar,
+  getSeverityBadge,
   getSeverityColor,
+  getSeverityEnum,
+  getSeverityLevel,
+  getSeverityValue,
   getSupportedLanguages,
   getToolWeight,
   getWasmPath,