@aiready/core 0.21.13 → 0.21.15

package/dist/index.js

@@ -123,6 +123,7 @@ __export(index_exports, {
   getToolWeight: () => getToolWeight,
   handleCLIError: () => handleCLIError,
   handleJSONOutput: () => handleJSONOutput,
+  initializeParsers: () => initializeParsers,
   isFileSupported: () => isFileSupported,
   isSourceFile: () => isSourceFile,
   loadConfig: () => loadConfig,
@@ -332,15 +333,15 @@ var COMMON_FINE_TUNING_OPTIONS = [
 var GLOBAL_SCAN_OPTIONS = [...GLOBAL_INFRA_OPTIONS];
 
 // src/types/language.ts
-var Language = /* @__PURE__ */ ((Language2) => {
-  Language2["TypeScript"] = "typescript";
-  Language2["JavaScript"] = "javascript";
-  Language2["Python"] = "python";
-  Language2["Java"] = "java";
-  Language2["Go"] = "go";
-  Language2["Rust"] = "rust";
-  Language2["CSharp"] = "csharp";
-  return Language2;
+var Language = /* @__PURE__ */ ((Language3) => {
+  Language3["TypeScript"] = "typescript";
+  Language3["JavaScript"] = "javascript";
+  Language3["Python"] = "python";
+  Language3["Java"] = "java";
+  Language3["Go"] = "go";
+  Language3["Rust"] = "rust";
+  Language3["CSharp"] = "csharp";
+  return Language3;
 })(Language || {});
 var LANGUAGE_EXTENSIONS = {
   ".ts": "typescript" /* TypeScript */,
@@ -788,1531 +789,1787 @@ function getSeverityColor(severity, chalk) {
 }
 
 // src/utils/ast-parser.ts
+var import_typescript_estree2 = require("@typescript-eslint/typescript-estree");
+
+// src/parsers/typescript-parser.ts
 var import_typescript_estree = require("@typescript-eslint/typescript-estree");
-function parseFileExports(code, filePath) {
-  try {
-    const ast = (0, import_typescript_estree.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: [] };
+var TypeScriptParser = class {
+  constructor() {
+    this.language = "typescript" /* TypeScript */;
+    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
   }
-}
-function extractFileImports(ast) {
-  const imports = [];
-  for (const node of ast.body) {
-    if (node.type === "ImportDeclaration") {
-      const source = node.source.value;
-      const specifiers = [];
-      const isTypeOnly = node.importKind === "type";
-      for (const spec of node.specifiers) {
-        if (spec.type === "ImportSpecifier") {
-          const imported = spec.imported;
-          const importName = imported.type === "Identifier" ? imported.name : imported.value;
-          specifiers.push(importName);
-        } else if (spec.type === "ImportDefaultSpecifier") {
-          specifiers.push("default");
-        } else if (spec.type === "ImportNamespaceSpecifier") {
-          specifiers.push("*");
-        }
-      }
-      imports.push({ source, specifiers, isTypeOnly });
-    }
+  async initialize() {
+    return Promise.resolve();
   }
-  return imports;
-}
-function extractExportsWithDependencies(ast, fileImports) {
-  const exports2 = [];
-  const importedNames = new Set(fileImports.flatMap((imp) => imp.specifiers));
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration") {
-      if (node.declaration) {
-        const exportNodes = extractFromDeclaration(node.declaration);
-        for (const exp of exportNodes) {
-          const usedImports = findUsedImports(node.declaration, importedNames);
-          const typeReferences = extractTypeReferences(node.declaration);
-          exports2.push({
-            ...exp,
-            imports: usedImports,
-            dependencies: [],
-            typeReferences,
-            loc: node.loc
-          });
-        }
-      }
-    } else if (node.type === "ExportDefaultDeclaration") {
-      const usedImports = findUsedImports(node.declaration, importedNames);
-      const typeReferences = extractTypeReferences(node.declaration);
-      exports2.push({
-        name: "default",
-        type: "default",
-        imports: usedImports,
-        dependencies: [],
-        typeReferences,
-        loc: node.loc
+  parse(code, filePath) {
+    try {
+      const isJavaScript = filePath.match(/\.jsx?$/i);
+      const ast = (0, import_typescript_estree.parse)(code, {
+        loc: true,
+        range: true,
+        jsx: filePath.match(/\.[jt]sx$/i) !== null,
+        filePath,
+        sourceType: "module",
+        ecmaVersion: "latest"
       });
+      const imports = this.extractImports(ast);
+      const exports2 = this.extractExports(ast, imports);
+      return {
+        exports: exports2,
+        imports,
+        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
+        warnings: []
+      };
+    } catch (error) {
+      const err = error;
+      throw new ParseError(
+        `Failed to parse ${filePath}: ${err.message}`,
+        filePath
+      );
     }
   }
-  return exports2;
-}
-function extractFromDeclaration(declaration) {
-  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" });
-      }
-    }
-  } 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" });
-  }
-  return results;
-}
-function findUsedImports(node, importedNames) {
-  const usedImports = /* @__PURE__ */ new Set();
-  function visit(n) {
-    if (n.type === "Identifier" && importedNames.has(n.name)) {
-      usedImports.add(n.name);
-    }
-    for (const key in n) {
-      const value = n[key];
-      if (value && typeof value === "object") {
-        if (Array.isArray(value)) {
-          value.forEach((child) => {
-            if (child && typeof child === "object" && "type" in child) {
-              visit(child);
-            }
-          });
-        } else if ("type" in value) {
-          visit(value);
-        }
-      }
-    }
+  getNamingConventions() {
+    return {
+      // camelCase for variables and functions
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
+      // PascalCase for classes
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      // UPPER_CASE for constants
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      // Common exceptions (React hooks, etc.)
+      exceptions: ["__filename", "__dirname", "__esModule"]
+    };
   }
-  visit(node);
-  return Array.from(usedImports);
-}
-function calculateImportSimilarity(export1, export2) {
-  if (export1.imports.length === 0 && export2.imports.length === 0) {
-    return 1;
+  canHandle(filePath) {
+    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
   }
-  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) {
-    if (!n || typeof n !== "object") return;
-    if (n.type === "TSTypeReference" && n.typeName) {
-      if (n.typeName.type === "Identifier") {
-        types.add(n.typeName.name);
-      } else if (n.typeName.type === "TSQualifiedName") {
-        let current = n.typeName;
-        while (current.type === "TSQualifiedName") {
-          if (current.right?.type === "Identifier") {
-            types.add(current.right.name);
-          }
-          current = current.left;
+  extractImports(ast) {
+    const imports = [];
+    for (const node of ast.body) {
+      if (node.type === "ImportDeclaration") {
+        const specifiers = [];
+        let isTypeOnly = false;
+        if (node.importKind === "type") {
+          isTypeOnly = true;
         }
-        if (current.type === "Identifier") {
-          types.add(current.name);
+        for (const spec of node.specifiers) {
+          if (spec.type === "ImportSpecifier") {
+            const imported = spec.imported;
+            const name = imported.type === "Identifier" ? imported.name : imported.value;
+            specifiers.push(name);
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            specifiers.push("default");
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            specifiers.push("*");
+          }
         }
+        imports.push({
+          source: node.source.value,
+          specifiers,
+          isTypeOnly,
+          loc: node.loc ? {
+            start: {
+              line: node.loc.start.line,
+              column: node.loc.start.column
+            },
+            end: { line: node.loc.end.line, column: node.loc.end.column }
+          } : void 0
+        });
       }
     }
-    if (n.type === "TSInterfaceHeritage" && n.expression) {
-      if (n.expression.type === "Identifier") {
-        types.add(n.expression.name);
-      }
-    }
-    for (const key of Object.keys(n)) {
-      const value = n[key];
-      if (Array.isArray(value)) {
-        value.forEach(visit);
-      } else if (value && typeof value === "object") {
-        visit(value);
+    return imports;
+  }
+  extractExports(ast, imports) {
+    const exports2 = [];
+    const importedNames = new Set(
+      imports.flatMap(
+        (imp) => imp.specifiers.filter((s) => s !== "*" && s !== "default")
+      )
+    );
+    for (const node of ast.body) {
+      if (node.type === "ExportNamedDeclaration" && node.declaration) {
+        const extracted = this.extractFromDeclaration(
+          node.declaration,
+          importedNames
+        );
+        exports2.push(...extracted);
+      } else if (node.type === "ExportDefaultDeclaration") {
+        let name = "default";
+        let type = "default";
+        if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+          name = node.declaration.id.name;
+          type = "function";
+        } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
+          name = node.declaration.id.name;
+          type = "class";
+        }
+        exports2.push({
+          name,
+          type,
+          loc: node.loc ? {
+            start: {
+              line: node.loc.start.line,
+              column: node.loc.start.column
+            },
+            end: { line: node.loc.end.line, column: node.loc.end.column }
+          } : void 0
+        });
       }
     }
+    return exports2;
   }
-  visit(node);
-  return Array.from(types);
-}
-function parseCode(code, language) {
-  return null;
-}
-function extractFunctions(ast) {
-  return [];
-}
-function extractImports(ast) {
-  return [];
-}
-
-// src/utils/metrics.ts
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-
-// src/utils/config.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
-var import_url = require("url");
-var CONFIG_FILES = [
-  "aiready.json",
-  "aiready.config.json",
-  ".aiready.json",
-  ".aireadyrc.json",
-  "aiready.config.js",
-  ".aireadyrc.js"
-];
-async function loadConfig(rootDir) {
-  let currentDir = (0, import_path3.resolve)(rootDir);
-  while (true) {
-    for (const configFile of CONFIG_FILES) {
-      const configPath = (0, import_path3.join)(currentDir, configFile);
-      if ((0, import_fs3.existsSync)(configPath)) {
-        try {
-          let config;
-          if (configFile.endsWith(".js")) {
-            const fileUrl = (0, import_url.pathToFileURL)(configPath).href;
-            const module2 = await import(`${fileUrl}?t=${Date.now()}`);
-            config = module2.default || module2;
-          } else {
-            const content = (0, import_fs3.readFileSync)(configPath, "utf-8");
-            config = JSON.parse(content);
+  extractFromDeclaration(declaration, importedNames) {
+    const exports2 = [];
+    if (declaration.type === "FunctionDeclaration" && declaration.id) {
+      exports2.push({
+        name: declaration.id.name,
+        type: "function",
+        parameters: declaration.params.map(
+          (p) => p.type === "Identifier" ? p.name : "unknown"
+        ),
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: {
+            line: declaration.loc.end.line,
+            column: declaration.loc.end.column
           }
-          if (typeof config !== "object" || config === null) {
-            throw new Error("Config must be an object");
+        } : void 0
+      });
+    } else if (declaration.type === "ClassDeclaration" && declaration.id) {
+      exports2.push({
+        name: declaration.id.name,
+        type: "class",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: {
+            line: declaration.loc.end.line,
+            column: declaration.loc.end.column
           }
-          return config;
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          const e = new Error(
-            `Failed to load config from ${configPath}: ${errorMessage}`
-          );
-          try {
-            e.cause = error instanceof Error ? error : void 0;
-          } catch {
+        } : void 0
+      });
+    } else if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === "Identifier") {
+          exports2.push({
+            name: declarator.id.name,
+            type: "const",
+            loc: declarator.loc ? {
+              start: {
+                line: declarator.loc.start.line,
+                column: declarator.loc.start.column
+              },
+              end: {
+                line: declarator.loc.end.line,
+                column: declarator.loc.end.column
+              }
+            } : void 0
+          });
+        }
+      }
+    } else if (declaration.type === "TSTypeAliasDeclaration") {
+      exports2.push({
+        name: declaration.id.name,
+        type: "type",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: {
+            line: declaration.loc.end.line,
+            column: declaration.loc.end.column
           }
-          throw e;
+        } : void 0
+      });
+    } else if (declaration.type === "TSInterfaceDeclaration") {
+      exports2.push({
+        name: declaration.id.name,
+        type: "interface",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: {
+            line: declaration.loc.end.line,
+            column: declaration.loc.end.column
+          }
+        } : void 0
+      });
+    }
+    return exports2;
+  }
+};
+
+// src/parsers/python-parser.ts
+var Parser = __toESM(require("web-tree-sitter"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var PythonParser = class {
+  constructor() {
+    this.language = "python" /* Python */;
+    this.extensions = [".py"];
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await Parser.Parser.init();
+      this.parser = new Parser.Parser();
+      const possiblePaths = [
+        path.join(
+          process.cwd(),
+          "node_modules/tree-sitter-python/tree-sitter-python.wasm"
+        ),
+        path.join(
+          __dirname,
+          "../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+        ),
+        path.join(
+          __dirname,
+          "../../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+        ),
+        path.join(
+          __dirname,
+          "../../../../node_modules/tree-sitter-python/tree-sitter-python.wasm"
+        ),
+        path.join(__dirname, "../assets/tree-sitter-python.wasm")
+      ];
+      let wasmPath = "";
+      for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+          wasmPath = p;
+          break;
         }
       }
+      if (!wasmPath) {
+        console.warn(
+          "Python WASM not found in common locations, attempting fallback regex parser"
+        );
+        return;
+      }
+      const Python = await Parser.Language.load(wasmPath);
+      this.parser.setLanguage(Python);
+      this.initialized = true;
+    } catch (error) {
+      console.error(
+        `Failed to initialize tree-sitter-python: ${error.message}`
+      );
     }
-    const parent = (0, import_path3.dirname)(currentDir);
-    if (parent === currentDir) {
-      break;
+  }
+  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);
+      return {
+        exports: exports2,
+        imports,
+        language: "python" /* Python */,
+        warnings: []
+      };
+    } catch (error) {
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
+      );
+      return this.parseRegex(code, filePath);
     }
-    currentDir = parent;
   }
-  return null;
-}
-function mergeConfigWithDefaults(userConfig, defaults) {
-  if (!userConfig) return defaults;
-  const result = { ...defaults };
-  if (userConfig.scan) {
-    if (userConfig.scan.include) result.include = userConfig.scan.include;
-    if (userConfig.scan.exclude) result.exclude = userConfig.scan.exclude;
+  extractImportsAST(rootNode) {
+    const imports = [];
+    const processImportNode = (node) => {
+      if (node.type === "import_statement") {
+        for (const child of node.children) {
+          if (child.type === "dotted_name") {
+            const source = child.text;
+            imports.push({
+              source,
+              specifiers: [source],
+              loc: {
+                start: {
+                  line: child.startPosition.row + 1,
+                  column: child.startPosition.column
+                },
+                end: {
+                  line: child.endPosition.row + 1,
+                  column: child.endPosition.column
+                }
+              }
+            });
+          } else if (child.type === "aliased_import") {
+            const nameNode = child.childForFieldName("name");
+            if (nameNode) {
+              const source = nameNode.text;
+              imports.push({
+                source,
+                specifiers: [source],
+                loc: {
+                  start: {
+                    line: child.startPosition.row + 1,
+                    column: child.startPosition.column
+                  },
+                  end: {
+                    line: child.endPosition.row + 1,
+                    column: child.endPosition.column
+                  }
+                }
+              });
+            }
+          }
+        }
+      } else if (node.type === "import_from_statement") {
+        const moduleNameNode = node.childForFieldName("module_name");
+        if (moduleNameNode) {
+          const source = moduleNameNode.text;
+          const specifiers = [];
+          for (const child of node.children) {
+            if (child.type === "dotted_name" && child !== moduleNameNode) {
+              specifiers.push(child.text);
+            } else if (child.type === "aliased_import") {
+              const nameNode = child.childForFieldName("name");
+              if (nameNode) specifiers.push(nameNode.text);
+            } else if (child.type === "wildcard_import") {
+              specifiers.push("*");
+            }
+          }
+          if (specifiers.length > 0) {
+            imports.push({
+              source,
+              specifiers,
+              loc: {
+                start: {
+                  line: node.startPosition.row + 1,
+                  column: node.startPosition.column
+                },
+                end: {
+                  line: node.endPosition.row + 1,
+                  column: node.endPosition.column
+                }
+              }
+            });
+          }
+        }
+      }
+    };
+    for (const node of rootNode.children) {
+      processImportNode(node);
+    }
+    return imports;
   }
-  const toolOverrides = userConfig.tools && !Array.isArray(userConfig.tools) && typeof userConfig.tools === "object" ? userConfig.tools : userConfig.toolConfigs;
-  if (toolOverrides) {
-    if (!result.toolConfigs) result.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],
-          ...toolConfig
-        };
+  extractExportsAST(rootNode) {
+    const exports2 = [];
+    for (const node of rootNode.children) {
+      if (node.type === "function_definition") {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          const name = nameNode.text;
+          const isPrivate = name.startsWith("_") && !name.startsWith("__");
+          if (!isPrivate) {
+            exports2.push({
+              name,
+              type: "function",
+              loc: {
+                start: {
+                  line: node.startPosition.row + 1,
+                  column: node.startPosition.column
+                },
+                end: {
+                  line: node.endPosition.row + 1,
+                  column: node.endPosition.column
+                }
+              },
+              parameters: this.extractParameters(node)
+            });
+          }
+        }
+      } else if (node.type === "class_definition") {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) {
+          exports2.push({
+            name: nameNode.text,
+            type: "class",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      } else if (node.type === "expression_statement") {
+        const assignment = node.firstChild;
+        if (assignment && assignment.type === "assignment") {
+          const left = assignment.childForFieldName("left");
+          if (left && left.type === "identifier") {
+            const name = left.text;
+            const isInternal = name === "__all__" || name === "__version__" || name === "__author__";
+            const isPrivate = name.startsWith("_") && !name.startsWith("__");
+            if (!isInternal && !isPrivate) {
+              exports2.push({
+                name,
+                type: name === name.toUpperCase() ? "const" : "variable",
+                loc: {
+                  start: {
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column
+                  },
+                  end: {
+                    line: node.endPosition.row + 1,
+                    column: node.endPosition.column
+                  }
+                }
+              });
+            }
+          }
+        }
       }
     }
+    return exports2;
   }
-  if (userConfig.output) {
-    result.output = { ...result.output, ...userConfig.output };
+  extractParameters(node) {
+    const paramsNode = node.childForFieldName("parameters");
+    if (!paramsNode) return [];
+    return paramsNode.children.filter(
+      (c) => c.type === "identifier" || c.type === "typed_parameter" || c.type === "default_parameter"
+    ).map((c) => {
+      if (c.type === "identifier") return c.text;
+      if (c.type === "typed_parameter" || c.type === "default_parameter") {
+        return c.firstChild?.text || "unknown";
+      }
+      return "unknown";
+    });
   }
-  return result;
-}
-
-// src/utils/visualization.ts
-function generateHTML(graph) {
-  const payload = JSON.stringify(graph, null, 2);
-  return `<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>AIReady Visualization</title>
-    <style>
-      html,body { height: 100%; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0 }
-      #container { display:flex; height:100vh }
-      #panel { width: 320px; padding: 16px; background: #071130; box-shadow: -2px 0 8px rgba(0,0,0,0.3); overflow:auto }
-      #canvasWrap { flex:1; display:flex; align-items:center; justify-content:center }
-      canvas { background: #0b1220; border-radius:8px }
-      .stat { margin-bottom:12px }
-    </style>
-  </head>
-  <body>
-    <div id="container">
-      <div id="canvasWrap"><canvas id="canvas" width="1200" height="800"></canvas></div>
-      <div id="panel">
-        <h2>AIReady Visualization</h2>
-        <div class="stat"><strong>Files:</strong> <span id="stat-files"></span></div>
-        <div class="stat"><strong>Dependencies:</strong> <span id="stat-deps"></span></div>
-        <div class="stat"><strong>Legend</strong></div>
-        <div style="font-size:13px;line-height:1.3;color:#cbd5e1;margin-top:8px">
-          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff4d4f;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Critical</strong>: highest severity issues.</div>
-          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff9900;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Major</strong>: important issues.</div>
-          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ffd666;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Minor</strong>: low priority issues.</div>
-          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#91d5ff;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Info</strong>: informational notes.</div>
-          <div style="margin-top:10px;color:#94a3b8"><strong>Node size</strong>: larger = higher token cost, more issues or dependency weight.</div>
-          <div style="margin-top:6px;color:#94a3b8"><strong>Proximity</strong>: nodes that are spatially close are more contextually related; relatedness is represented by distance and size rather than explicit edges.</div>
-          <div style="margin-top:6px;color:#94a3b8"><strong>Edge colors</strong>: <span style="color:#fb7e81">Similarity</span>, <span style="color:#84c1ff">Dependency</span>, <span style="color:#ffa500">Reference</span>, default <span style="color:#334155">Other</span>.</div>
-        </div>
-      </div>
-    </div>
-
-    <script>
-      const graphData = ${payload};
-      document.getElementById('stat-files').textContent = graphData.metadata.totalFiles;
-      document.getElementById('stat-deps').textContent = graphData.metadata.totalDependencies;
-
-      const canvas = document.getElementById('canvas');
-      const ctx = canvas.getContext('2d');
-
-      const nodes = graphData.nodes.map((n, i) => ({
-        ...n,
-        x: canvas.width / 2 + Math.cos(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
-        y: canvas.height / 2 + Math.sin(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
-      }));
-
-      function draw() {
-        ctx.clearRect(0, 0, canvas.width, canvas.height);
-
-        graphData.edges.forEach(edge => {
-          const s = nodes.find(n => n.id === edge.source);
-          const t = nodes.find(n => n.id === edge.target);
-          if (!s || !t) return;
-          if (edge.type === 'related') return;
-          if (edge.type === 'similarity') {
-            ctx.strokeStyle = '#fb7e81';
-            ctx.lineWidth = 1.2;
-          } else if (edge.type === 'dependency') {
-            ctx.strokeStyle = '#84c1ff';
-            ctx.lineWidth = 1.0;
-          } else if (edge.type === 'reference') {
-            ctx.strokeStyle = '#ffa500';
-            ctx.lineWidth = 0.9;
-          } else {
-            ctx.strokeStyle = '#334155';
-            ctx.lineWidth = 0.8;
-          }
-          ctx.beginPath();
-          ctx.moveTo(s.x, s.y);
-          ctx.lineTo(t.x, t.y);
-          ctx.stroke();
-        });
-
-        const groups = {};
-        nodes.forEach(n => {
-          const g = n.group || '__default';
-          if (!groups[g]) groups[g] = { minX: n.x, minY: n.y, maxX: n.x, maxY: n.y };
-          groups[g].minX = Math.min(groups[g].minX, n.x);
-          groups[g].minY = Math.min(groups[g].minY, n.y);
-          groups[g].maxX = Math.max(groups[g].maxX, n.x);
-          groups[g].maxY = Math.max(groups[g].maxY, n.y);
-        });
-
-        const groupRelations = {};
-        graphData.edges.forEach(edge => {
-          const sNode = nodes.find(n => n.id === edge.source);
-          const tNode = nodes.find(n => n.id === edge.target);
-          if (!sNode || !tNode) return;
-          const g1 = sNode.group || '__default';
-          const g2 = tNode.group || '__default';
-          if (g1 === g2) return;
-          const key = g1 < g2 ? g1 + '::' + g2 : g2 + '::' + g1;
-          groupRelations[key] = (groupRelations[key] || 0) + 1;
-        });
-
-        Object.keys(groupRelations).forEach(k => {
-          const count = groupRelations[k];
-          const [ga, gb] = k.split('::');
-          if (!groups[ga] || !groups[gb]) return;
-          const ax = (groups[ga].minX + groups[ga].maxX) / 2;
-          const ay = (groups[ga].minY + groups[ga].maxY) / 2;
-          const bx = (groups[gb].minX + groups[gb].maxX) / 2;
-          const by = (groups[gb].minY + groups[gb].maxY) / 2;
-          ctx.beginPath();
-          ctx.strokeStyle = 'rgba(148,163,184,0.25)';
-          ctx.lineWidth = Math.min(6, 0.6 + Math.sqrt(count));
-          ctx.moveTo(ax, ay);
-          ctx.lineTo(bx, by);
-          ctx.stroke();
-        });
-
-        Object.keys(groups).forEach(g => {
-          if (g === '__default') return;
-          const box = groups[g];
-          const pad = 16;
-          const x = box.minX - pad;
-          const y = box.minY - pad;
-          const w = (box.maxX - box.minX) + pad * 2;
-          const h = (box.maxY - box.minY) + pad * 2;
-          ctx.save();
-          ctx.fillStyle = 'rgba(30,64,175,0.04)';
-          ctx.strokeStyle = 'rgba(30,64,175,0.12)';
-          ctx.lineWidth = 1.2;
-          const r = 8;
-          ctx.beginPath();
-          ctx.moveTo(x + r, y);
-          ctx.arcTo(x + w, y, x + w, y + h, r);
-          ctx.arcTo(x + w, y + h, x, y + h, r);
-          ctx.arcTo(x, y + h, x, y, r);
-          ctx.arcTo(x, y, x + w, y, r);
-          ctx.closePath();
-          ctx.fill();
-          ctx.stroke();
-          ctx.restore();
-          ctx.fillStyle = '#94a3b8';
-          ctx.font = '11px sans-serif';
-          ctx.fillText(g, x + 8, y + 14);
-        });
-
-        nodes.forEach(n => {
-          const sizeVal = (n.size || n.value || 1);
-          const r = 6 + (sizeVal / 2);
-          ctx.beginPath();
-          ctx.fillStyle = n.color || '#60a5fa';
-          ctx.arc(n.x, n.y, r, 0, Math.PI * 2);
-          ctx.fill();
-
-          ctx.fillStyle = '#e2e8f0';
-          ctx.font = '11px sans-serif';
-          ctx.textAlign = 'center';
-          ctx.fillText(n.label || n.id.split('/').slice(-1)[0], n.x, n.y + r + 12);
-        });
-      }
-
-      draw();
-    </script>
-  </body>
-</html>`;
-}
-
-// src/scoring.ts
-var DEFAULT_TOOL_WEIGHTS = {
-  ["pattern-detect" /* PatternDetect */]: 22,
-  ["context-analyzer" /* ContextAnalyzer */]: 19,
-  ["naming-consistency" /* NamingConsistency */]: 14,
-  ["ai-signal-clarity" /* AiSignalClarity */]: 11,
-  ["agent-grounding" /* AgentGrounding */]: 10,
-  ["testability-index" /* TestabilityIndex */]: 10,
-  ["doc-drift" /* DocDrift */]: 8,
-  ["dependency-health" /* DependencyHealth */]: 6,
-  ["change-amplification" /* ChangeAmplification */]: 8
-};
-var TOOL_NAME_MAP = {
-  patterns: "pattern-detect" /* PatternDetect */,
-  "pattern-detect": "pattern-detect" /* PatternDetect */,
-  context: "context-analyzer" /* ContextAnalyzer */,
-  "context-analyzer": "context-analyzer" /* ContextAnalyzer */,
-  consistency: "naming-consistency" /* NamingConsistency */,
-  "naming-consistency": "naming-consistency" /* NamingConsistency */,
-  "ai-signal": "ai-signal-clarity" /* AiSignalClarity */,
-  "ai-signal-clarity": "ai-signal-clarity" /* AiSignalClarity */,
-  grounding: "agent-grounding" /* AgentGrounding */,
-  "agent-grounding": "agent-grounding" /* AgentGrounding */,
-  testability: "testability-index" /* TestabilityIndex */,
-  "testability-index": "testability-index" /* TestabilityIndex */,
-  "doc-drift": "doc-drift" /* DocDrift */,
-  "deps-health": "dependency-health" /* DependencyHealth */,
-  "dependency-health": "dependency-health" /* DependencyHealth */,
-  "change-amp": "change-amplification" /* ChangeAmplification */,
-  "change-amplification": "change-amplification" /* ChangeAmplification */
-};
-var CONTEXT_TIER_THRESHOLDS = {
-  compact: { idealTokens: 3e3, criticalTokens: 1e4, idealDepth: 4 },
-  standard: { idealTokens: 5e3, criticalTokens: 15e3, idealDepth: 5 },
-  extended: { idealTokens: 15e3, criticalTokens: 5e4, idealDepth: 7 },
-  frontier: { idealTokens: 5e4, criticalTokens: 15e4, idealDepth: 10 }
-};
-var SIZE_ADJUSTED_THRESHOLDS = {
-  xs: 80,
-  // < 50 files
-  small: 75,
-  // 50-200 files
-  medium: 70,
-  // 200-500 files
-  large: 65,
-  // 500-2000 files
-  enterprise: 58
-  // 2000+ files
-};
-function getProjectSizeTier(fileCount) {
-  if (fileCount < 50) return "xs";
-  if (fileCount < 200) return "small";
-  if (fileCount < 500) return "medium";
-  if (fileCount < 2e3) return "large";
-  return "enterprise";
-}
-function getRecommendedThreshold(fileCount, modelTier = "standard") {
-  const sizeTier = getProjectSizeTier(fileCount);
-  const base = SIZE_ADJUSTED_THRESHOLDS[sizeTier];
-  const modelBonus = modelTier === "frontier" ? -3 : modelTier === "extended" ? -2 : 0;
-  return base + modelBonus;
-}
-function normalizeToolName(shortName) {
-  return TOOL_NAME_MAP[shortName.toLowerCase()] || shortName;
-}
-function getToolWeight(toolName, toolConfig, cliOverride) {
-  if (cliOverride !== void 0) return cliOverride;
-  if (toolConfig?.scoreWeight !== void 0) return toolConfig.scoreWeight;
-  return DEFAULT_TOOL_WEIGHTS[toolName] || 5;
-}
-function parseWeightString(weightStr) {
-  const weights = /* @__PURE__ */ new Map();
-  if (!weightStr) return weights;
-  const pairs = weightStr.split(",");
-  for (const pair of pairs) {
-    const [toolShortName, weightStr2] = pair.split(":");
-    if (toolShortName && weightStr2) {
-      const toolName = normalizeToolName(toolShortName.trim());
-      const weight = parseInt(weightStr2.trim(), 10);
-      if (!isNaN(weight) && weight > 0) {
-        weights.set(toolName, weight);
-      }
-    }
-  }
-  return weights;
-}
-function calculateOverallScore(toolOutputs, config, cliWeights) {
-  if (toolOutputs.size === 0) {
-    throw new Error("No tool outputs provided for scoring");
-  }
-  const weights = /* @__PURE__ */ new Map();
-  for (const [toolName] of toolOutputs.entries()) {
-    const cliWeight = cliWeights?.get(toolName);
-    const configWeight = config?.tools?.[toolName]?.scoreWeight;
-    const weight = cliWeight ?? configWeight ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? 5;
-    weights.set(toolName, weight);
-  }
-  let weightedSum = 0;
-  let totalWeight = 0;
-  const breakdown = [];
-  const toolsUsed = [];
-  const calculationWeights = {};
-  for (const [toolName, output] of toolOutputs.entries()) {
-    const weight = weights.get(toolName) || 5;
-    weightedSum += output.score * weight;
-    totalWeight += weight;
-    toolsUsed.push(toolName);
-    calculationWeights[toolName] = weight;
-    breakdown.push(output);
-  }
-  const overall = Math.round(weightedSum / totalWeight);
-  const rating = getRating(overall);
-  const formulaParts = Array.from(toolOutputs.entries()).map(
-    ([name, output]) => {
-      const w = weights.get(name) || 5;
-      return `(${output.score} \xD7 ${w})`;
-    }
-  );
-  const formulaStr = `[${formulaParts.join(" + ")}] / ${totalWeight} = ${overall}`;
-  return {
-    overall,
-    rating,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    toolsUsed,
-    breakdown,
-    calculation: {
-      formula: formulaStr,
-      weights: calculationWeights,
-      normalized: formulaStr
-    }
-  };
-}
-function getRating(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;
-  return getRating(normalized);
-}
-function getRatingDisplay(rating) {
-  switch (rating) {
-    case "Excellent":
-      return { emoji: "\u2705", color: "green" };
-    case "Good":
-      return { emoji: "\u{1F44D}", color: "blue" };
-    case "Fair":
-      return { emoji: "\u26A0\uFE0F", color: "yellow" };
-    case "Needs Work":
-      return { emoji: "\u{1F528}", color: "orange" };
-    case "Critical":
-      return { emoji: "\u274C", color: "red" };
-  }
-}
-function formatScore(result) {
-  const { emoji } = getRatingDisplay(result.rating);
-  return `${result.overall}/100 (${result.rating}) ${emoji}`;
-}
-function formatToolScore(output) {
-  let result = `  Score: ${output.score}/100
-
-`;
-  if (output.factors && output.factors.length > 0) {
-    result += `  Factors:
-`;
-    output.factors.forEach((factor) => {
-      const impactSign = factor.impact > 0 ? "+" : "";
-      result += `    \u2022 ${factor.name}: ${impactSign}${factor.impact} - ${factor.description}
-`;
-    });
-    result += "\n";
-  }
-  if (output.recommendations && output.recommendations.length > 0) {
-    result += `  Recommendations:
-`;
-    output.recommendations.forEach((rec, i) => {
-      const priorityIcon = rec.priority === "high" ? "\u{1F534}" : rec.priority === "medium" ? "\u{1F7E1}" : "\u{1F535}";
-      result += `    ${i + 1}. ${priorityIcon} ${rec.action}
-`;
-      result += `       Impact: +${rec.estimatedImpact} points
-
-`;
-    });
-  }
-  return result;
-}
-
-// src/business/pricing-models.ts
-var MODEL_PRICING_PRESETS = {
-  "gpt-5.3": {
-    name: "GPT-5.3",
-    pricePer1KInputTokens: 2e-3,
-    pricePer1KOutputTokens: 8e-3,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 100
-  },
-  "claude-4.6": {
-    name: "Claude 4.6",
-    pricePer1KInputTokens: 15e-4,
-    pricePer1KOutputTokens: 75e-4,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 100
-  },
-  "gemini-3.1": {
-    name: "Gemini 3.1 Pro",
-    pricePer1KInputTokens: 8e-4,
-    pricePer1KOutputTokens: 3e-3,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 120
-  },
-  "gpt-4o": {
-    name: "GPT-4o (legacy)",
-    pricePer1KInputTokens: 5e-3,
-    pricePer1KOutputTokens: 0.015,
-    contextTier: "extended",
-    typicalQueriesPerDevPerDay: 60
-  },
-  "claude-3-5-sonnet": {
-    name: "Claude 3.5 Sonnet (legacy)",
-    pricePer1KInputTokens: 3e-3,
-    pricePer1KOutputTokens: 0.015,
-    contextTier: "extended",
-    typicalQueriesPerDevPerDay: 80
-  },
-  "gemini-1-5-pro": {
-    name: "Gemini 1.5 Pro (legacy)",
-    pricePer1KInputTokens: 125e-5,
-    pricePer1KOutputTokens: 5e-3,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 80
-  },
-  copilot: {
-    name: "GitHub Copilot (subscription)",
-    pricePer1KInputTokens: 8e-5,
-    pricePer1KOutputTokens: 8e-5,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 150
-  },
-  "cursor-pro": {
-    name: "Cursor Pro (subscription)",
-    pricePer1KInputTokens: 8e-5,
-    pricePer1KOutputTokens: 8e-5,
-    contextTier: "frontier",
-    typicalQueriesPerDevPerDay: 200
-  }
-};
-function getModelPreset(modelId) {
-  return MODEL_PRICING_PRESETS[modelId] ?? MODEL_PRICING_PRESETS["claude-4.6"];
-}
-
-// src/business/cost-metrics.ts
-var DEFAULT_COST_CONFIG = {
-  pricePer1KTokens: 5e-3,
-  queriesPerDevPerDay: 60,
-  developerCount: 5,
-  daysPerMonth: 30
-};
-function calculateMonthlyCost(tokenWaste, config = {}) {
-  const budget = calculateTokenBudget({
-    totalContextTokens: tokenWaste * 2.5,
-    wastedTokens: {
-      duplication: tokenWaste * 0.7,
-      fragmentation: tokenWaste * 0.3,
-      chattiness: 0
-    }
-  });
-  const preset = getModelPreset("claude-4.6");
-  return estimateCostFromBudget(budget, preset, config);
-}
-function calculateTokenBudget(params) {
-  const { totalContextTokens, wastedTokens } = params;
-  const estimatedResponseTokens = params.estimatedResponseTokens ?? totalContextTokens * 0.2;
-  const totalWaste = wastedTokens.duplication + wastedTokens.fragmentation + wastedTokens.chattiness;
-  const efficiencyRatio = Math.max(
-    0,
-    Math.min(
-      1,
-      (totalContextTokens - totalWaste) / Math.max(1, totalContextTokens)
-    )
-  );
-  return {
-    totalContextTokens: Math.round(totalContextTokens),
-    estimatedResponseTokens: Math.round(estimatedResponseTokens),
-    wastedTokens: {
-      total: Math.round(totalWaste),
-      bySource: {
-        duplication: Math.round(wastedTokens.duplication),
-        fragmentation: Math.round(wastedTokens.fragmentation),
-        chattiness: Math.round(wastedTokens.chattiness)
-      }
-    },
-    efficiencyRatio: Math.round(efficiencyRatio * 100) / 100,
-    potentialRetrievableTokens: Math.round(totalWaste * 0.8)
-  };
-}
-function estimateCostFromBudget(budget, model, config = {}) {
-  const cfg = { ...DEFAULT_COST_CONFIG, ...config };
-  const wastePerQuery = budget.wastedTokens.total;
-  const tokensPerDay = wastePerQuery * cfg.queriesPerDevPerDay;
-  const tokensPerMonth = tokensPerDay * cfg.daysPerMonth;
-  const totalWeight = cfg.developerCount;
-  const price = config.pricePer1KTokens ?? model.pricePer1KInputTokens;
-  const baseCost = tokensPerMonth / 1e3 * price * totalWeight;
-  let confidence = 0.85;
-  if (model.contextTier === "frontier") confidence = 0.7;
-  const variance = 0.25;
-  const range = [
-    Math.round(baseCost * (1 - variance) * 100) / 100,
-    Math.round(baseCost * (1 + variance) * 100) / 100
-  ];
-  return {
-    total: Math.round(baseCost * 100) / 100,
-    range,
-    confidence
-  };
-}
-
-// src/business/productivity-metrics.ts
-var SEVERITY_TIME_ESTIMATES = {
-  ["critical" /* Critical */]: 4,
-  ["major" /* Major */]: 2,
-  ["minor" /* Minor */]: 0.5,
-  ["info" /* Info */]: 0.25
-};
-var DEFAULT_HOURLY_RATE = 75;
-function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
-  const counts = {
-    ["critical" /* Critical */]: issues.filter((i) => i.severity === "critical" /* Critical */).length,
-    ["major" /* Major */]: issues.filter((i) => i.severity === "major" /* Major */).length,
-    ["minor" /* Minor */]: issues.filter((i) => i.severity === "minor" /* Minor */).length,
-    ["info" /* Info */]: issues.filter((i) => i.severity === "info" /* Info */).length
-  };
-  const hours = {
-    ["critical" /* Critical */]: counts["critical" /* Critical */] * SEVERITY_TIME_ESTIMATES["critical" /* Critical */],
-    ["major" /* Major */]: counts["major" /* Major */] * SEVERITY_TIME_ESTIMATES["major" /* Major */],
-    ["minor" /* Minor */]: counts["minor" /* Minor */] * SEVERITY_TIME_ESTIMATES["minor" /* Minor */],
-    ["info" /* Info */]: counts["info" /* Info */] * SEVERITY_TIME_ESTIMATES["info" /* Info */]
-  };
-  const totalHours = hours["critical" /* Critical */] + hours["major" /* Major */] + hours["minor" /* Minor */] + hours["info" /* Info */];
-  const totalCost = totalHours * hourlyRate;
-  return {
-    totalHours: Math.round(totalHours * 10) / 10,
-    hourlyRate,
-    totalCost: Math.round(totalCost),
-    bySeverity: {
-      ["critical" /* Critical */]: {
-        hours: Math.round(hours["critical" /* Critical */] * 10) / 10,
-        cost: Math.round(hours["critical" /* Critical */] * hourlyRate)
-      },
-      ["major" /* Major */]: {
-        hours: Math.round(hours["major" /* Major */] * 10) / 10,
-        cost: Math.round(hours["major" /* Major */] * hourlyRate)
-      },
-      ["minor" /* Minor */]: {
-        hours: Math.round(hours["minor" /* Minor */] * 10) / 10,
-        cost: Math.round(hours["minor" /* Minor */] * hourlyRate)
-      },
-      ["info" /* Info */]: {
-        hours: Math.round(hours["info" /* Info */] * 10) / 10,
-        cost: Math.round(hours["info" /* Info */] * hourlyRate)
-      }
+  parseRegex(code, filePath) {
+    try {
+      const imports = this.extractImportsRegex(code, filePath);
+      const exports2 = this.extractExportsRegex(code, filePath);
+      return {
+        exports: exports2,
+        imports,
+        language: "python" /* Python */,
+        warnings: [
+          "Python parsing is currently using regex-based extraction as tree-sitter wasm was not available."
+        ]
+      };
+    } catch (error) {
+      throw new ParseError(
+        `Failed to parse Python file ${filePath}: ${error.message}`,
+        filePath
+      );
     }
-  };
-}
-function predictAcceptanceRate(toolOutputs) {
-  const factors = [];
-  const baseRate = 0.3;
-  const patterns = toolOutputs.get("pattern-detect");
-  if (patterns) {
-    factors.push({
-      name: "Semantic Duplication",
-      impact: Math.round((patterns.score - 50) * 3e-3 * 100)
-    });
   }
-  const context = toolOutputs.get("context-analyzer");
-  if (context) {
-    factors.push({
-      name: "Context Efficiency",
-      impact: Math.round((context.score - 50) * 4e-3 * 100)
-    });
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-z_][a-z0-9_]*$/,
+      functionPattern: /^[a-z_][a-z0-9_]*$/,
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      exceptions: [
+        "__init__",
+        "__str__",
+        "__repr__",
+        "__name__",
+        "__main__",
+        "__file__",
+        "__doc__",
+        "__all__",
+        "__version__",
+        "__author__",
+        "__dict__",
+        "__class__",
+        "__module__",
+        "__bases__"
+      ]
+    };
   }
-  const consistency = toolOutputs.get("consistency");
-  if (consistency) {
-    factors.push({
-      name: "Code Consistency",
-      impact: Math.round((consistency.score - 50) * 2e-3 * 100)
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".py");
+  }
+  extractImportsRegex(code, _filePath) {
+    const imports = [];
+    const lines = code.split("\n");
+    const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
+    const fromImportRegex = /^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)/;
+    lines.forEach((line, idx) => {
+      if (line.trim().startsWith("#")) return;
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const modules = importMatch[1].split(",").map((m) => m.trim().split(" as ")[0]);
+        modules.forEach((module2) => {
+          imports.push({
+            source: module2,
+            specifiers: [module2],
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        });
+        return;
+      }
+      const fromMatch = line.match(fromImportRegex);
+      if (fromMatch) {
+        const module2 = fromMatch[1];
+        const imports_str = fromMatch[2];
+        if (imports_str.trim() === "*") {
+          imports.push({
+            source: module2,
+            specifiers: ["*"],
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+          return;
+        }
+        const specifiers = imports_str.split(",").map((s) => s.trim().split(" as ")[0]);
+        imports.push({
+          source: module2,
+          specifiers,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
     });
+    return imports;
   }
-  const aiSignalClarity = toolOutputs.get("ai-signal-clarity");
-  if (aiSignalClarity) {
-    factors.push({
-      name: "AI Signal Clarity",
-      impact: Math.round((50 - aiSignalClarity.score) * 2e-3 * 100)
+  extractExportsRegex(code, _filePath) {
+    const exports2 = [];
+    const lines = code.split("\n");
+    const functionRegex = /^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
+    const classRegex = /^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/;
+    const allRegex = /__all__\s*=\s*\[([^\]]+)\]/;
+    let inClass = false;
+    let classIndent = 0;
+    lines.forEach((line, idx) => {
+      const indent = line.search(/\S/);
+      if (line.match(classRegex)) {
+        inClass = true;
+        classIndent = indent;
+      } else if (inClass && indent <= classIndent && line.trim()) {
+        inClass = false;
+      }
+      if (inClass) {
+        const classMatch = line.match(classRegex);
+        if (classMatch) {
+          exports2.push({
+            name: classMatch[1],
+            type: "class",
+            loc: {
+              start: { line: idx + 1, column: indent },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        }
+        return;
+      }
+      const funcMatch = line.match(functionRegex);
+      if (funcMatch && indent === 0) {
+        const name = funcMatch[1];
+        if (!name.startsWith("_") || name.startsWith("__")) {
+          exports2.push({
+            name,
+            type: "function",
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        }
+      }
+      const allMatch = line.match(allRegex);
+      if (allMatch) {
+        const names = allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, ""));
+        names.forEach((name) => {
+          if (name && !exports2.find((e) => e.name === name)) {
+            exports2.push({
+              name,
+              type: "variable",
+              loc: {
+                start: { line: idx + 1, column: 0 },
+                end: { line: idx + 1, column: line.length }
+              }
+            });
+          }
+        });
+      }
     });
+    return exports2;
   }
-  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;
-  else if (toolOutputs.size >= 3) confidence = 0.65;
-  else if (toolOutputs.size >= 2) confidence = 0.5;
-  return { rate: Math.round(rate * 100) / 100, confidence, factors };
-}
+};
 
-// src/business/risk-metrics.ts
-function calculateKnowledgeConcentration(params) {
-  const { uniqueConceptFiles, totalFiles, singleAuthorFiles, orphanFiles } = params;
-  const concentrationRatio = totalFiles > 0 ? (uniqueConceptFiles + singleAuthorFiles) / (totalFiles * 2) : 0;
-  const score = Math.round(
-    Math.min(
-      100,
-      concentrationRatio * 100 + orphanFiles / Math.max(1, totalFiles) * 20
-    )
-  );
-  let rating;
-  if (score < 30) rating = "low";
-  else if (score < 50) rating = "moderate";
-  else if (score < 75) rating = "high";
-  else rating = "critical";
-  const recommendations = [];
-  if (singleAuthorFiles > 0)
-    recommendations.push(
-      `Distribute knowledge for ${singleAuthorFiles} single-author files.`
-    );
-  if (orphanFiles > 0)
-    recommendations.push(
-      `Link ${orphanFiles} orphan files to the rest of the codebase.`
+// src/parsers/parser-factory.ts
+var ParserFactory = class _ParserFactory {
+  constructor() {
+    this.parsers = /* @__PURE__ */ new Map();
+    this.extensionMap = new Map(
+      Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
     );
-  return {
-    score,
-    rating,
-    recommendations,
-    analysis: {
-      uniqueConceptFiles,
-      totalFiles,
-      concentrationRatio,
-      singleAuthorFiles,
-      orphanFiles
-    }
-  };
-}
-function calculateDebtInterest(principal, monthlyGrowthRate) {
-  const monthlyRate = monthlyGrowthRate;
-  const annualRate = Math.pow(1 + monthlyRate, 12) - 1;
-  const monthlyCost = principal * monthlyRate;
-  return {
-    monthlyRate,
-    annualRate,
-    principal,
-    monthlyCost,
-    projections: {
-      months6: principal * Math.pow(1 + monthlyRate, 6),
-      months12: principal * Math.pow(1 + monthlyRate, 12),
-      months24: principal * Math.pow(1 + monthlyRate, 24)
-    }
-  };
-}
-
-// src/business/comprehension-metrics.ts
-function calculateTechnicalValueChain(params) {
-  const { businessLogicDensity, dataAccessComplexity, apiSurfaceArea } = params;
-  const score = (businessLogicDensity * 0.5 + (1 - dataAccessComplexity / 10) * 0.3 + (1 - apiSurfaceArea / 20) * 0.2) * 100;
-  return {
-    score: Math.round(Math.max(0, Math.min(100, score))),
-    density: businessLogicDensity,
-    complexity: dataAccessComplexity,
-    surface: apiSurfaceArea
-  };
-}
-function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentation, modelTier = "frontier") {
-  const tierMap = {
-    compact: "compact",
-    standard: "standard",
-    extended: "extended",
-    frontier: "frontier",
-    easy: "frontier",
-    // Map legacy 'easy' to 'frontier'
-    moderate: "standard",
-    difficult: "compact"
-  };
-  const tier = tierMap[modelTier] || "frontier";
-  const threshold = CONTEXT_TIER_THRESHOLDS[tier];
-  const budgetRatio = contextBudget / threshold.idealTokens;
-  const score = (budgetRatio * 0.6 + importDepth / 10 * 0.2 + fragmentation * 0.2) * 100;
-  const finalScore = Math.round(Math.max(0, Math.min(100, score)));
-  let rating;
-  if (finalScore < 20) rating = "trivial";
-  else if (finalScore < 40) rating = "easy";
-  else if (finalScore < 60) rating = "moderate";
-  else if (finalScore < 85) rating = "difficult";
-  else rating = "expert";
-  return {
-    score: finalScore,
-    rating,
-    factors: { budgetRatio, depthRatio: importDepth / 10, fragmentation }
-  };
-}
-
-// src/business-metrics.ts
-function calculateBusinessROI(params) {
-  const model = getModelPreset(params.modelId || "claude-4.6");
-  const devCount = params.developerCount || 5;
-  const budget = calculateTokenBudget({
-    totalContextTokens: params.tokenWaste * 2.5,
-    wastedTokens: {
-      duplication: params.tokenWaste * 0.7,
-      fragmentation: params.tokenWaste * 0.3,
-      chattiness: 0
+    this.registerParser(new TypeScriptParser());
+    this.registerParser(new PythonParser());
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!_ParserFactory.instance) {
+      _ParserFactory.instance = new _ParserFactory();
     }
-  });
-  const cost = estimateCostFromBudget(budget, model, {
-    developerCount: devCount
-  });
-  const productivity = calculateProductivityImpact(params.issues);
-  const monthlySavings = cost.total;
-  const productivityGainHours = productivity.totalHours;
-  const annualValue = (monthlySavings + productivityGainHours * 75) * 12;
-  return {
-    monthlySavings: Math.round(monthlySavings),
-    productivityGainHours: Math.round(productivityGainHours),
-    annualValue: Math.round(annualValue)
-  };
-}
-function formatCost(cost) {
-  if (cost < 1) {
-    return `$${cost.toFixed(2)}`;
-  } else if (cost < 1e3) {
-    return `$${cost.toFixed(0)}`;
-  } else {
-    return `$${(cost / 1e3).toFixed(1)}k`;
+    return _ParserFactory.instance;
+  }
+  /**
+   * Register a language parser
+   */
+  registerParser(parser) {
+    this.parsers.set(parser.language, parser);
+    parser.extensions.forEach((ext) => {
+      const lang = LANGUAGE_EXTENSIONS[ext] || parser.language;
+      this.extensionMap.set(ext, lang);
+      this.parsers.set(lang, parser);
+    });
+  }
+  /**
+   * Get parser for a specific language
+   */
+  getParserForLanguage(language) {
+    return this.parsers.get(language) || null;
+  }
+  /**
+   * Get parser for a file based on its extension
+   */
+  getParserForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    const language = this.extensionMap.get(ext);
+    if (!language) {
+      return null;
+    }
+    return this.parsers.get(language) || null;
   }
-}
-function formatHours(hours) {
-  if (hours < 1) {
-    return `${Math.round(hours * 60)}min`;
-  } else if (hours < 8) {
-    return `${hours.toFixed(1)}h`;
-  } else if (hours < 40) {
-    return `${Math.round(hours)}h`;
-  } else {
-    return `${(hours / 40).toFixed(1)} weeks`;
+  /**
+   * Check if a file is supported
+   */
+  isSupported(filePath) {
+    return this.getParserForFile(filePath) !== null;
+  }
+  /**
+   * Get all registered languages
+   */
+  getSupportedLanguages() {
+    return Array.from(this.parsers.keys());
+  }
+  /**
+   * Get all supported file extensions
+   */
+  getSupportedExtensions() {
+    return Array.from(this.extensionMap.keys());
+  }
+  /**
+   * Get language for a file
+   */
+  getLanguageForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    return this.extensionMap.get(ext) || null;
+  }
+  /**
+   * Extract file extension (with dot)
+   */
+  getFileExtension(filePath) {
+    const match = filePath.match(/\.[^.]+$/);
+    return match ? match[0].toLowerCase() : "";
+  }
+  /**
+   * Reset factory (useful for testing)
+   */
+  static reset() {
+    _ParserFactory.instance = new _ParserFactory();
+  }
+  /**
+   * Initialize all registered parsers
+   */
+  async initializeAll() {
+    const promises = Array.from(this.parsers.values()).map(
+      (p) => p.initialize()
+    );
+    await Promise.all(promises);
   }
+};
+function getParser(filePath) {
+  return ParserFactory.getInstance().getParserForFile(filePath);
 }
-function formatAcceptanceRate(rate) {
-  return `${Math.round(rate * 100)}%`;
+async function initializeParsers() {
+  await ParserFactory.getInstance().initializeAll();
 }
-function generateValueChain(params) {
-  const { issueType, count, severity } = params;
-  const impacts = {
-    "duplicate-pattern": {
-      ai: "Ambiguous context leads to code generation variants. AI picks wrong implementation 40% of the time.",
-      dev: "Developers must manually resolve conflicts between suggested variants.",
-      risk: "high"
-    },
-    "context-fragmentation": {
-      ai: "Context window overflow causes model to forget mid-file dependencies resulting in hallucinations.",
-      dev: "Slower AI responses and increased need for manual context pinning.",
-      risk: "critical"
-    },
-    "naming-inconsistency": {
-      ai: "Degraded intent inference. AI misidentifies domain concepts across file boundaries.",
-      dev: "Increased cognitive load for new devs during onboarding.",
-      risk: "moderate"
-    }
-  };
-  const impact = impacts[issueType] || {
-    ai: "Reduced suggestion quality.",
-    dev: "Slowed development velocity.",
-    risk: "moderate"
-  };
-  const productivityLoss = severity === "critical" ? 0.25 : severity === "major" ? 0.1 : 0.05;
-  return {
-    issueType,
-    technicalMetric: "Issue Count",
-    technicalValue: count,
-    aiImpact: {
-      description: impact.ai,
-      scoreImpact: severity === "critical" ? -15 : -5
-    },
-    developerImpact: {
-      description: impact.dev,
-      productivityLoss
-    },
-    businessOutcome: {
-      directCost: count * 12,
-      opportunityCost: productivityLoss * 15e3,
-      riskLevel: impact.risk
-    }
-  };
+function isFileSupported(filePath) {
+  return ParserFactory.getInstance().isSupported(filePath);
+}
+function getSupportedLanguages() {
+  return ParserFactory.getInstance().getSupportedLanguages();
 }
 
-// src/parsers/typescript-parser.ts
-var import_typescript_estree2 = require("@typescript-eslint/typescript-estree");
-var TypeScriptParser = class {
-  constructor() {
-    this.language = "typescript" /* TypeScript */;
-    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
-  }
-  parse(code, filePath) {
+// src/utils/ast-parser.ts
+function parseFileExports(code, filePath) {
+  const parser = getParser(filePath);
+  if (parser && parser.language === "python" /* Python */) {
     try {
-      const isJavaScript = filePath.match(/\.jsx?$/i);
-      const ast = (0, import_typescript_estree2.parse)(code, {
-        loc: true,
-        range: true,
-        jsx: filePath.match(/\.[jt]sx$/i) !== null,
-        filePath,
-        sourceType: "module",
-        ecmaVersion: "latest"
-      });
-      const imports = this.extractImports(ast);
-      const exports2 = this.extractExports(ast, imports);
+      const result = parser.parse(code, filePath);
       return {
-        exports: exports2,
-        imports,
-        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
-        warnings: []
+        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 (error) {
-      const err = error;
-      throw new ParseError(
-        `Failed to parse ${filePath}: ${err.message}`,
-        filePath
-      );
+    } catch (e) {
+      return { exports: [], imports: [] };
     }
   }
-  getNamingConventions() {
-    return {
-      // camelCase for variables and functions
-      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
-      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-      // PascalCase for classes
-      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      // UPPER_CASE for constants
-      constantPattern: /^[A-Z][A-Z0-9_]*$/,
-      // Common exceptions (React hooks, etc.)
-      exceptions: ["__filename", "__dirname", "__esModule"]
-    };
+  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: [] };
+  }
+}
+function extractFileImports(ast) {
+  const imports = [];
+  for (const node of ast.body) {
+    if (node.type === "ImportDeclaration") {
+      const source = node.source.value;
+      const specifiers = [];
+      const isTypeOnly = node.importKind === "type";
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          const imported = spec.imported;
+          const importName = imported.type === "Identifier" ? imported.name : imported.value;
+          specifiers.push(importName);
+        } else if (spec.type === "ImportDefaultSpecifier") {
+          specifiers.push("default");
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          specifiers.push("*");
+        }
+      }
+      imports.push({ source, specifiers, isTypeOnly });
+    }
+  }
+  return imports;
+}
+function extractExportsWithDependencies(ast, fileImports) {
+  const exports2 = [];
+  const importedNames = new Set(fileImports.flatMap((imp) => imp.specifiers));
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration") {
+      if (node.declaration) {
+        const exportNodes = extractFromDeclaration(node.declaration);
+        for (const exp of exportNodes) {
+          const usedImports = findUsedImports(node.declaration, importedNames);
+          const typeReferences = extractTypeReferences(node.declaration);
+          exports2.push({
+            ...exp,
+            imports: usedImports,
+            dependencies: [],
+            typeReferences,
+            loc: node.loc
+          });
+        }
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      const usedImports = findUsedImports(node.declaration, importedNames);
+      const typeReferences = extractTypeReferences(node.declaration);
+      exports2.push({
+        name: "default",
+        type: "default",
+        imports: usedImports,
+        dependencies: [],
+        typeReferences,
+        loc: node.loc
+      });
+    }
+  }
+  return exports2;
+}
+function extractFromDeclaration(declaration) {
+  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" });
+      }
+    }
+  } 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" });
+  }
+  return results;
+}
+function findUsedImports(node, importedNames) {
+  const usedImports = /* @__PURE__ */ new Set();
+  function visit(n) {
+    if (n.type === "Identifier" && importedNames.has(n.name)) {
+      usedImports.add(n.name);
+    }
+    for (const key in n) {
+      const value = n[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          value.forEach((child) => {
+            if (child && typeof child === "object" && "type" in child) {
+              visit(child);
+            }
+          });
+        } else if ("type" in value) {
+          visit(value);
+        }
+      }
+    }
   }
-  canHandle(filePath) {
-    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
+  visit(node);
+  return Array.from(usedImports);
+}
+function calculateImportSimilarity(export1, export2) {
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1;
   }
-  extractImports(ast) {
-    const imports = [];
-    for (const node of ast.body) {
-      if (node.type === "ImportDeclaration") {
-        const specifiers = [];
-        let isTypeOnly = false;
-        if (node.importKind === "type") {
-          isTypeOnly = true;
-        }
-        for (const spec of node.specifiers) {
-          if (spec.type === "ImportSpecifier") {
-            const imported = spec.imported;
-            const name = imported.type === "Identifier" ? imported.name : imported.value;
-            specifiers.push(name);
-          } else if (spec.type === "ImportDefaultSpecifier") {
-            specifiers.push("default");
-          } else if (spec.type === "ImportNamespaceSpecifier") {
-            specifiers.push("*");
+  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) {
+    if (!n || typeof n !== "object") return;
+    if (n.type === "TSTypeReference" && n.typeName) {
+      if (n.typeName.type === "Identifier") {
+        types.add(n.typeName.name);
+      } else if (n.typeName.type === "TSQualifiedName") {
+        let current = n.typeName;
+        while (current.type === "TSQualifiedName") {
+          if (current.right?.type === "Identifier") {
+            types.add(current.right.name);
           }
+          current = current.left;
+        }
+        if (current.type === "Identifier") {
+          types.add(current.name);
         }
-        imports.push({
-          source: node.source.value,
-          specifiers,
-          isTypeOnly,
-          loc: node.loc ? {
-            start: {
-              line: node.loc.start.line,
-              column: node.loc.start.column
-            },
-            end: { line: node.loc.end.line, column: node.loc.end.column }
-          } : void 0
-        });
       }
     }
-    return imports;
-  }
-  extractExports(ast, imports) {
-    const exports2 = [];
-    const importedNames = new Set(
-      imports.flatMap(
-        (imp) => imp.specifiers.filter((s) => s !== "*" && s !== "default")
-      )
-    );
-    for (const node of ast.body) {
-      if (node.type === "ExportNamedDeclaration" && node.declaration) {
-        const extracted = this.extractFromDeclaration(
-          node.declaration,
-          importedNames
-        );
-        exports2.push(...extracted);
-      } else if (node.type === "ExportDefaultDeclaration") {
-        let name = "default";
-        let type = "default";
-        if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-          name = node.declaration.id.name;
-          type = "function";
-        } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
-          name = node.declaration.id.name;
-          type = "class";
-        }
-        exports2.push({
-          name,
-          type,
-          loc: node.loc ? {
-            start: {
-              line: node.loc.start.line,
-              column: node.loc.start.column
-            },
-            end: { line: node.loc.end.line, column: node.loc.end.column }
-          } : void 0
-        });
+    if (n.type === "TSInterfaceHeritage" && n.expression) {
+      if (n.expression.type === "Identifier") {
+        types.add(n.expression.name);
+      }
+    }
+    for (const key of Object.keys(n)) {
+      const value = n[key];
+      if (Array.isArray(value)) {
+        value.forEach(visit);
+      } else if (value && typeof value === "object") {
+        visit(value);
       }
     }
-    return exports2;
   }
-  extractFromDeclaration(declaration, importedNames) {
-    const exports2 = [];
-    if (declaration.type === "FunctionDeclaration" && declaration.id) {
-      exports2.push({
-        name: declaration.id.name,
-        type: "function",
-        parameters: declaration.params.map(
-          (p) => p.type === "Identifier" ? p.name : "unknown"
-        ),
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
+  visit(node);
+  return Array.from(types);
+}
+function parseCode(code, language) {
+  return null;
+}
+function extractFunctions(ast) {
+  return [];
+}
+function extractImports(ast) {
+  return [];
+}
+
+// src/utils/metrics.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// src/utils/config.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_url = require("url");
+var CONFIG_FILES = [
+  "aiready.json",
+  "aiready.config.json",
+  ".aiready.json",
+  ".aireadyrc.json",
+  "aiready.config.js",
+  ".aireadyrc.js"
+];
+async function loadConfig(rootDir) {
+  let currentDir = (0, import_path3.resolve)(rootDir);
+  while (true) {
+    for (const configFile of CONFIG_FILES) {
+      const configPath = (0, import_path3.join)(currentDir, configFile);
+      if ((0, import_fs3.existsSync)(configPath)) {
+        try {
+          let config;
+          if (configFile.endsWith(".js")) {
+            const fileUrl = (0, import_url.pathToFileURL)(configPath).href;
+            const module2 = await import(`${fileUrl}?t=${Date.now()}`);
+            config = module2.default || module2;
+          } else {
+            const content = (0, import_fs3.readFileSync)(configPath, "utf-8");
+            config = JSON.parse(content);
           }
-        } : void 0
-      });
-    } else if (declaration.type === "ClassDeclaration" && declaration.id) {
-      exports2.push({
-        name: declaration.id.name,
-        type: "class",
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
+          if (typeof config !== "object" || config === null) {
+            throw new Error("Config must be an object");
           }
-        } : void 0
-      });
-    } else if (declaration.type === "VariableDeclaration") {
-      for (const declarator of declaration.declarations) {
-        if (declarator.id.type === "Identifier") {
-          exports2.push({
-            name: declarator.id.name,
-            type: "const",
-            loc: declarator.loc ? {
-              start: {
-                line: declarator.loc.start.line,
-                column: declarator.loc.start.column
-              },
-              end: {
-                line: declarator.loc.end.line,
-                column: declarator.loc.end.column
-              }
-            } : void 0
-          });
+          return config;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const e = new Error(
+            `Failed to load config from ${configPath}: ${errorMessage}`
+          );
+          try {
+            e.cause = error instanceof Error ? error : void 0;
+          } catch {
+          }
+          throw e;
         }
       }
-    } else if (declaration.type === "TSTypeAliasDeclaration") {
-      exports2.push({
-        name: declaration.id.name,
-        type: "type",
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0
-      });
-    } else if (declaration.type === "TSInterfaceDeclaration") {
-      exports2.push({
-        name: declaration.id.name,
-        type: "interface",
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0
-      });
     }
-    return exports2;
+    const parent = (0, import_path3.dirname)(currentDir);
+    if (parent === currentDir) {
+      break;
+    }
+    currentDir = parent;
   }
-};
-
-// src/parsers/python-parser.ts
-var PythonParser = class {
-  constructor() {
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
-    this.parser = null;
-    this.initialized = false;
+  return null;
+}
+function mergeConfigWithDefaults(userConfig, defaults) {
+  if (!userConfig) return defaults;
+  const result = { ...defaults };
+  if (userConfig.scan) {
+    if (userConfig.scan.include) result.include = userConfig.scan.include;
+    if (userConfig.scan.exclude) result.exclude = userConfig.scan.exclude;
   }
-  /**
-   * Initialize the tree-sitter parser
-   * This is async because tree-sitter WASM needs to be loaded
-   */
-  async initialize() {
-    if (this.initialized) return;
-    try {
-      this.initialized = true;
-    } catch (error) {
-      throw new Error(
-        `Failed to initialize Python parser: ${error.message}`
-      );
+  const toolOverrides = userConfig.tools && !Array.isArray(userConfig.tools) && typeof userConfig.tools === "object" ? userConfig.tools : userConfig.toolConfigs;
+  if (toolOverrides) {
+    if (!result.toolConfigs) result.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],
+          ...toolConfig
+        };
+      }
     }
   }
-  parse(code, filePath) {
-    try {
-      const imports = this.extractImportsRegex(code, filePath);
-      const exports2 = this.extractExportsRegex(code, filePath);
-      return {
-        exports: exports2,
-        imports,
-        language: "python" /* Python */,
-        warnings: [
-          "Python parsing is currently using regex-based extraction. Tree-sitter support coming soon."
-        ]
-      };
-    } catch (error) {
-      throw new ParseError(
-        `Failed to parse Python file ${filePath}: ${error.message}`,
-        filePath
-      );
+  if (userConfig.output) {
+    result.output = { ...result.output, ...userConfig.output };
+  }
+  return result;
+}
+
+// src/utils/visualization.ts
+function generateHTML(graph) {
+  const payload = JSON.stringify(graph, null, 2);
+  return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AIReady Visualization</title>
+    <style>
+      html,body { height: 100%; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0 }
+      #container { display:flex; height:100vh }
+      #panel { width: 320px; padding: 16px; background: #071130; box-shadow: -2px 0 8px rgba(0,0,0,0.3); overflow:auto }
+      #canvasWrap { flex:1; display:flex; align-items:center; justify-content:center }
+      canvas { background: #0b1220; border-radius:8px }
+      .stat { margin-bottom:12px }
+    </style>
+  </head>
+  <body>
+    <div id="container">
+      <div id="canvasWrap"><canvas id="canvas" width="1200" height="800"></canvas></div>
+      <div id="panel">
+        <h2>AIReady Visualization</h2>
+        <div class="stat"><strong>Files:</strong> <span id="stat-files"></span></div>
+        <div class="stat"><strong>Dependencies:</strong> <span id="stat-deps"></span></div>
+        <div class="stat"><strong>Legend</strong></div>
+        <div style="font-size:13px;line-height:1.3;color:#cbd5e1;margin-top:8px">
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff4d4f;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Critical</strong>: highest severity issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ff9900;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Major</strong>: important issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#ffd666;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Minor</strong>: low priority issues.</div>
+          <div style="margin-bottom:8px"><span style="display:inline-block;width:12px;height:12px;background:#91d5ff;margin-right:8px;border:1px solid rgba(255,255,255,0.06)"></span><strong>Info</strong>: informational notes.</div>
+          <div style="margin-top:10px;color:#94a3b8"><strong>Node size</strong>: larger = higher token cost, more issues or dependency weight.</div>
+          <div style="margin-top:6px;color:#94a3b8"><strong>Proximity</strong>: nodes that are spatially close are more contextually related; relatedness is represented by distance and size rather than explicit edges.</div>
+          <div style="margin-top:6px;color:#94a3b8"><strong>Edge colors</strong>: <span style="color:#fb7e81">Similarity</span>, <span style="color:#84c1ff">Dependency</span>, <span style="color:#ffa500">Reference</span>, default <span style="color:#334155">Other</span>.</div>
+        </div>
+      </div>
+    </div>
+
+    <script>
+      const graphData = ${payload};
+      document.getElementById('stat-files').textContent = graphData.metadata.totalFiles;
+      document.getElementById('stat-deps').textContent = graphData.metadata.totalDependencies;
+
+      const canvas = document.getElementById('canvas');
+      const ctx = canvas.getContext('2d');
+
+      const nodes = graphData.nodes.map((n, i) => ({
+        ...n,
+        x: canvas.width / 2 + Math.cos(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
+        y: canvas.height / 2 + Math.sin(i / graphData.nodes.length * Math.PI * 2) * (Math.min(canvas.width, canvas.height) / 3),
+      }));
+
+      function draw() {
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+        graphData.edges.forEach(edge => {
+          const s = nodes.find(n => n.id === edge.source);
+          const t = nodes.find(n => n.id === edge.target);
+          if (!s || !t) return;
+          if (edge.type === 'related') return;
+          if (edge.type === 'similarity') {
+            ctx.strokeStyle = '#fb7e81';
+            ctx.lineWidth = 1.2;
+          } else if (edge.type === 'dependency') {
+            ctx.strokeStyle = '#84c1ff';
+            ctx.lineWidth = 1.0;
+          } else if (edge.type === 'reference') {
+            ctx.strokeStyle = '#ffa500';
+            ctx.lineWidth = 0.9;
+          } else {
+            ctx.strokeStyle = '#334155';
+            ctx.lineWidth = 0.8;
+          }
+          ctx.beginPath();
+          ctx.moveTo(s.x, s.y);
+          ctx.lineTo(t.x, t.y);
+          ctx.stroke();
+        });
+
+        const groups = {};
+        nodes.forEach(n => {
+          const g = n.group || '__default';
+          if (!groups[g]) groups[g] = { minX: n.x, minY: n.y, maxX: n.x, maxY: n.y };
+          groups[g].minX = Math.min(groups[g].minX, n.x);
+          groups[g].minY = Math.min(groups[g].minY, n.y);
+          groups[g].maxX = Math.max(groups[g].maxX, n.x);
+          groups[g].maxY = Math.max(groups[g].maxY, n.y);
+        });
+
+        const groupRelations = {};
+        graphData.edges.forEach(edge => {
+          const sNode = nodes.find(n => n.id === edge.source);
+          const tNode = nodes.find(n => n.id === edge.target);
+          if (!sNode || !tNode) return;
+          const g1 = sNode.group || '__default';
+          const g2 = tNode.group || '__default';
+          if (g1 === g2) return;
+          const key = g1 < g2 ? g1 + '::' + g2 : g2 + '::' + g1;
+          groupRelations[key] = (groupRelations[key] || 0) + 1;
+        });
+
+        Object.keys(groupRelations).forEach(k => {
+          const count = groupRelations[k];
+          const [ga, gb] = k.split('::');
+          if (!groups[ga] || !groups[gb]) return;
+          const ax = (groups[ga].minX + groups[ga].maxX) / 2;
+          const ay = (groups[ga].minY + groups[ga].maxY) / 2;
+          const bx = (groups[gb].minX + groups[gb].maxX) / 2;
+          const by = (groups[gb].minY + groups[gb].maxY) / 2;
+          ctx.beginPath();
+          ctx.strokeStyle = 'rgba(148,163,184,0.25)';
+          ctx.lineWidth = Math.min(6, 0.6 + Math.sqrt(count));
+          ctx.moveTo(ax, ay);
+          ctx.lineTo(bx, by);
+          ctx.stroke();
+        });
+
+        Object.keys(groups).forEach(g => {
+          if (g === '__default') return;
+          const box = groups[g];
+          const pad = 16;
+          const x = box.minX - pad;
+          const y = box.minY - pad;
+          const w = (box.maxX - box.minX) + pad * 2;
+          const h = (box.maxY - box.minY) + pad * 2;
+          ctx.save();
+          ctx.fillStyle = 'rgba(30,64,175,0.04)';
+          ctx.strokeStyle = 'rgba(30,64,175,0.12)';
+          ctx.lineWidth = 1.2;
+          const r = 8;
+          ctx.beginPath();
+          ctx.moveTo(x + r, y);
+          ctx.arcTo(x + w, y, x + w, y + h, r);
+          ctx.arcTo(x + w, y + h, x, y + h, r);
+          ctx.arcTo(x, y + h, x, y, r);
+          ctx.arcTo(x, y, x + w, y, r);
+          ctx.closePath();
+          ctx.fill();
+          ctx.stroke();
+          ctx.restore();
+          ctx.fillStyle = '#94a3b8';
+          ctx.font = '11px sans-serif';
+          ctx.fillText(g, x + 8, y + 14);
+        });
+
+        nodes.forEach(n => {
+          const sizeVal = (n.size || n.value || 1);
+          const r = 6 + (sizeVal / 2);
+          ctx.beginPath();
+          ctx.fillStyle = n.color || '#60a5fa';
+          ctx.arc(n.x, n.y, r, 0, Math.PI * 2);
+          ctx.fill();
+
+          ctx.fillStyle = '#e2e8f0';
+          ctx.font = '11px sans-serif';
+          ctx.textAlign = 'center';
+          ctx.fillText(n.label || n.id.split('/').slice(-1)[0], n.x, n.y + r + 12);
+        });
+      }
+
+      draw();
+    </script>
+  </body>
+</html>`;
+}
+
+// src/scoring.ts
+var DEFAULT_TOOL_WEIGHTS = {
+  ["pattern-detect" /* PatternDetect */]: 22,
+  ["context-analyzer" /* ContextAnalyzer */]: 19,
+  ["naming-consistency" /* NamingConsistency */]: 14,
+  ["ai-signal-clarity" /* AiSignalClarity */]: 11,
+  ["agent-grounding" /* AgentGrounding */]: 10,
+  ["testability-index" /* TestabilityIndex */]: 10,
+  ["doc-drift" /* DocDrift */]: 8,
+  ["dependency-health" /* DependencyHealth */]: 6,
+  ["change-amplification" /* ChangeAmplification */]: 8
+};
+var TOOL_NAME_MAP = {
+  patterns: "pattern-detect" /* PatternDetect */,
+  "pattern-detect": "pattern-detect" /* PatternDetect */,
+  context: "context-analyzer" /* ContextAnalyzer */,
+  "context-analyzer": "context-analyzer" /* ContextAnalyzer */,
+  consistency: "naming-consistency" /* NamingConsistency */,
+  "naming-consistency": "naming-consistency" /* NamingConsistency */,
+  "ai-signal": "ai-signal-clarity" /* AiSignalClarity */,
+  "ai-signal-clarity": "ai-signal-clarity" /* AiSignalClarity */,
+  grounding: "agent-grounding" /* AgentGrounding */,
+  "agent-grounding": "agent-grounding" /* AgentGrounding */,
+  testability: "testability-index" /* TestabilityIndex */,
+  "testability-index": "testability-index" /* TestabilityIndex */,
+  "doc-drift": "doc-drift" /* DocDrift */,
+  "deps-health": "dependency-health" /* DependencyHealth */,
+  "dependency-health": "dependency-health" /* DependencyHealth */,
+  "change-amp": "change-amplification" /* ChangeAmplification */,
+  "change-amplification": "change-amplification" /* ChangeAmplification */
+};
+var CONTEXT_TIER_THRESHOLDS = {
+  compact: { idealTokens: 3e3, criticalTokens: 1e4, idealDepth: 4 },
+  standard: { idealTokens: 5e3, criticalTokens: 15e3, idealDepth: 5 },
+  extended: { idealTokens: 15e3, criticalTokens: 5e4, idealDepth: 7 },
+  frontier: { idealTokens: 5e4, criticalTokens: 15e4, idealDepth: 10 }
+};
+var SIZE_ADJUSTED_THRESHOLDS = {
+  xs: 80,
+  // < 50 files
+  small: 75,
+  // 50-200 files
+  medium: 70,
+  // 200-500 files
+  large: 65,
+  // 500-2000 files
+  enterprise: 58
+  // 2000+ files
+};
+function getProjectSizeTier(fileCount) {
+  if (fileCount < 50) return "xs";
+  if (fileCount < 200) return "small";
+  if (fileCount < 500) return "medium";
+  if (fileCount < 2e3) return "large";
+  return "enterprise";
+}
+function getRecommendedThreshold(fileCount, modelTier = "standard") {
+  const sizeTier = getProjectSizeTier(fileCount);
+  const base = SIZE_ADJUSTED_THRESHOLDS[sizeTier];
+  const modelBonus = modelTier === "frontier" ? -3 : modelTier === "extended" ? -2 : 0;
+  return base + modelBonus;
+}
+function normalizeToolName(shortName) {
+  return TOOL_NAME_MAP[shortName.toLowerCase()] || shortName;
+}
+function getToolWeight(toolName, toolConfig, cliOverride) {
+  if (cliOverride !== void 0) return cliOverride;
+  if (toolConfig?.scoreWeight !== void 0) return toolConfig.scoreWeight;
+  return DEFAULT_TOOL_WEIGHTS[toolName] || 5;
+}
+function parseWeightString(weightStr) {
+  const weights = /* @__PURE__ */ new Map();
+  if (!weightStr) return weights;
+  const pairs = weightStr.split(",");
+  for (const pair of pairs) {
+    const [toolShortName, weightStr2] = pair.split(":");
+    if (toolShortName && weightStr2) {
+      const toolName = normalizeToolName(toolShortName.trim());
+      const weight = parseInt(weightStr2.trim(), 10);
+      if (!isNaN(weight) && weight > 0) {
+        weights.set(toolName, weight);
+      }
     }
   }
-  getNamingConventions() {
-    return {
-      // snake_case for variables and functions
-      variablePattern: /^[a-z_][a-z0-9_]*$/,
-      functionPattern: /^[a-z_][a-z0-9_]*$/,
-      // PascalCase for classes
-      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      // UPPER_CASE for constants
-      constantPattern: /^[A-Z][A-Z0-9_]*$/,
-      // Python special methods and common exceptions
-      exceptions: [
-        "__init__",
-        "__str__",
-        "__repr__",
-        "__name__",
-        "__main__",
-        "__file__",
-        "__doc__",
-        "__all__",
-        "__version__",
-        "__author__",
-        "__dict__",
-        "__class__",
-        "__module__",
-        "__bases__"
-      ]
-    };
+  return weights;
+}
+function calculateOverallScore(toolOutputs, config, cliWeights) {
+  if (toolOutputs.size === 0) {
+    throw new Error("No tool outputs provided for scoring");
   }
-  canHandle(filePath) {
-    return filePath.toLowerCase().endsWith(".py");
+  const weights = /* @__PURE__ */ new Map();
+  for (const [toolName] of toolOutputs.entries()) {
+    const cliWeight = cliWeights?.get(toolName);
+    const configWeight = config?.tools?.[toolName]?.scoreWeight;
+    const weight = cliWeight ?? configWeight ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? 5;
+    weights.set(toolName, weight);
   }
-  /**
-   * Regex-based import extraction (temporary implementation)
-   */
-  extractImportsRegex(code, filePath) {
-    const imports = [];
-    const lines = code.split("\n");
-    const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
-    const fromImportRegex = /^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)/;
-    lines.forEach((line, idx) => {
-      if (line.trim().startsWith("#")) return;
-      const importMatch = line.match(importRegex);
-      if (importMatch) {
-        const modules = importMatch[1].split(",").map((m) => m.trim().split(" as ")[0]);
-        modules.forEach((module2) => {
-          imports.push({
-            source: module2,
-            specifiers: [module2],
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-        });
-        return;
-      }
-      const fromMatch = line.match(fromImportRegex);
-      if (fromMatch) {
-        const module2 = fromMatch[1];
-        const imports_str = fromMatch[2];
-        if (imports_str.trim() === "*") {
-          imports.push({
-            source: module2,
-            specifiers: ["*"],
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-          return;
-        }
-        const specifiers = imports_str.split(",").map((s) => s.trim().split(" as ")[0]);
-        imports.push({
-          source: module2,
-          specifiers,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return imports;
+  let weightedSum = 0;
+  let totalWeight = 0;
+  const breakdown = [];
+  const toolsUsed = [];
+  const calculationWeights = {};
+  for (const [toolName, output] of toolOutputs.entries()) {
+    const weight = weights.get(toolName) || 5;
+    weightedSum += output.score * weight;
+    totalWeight += weight;
+    toolsUsed.push(toolName);
+    calculationWeights[toolName] = weight;
+    breakdown.push(output);
   }
-  /**
-   * Regex-based export extraction (temporary implementation)
-   *
-   * Python doesn't have explicit exports like JavaScript.
-   * We extract:
-   * - Functions defined at module level (def)
-   * - Classes defined at module level (class)
-   * - Variables in __all__ list
-   */
-  extractExportsRegex(code, filePath) {
-    const exports2 = [];
-    const lines = code.split("\n");
-    const functionRegex = /^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
-    const classRegex = /^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/;
-    const allRegex = /__all__\s*=\s*\[([^\]]+)\]/;
-    let inClass = false;
-    let classIndent = 0;
-    lines.forEach((line, idx) => {
-      const indent = line.search(/\S/);
-      if (line.match(classRegex)) {
-        inClass = true;
-        classIndent = indent;
-      } else if (inClass && indent <= classIndent && line.trim()) {
-        inClass = false;
-      }
-      if (inClass) {
-        const classMatch = line.match(classRegex);
-        if (classMatch) {
-          exports2.push({
-            name: classMatch[1],
-            type: "class",
-            loc: {
-              start: { line: idx + 1, column: indent },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-        }
-        return;
-      }
-      const funcMatch = line.match(functionRegex);
-      if (funcMatch && indent === 0) {
-        const name = funcMatch[1];
-        if (!name.startsWith("_") || name.startsWith("__")) {
-          exports2.push({
-            name,
-            type: "function",
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-        }
-      }
-      const allMatch = line.match(allRegex);
-      if (allMatch) {
-        const names = allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, ""));
-        names.forEach((name) => {
-          if (name && !exports2.find((e) => e.name === name)) {
-            exports2.push({
-              name,
-              type: "variable",
-              loc: {
-                start: { line: idx + 1, column: 0 },
-                end: { line: idx + 1, column: line.length }
-              }
-            });
-          }
-        });
-      }
-    });
-    return exports2;
+  const overall = Math.round(weightedSum / totalWeight);
+  const rating = getRating(overall);
+  const formulaParts = Array.from(toolOutputs.entries()).map(
+    ([name, output]) => {
+      const w = weights.get(name) || 5;
+      return `(${output.score} \xD7 ${w})`;
+    }
+  );
+  const formulaStr = `[${formulaParts.join(" + ")}] / ${totalWeight} = ${overall}`;
+  return {
+    overall,
+    rating,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    toolsUsed,
+    breakdown,
+    calculation: {
+      formula: formulaStr,
+      weights: calculationWeights,
+      normalized: formulaStr
+    }
+  };
+}
+function getRating(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;
+  return getRating(normalized);
+}
+function getRatingDisplay(rating) {
+  switch (rating) {
+    case "Excellent":
+      return { emoji: "\u2705", color: "green" };
+    case "Good":
+      return { emoji: "\u{1F44D}", color: "blue" };
+    case "Fair":
+      return { emoji: "\u26A0\uFE0F", color: "yellow" };
+    case "Needs Work":
+      return { emoji: "\u{1F528}", color: "orange" };
+    case "Critical":
+      return { emoji: "\u274C", color: "red" };
   }
-};
+}
+function formatScore(result) {
+  const { emoji } = getRatingDisplay(result.rating);
+  return `${result.overall}/100 (${result.rating}) ${emoji}`;
+}
+function formatToolScore(output) {
+  let result = `  Score: ${output.score}/100
 
-// src/parsers/parser-factory.ts
-var ParserFactory = class _ParserFactory {
-  constructor() {
-    this.parsers = /* @__PURE__ */ new Map();
-    this.extensionMap = new Map(
-      Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
-    );
-    this.registerParser(new TypeScriptParser());
-    this.registerParser(new PythonParser());
-  }
-  /**
-   * Get singleton instance
-   */
-  static getInstance() {
-    if (!_ParserFactory.instance) {
-      _ParserFactory.instance = new _ParserFactory();
-    }
-    return _ParserFactory.instance;
+`;
+  if (output.factors && output.factors.length > 0) {
+    result += `  Factors:
+`;
+    output.factors.forEach((factor) => {
+      const impactSign = factor.impact > 0 ? "+" : "";
+      result += `    \u2022 ${factor.name}: ${impactSign}${factor.impact} - ${factor.description}
+`;
+    });
+    result += "\n";
   }
-  /**
-   * Register a language parser
-   */
-  registerParser(parser) {
-    this.parsers.set(parser.language, parser);
-    parser.extensions.forEach((ext) => {
-      const lang = LANGUAGE_EXTENSIONS[ext] || parser.language;
-      this.extensionMap.set(ext, lang);
-      this.parsers.set(lang, parser);
+  if (output.recommendations && output.recommendations.length > 0) {
+    result += `  Recommendations:
+`;
+    output.recommendations.forEach((rec, i) => {
+      const priorityIcon = rec.priority === "high" ? "\u{1F534}" : rec.priority === "medium" ? "\u{1F7E1}" : "\u{1F535}";
+      result += `    ${i + 1}. ${priorityIcon} ${rec.action}
+`;
+      result += `       Impact: +${rec.estimatedImpact} points
+
+`;
     });
   }
-  /**
-   * Get parser for a specific language
-   */
-  getParserForLanguage(language) {
-    return this.parsers.get(language) || null;
+  return result;
+}
+
+// src/business/pricing-models.ts
+var MODEL_PRICING_PRESETS = {
+  "gpt-5.3": {
+    name: "GPT-5.3",
+    pricePer1KInputTokens: 2e-3,
+    pricePer1KOutputTokens: 8e-3,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 100
+  },
+  "claude-4.6": {
+    name: "Claude 4.6",
+    pricePer1KInputTokens: 15e-4,
+    pricePer1KOutputTokens: 75e-4,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 100
+  },
+  "gemini-3.1": {
+    name: "Gemini 3.1 Pro",
+    pricePer1KInputTokens: 8e-4,
+    pricePer1KOutputTokens: 3e-3,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 120
+  },
+  "gpt-4o": {
+    name: "GPT-4o (legacy)",
+    pricePer1KInputTokens: 5e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 60
+  },
+  "claude-3-5-sonnet": {
+    name: "Claude 3.5 Sonnet (legacy)",
+    pricePer1KInputTokens: 3e-3,
+    pricePer1KOutputTokens: 0.015,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 80
+  },
+  "gemini-1-5-pro": {
+    name: "Gemini 1.5 Pro (legacy)",
+    pricePer1KInputTokens: 125e-5,
+    pricePer1KOutputTokens: 5e-3,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 80
+  },
+  copilot: {
+    name: "GitHub Copilot (subscription)",
+    pricePer1KInputTokens: 8e-5,
+    pricePer1KOutputTokens: 8e-5,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 150
+  },
+  "cursor-pro": {
+    name: "Cursor Pro (subscription)",
+    pricePer1KInputTokens: 8e-5,
+    pricePer1KOutputTokens: 8e-5,
+    contextTier: "frontier",
+    typicalQueriesPerDevPerDay: 200
   }
-  /**
-   * Get parser for a file based on its extension
-   */
-  getParserForFile(filePath) {
-    const ext = this.getFileExtension(filePath);
-    const language = this.extensionMap.get(ext);
-    if (!language) {
-      return null;
+};
+function getModelPreset(modelId) {
+  return MODEL_PRICING_PRESETS[modelId] ?? MODEL_PRICING_PRESETS["claude-4.6"];
+}
+
+// src/business/cost-metrics.ts
+var DEFAULT_COST_CONFIG = {
+  pricePer1KTokens: 5e-3,
+  queriesPerDevPerDay: 60,
+  developerCount: 5,
+  daysPerMonth: 30
+};
+function calculateMonthlyCost(tokenWaste, config = {}) {
+  const budget = calculateTokenBudget({
+    totalContextTokens: tokenWaste * 2.5,
+    wastedTokens: {
+      duplication: tokenWaste * 0.7,
+      fragmentation: tokenWaste * 0.3,
+      chattiness: 0
     }
-    return this.parsers.get(language) || null;
-  }
-  /**
-   * Check if a file is supported
-   */
-  isSupported(filePath) {
-    return this.getParserForFile(filePath) !== null;
+  });
+  const preset = getModelPreset("claude-4.6");
+  return estimateCostFromBudget(budget, preset, config);
+}
+function calculateTokenBudget(params) {
+  const { totalContextTokens, wastedTokens } = params;
+  const estimatedResponseTokens = params.estimatedResponseTokens ?? totalContextTokens * 0.2;
+  const totalWaste = wastedTokens.duplication + wastedTokens.fragmentation + wastedTokens.chattiness;
+  const efficiencyRatio = Math.max(
+    0,
+    Math.min(
+      1,
+      (totalContextTokens - totalWaste) / Math.max(1, totalContextTokens)
+    )
+  );
+  return {
+    totalContextTokens: Math.round(totalContextTokens),
+    estimatedResponseTokens: Math.round(estimatedResponseTokens),
+    wastedTokens: {
+      total: Math.round(totalWaste),
+      bySource: {
+        duplication: Math.round(wastedTokens.duplication),
+        fragmentation: Math.round(wastedTokens.fragmentation),
+        chattiness: Math.round(wastedTokens.chattiness)
+      }
+    },
+    efficiencyRatio: Math.round(efficiencyRatio * 100) / 100,
+    potentialRetrievableTokens: Math.round(totalWaste * 0.8)
+  };
+}
+function estimateCostFromBudget(budget, model, config = {}) {
+  const cfg = { ...DEFAULT_COST_CONFIG, ...config };
+  const wastePerQuery = budget.wastedTokens.total;
+  const tokensPerDay = wastePerQuery * cfg.queriesPerDevPerDay;
+  const tokensPerMonth = tokensPerDay * cfg.daysPerMonth;
+  const totalWeight = cfg.developerCount;
+  const price = config.pricePer1KTokens ?? model.pricePer1KInputTokens;
+  const baseCost = tokensPerMonth / 1e3 * price * totalWeight;
+  let confidence = 0.85;
+  if (model.contextTier === "frontier") confidence = 0.7;
+  const variance = 0.25;
+  const range = [
+    Math.round(baseCost * (1 - variance) * 100) / 100,
+    Math.round(baseCost * (1 + variance) * 100) / 100
+  ];
+  return {
+    total: Math.round(baseCost * 100) / 100,
+    range,
+    confidence
+  };
+}
+
+// src/business/productivity-metrics.ts
+var SEVERITY_TIME_ESTIMATES = {
+  ["critical" /* Critical */]: 4,
+  ["major" /* Major */]: 2,
+  ["minor" /* Minor */]: 0.5,
+  ["info" /* Info */]: 0.25
+};
+var DEFAULT_HOURLY_RATE = 75;
+function calculateProductivityImpact(issues, hourlyRate = DEFAULT_HOURLY_RATE) {
+  const counts = {
+    ["critical" /* Critical */]: issues.filter((i) => i.severity === "critical" /* Critical */).length,
+    ["major" /* Major */]: issues.filter((i) => i.severity === "major" /* Major */).length,
+    ["minor" /* Minor */]: issues.filter((i) => i.severity === "minor" /* Minor */).length,
+    ["info" /* Info */]: issues.filter((i) => i.severity === "info" /* Info */).length
+  };
+  const hours = {
+    ["critical" /* Critical */]: counts["critical" /* Critical */] * SEVERITY_TIME_ESTIMATES["critical" /* Critical */],
+    ["major" /* Major */]: counts["major" /* Major */] * SEVERITY_TIME_ESTIMATES["major" /* Major */],
+    ["minor" /* Minor */]: counts["minor" /* Minor */] * SEVERITY_TIME_ESTIMATES["minor" /* Minor */],
+    ["info" /* Info */]: counts["info" /* Info */] * SEVERITY_TIME_ESTIMATES["info" /* Info */]
+  };
+  const totalHours = hours["critical" /* Critical */] + hours["major" /* Major */] + hours["minor" /* Minor */] + hours["info" /* Info */];
+  const totalCost = totalHours * hourlyRate;
+  return {
+    totalHours: Math.round(totalHours * 10) / 10,
+    hourlyRate,
+    totalCost: Math.round(totalCost),
+    bySeverity: {
+      ["critical" /* Critical */]: {
+        hours: Math.round(hours["critical" /* Critical */] * 10) / 10,
+        cost: Math.round(hours["critical" /* Critical */] * hourlyRate)
+      },
+      ["major" /* Major */]: {
+        hours: Math.round(hours["major" /* Major */] * 10) / 10,
+        cost: Math.round(hours["major" /* Major */] * hourlyRate)
+      },
+      ["minor" /* Minor */]: {
+        hours: Math.round(hours["minor" /* Minor */] * 10) / 10,
+        cost: Math.round(hours["minor" /* Minor */] * hourlyRate)
+      },
+      ["info" /* Info */]: {
+        hours: Math.round(hours["info" /* Info */] * 10) / 10,
+        cost: Math.round(hours["info" /* Info */] * hourlyRate)
+      }
+    }
+  };
+}
+function predictAcceptanceRate(toolOutputs) {
+  const factors = [];
+  const baseRate = 0.3;
+  const patterns = toolOutputs.get("pattern-detect");
+  if (patterns) {
+    factors.push({
+      name: "Semantic Duplication",
+      impact: Math.round((patterns.score - 50) * 3e-3 * 100)
+    });
   }
-  /**
-   * Get all registered languages
-   */
-  getSupportedLanguages() {
-    return Array.from(this.parsers.keys());
+  const context = toolOutputs.get("context-analyzer");
+  if (context) {
+    factors.push({
+      name: "Context Efficiency",
+      impact: Math.round((context.score - 50) * 4e-3 * 100)
+    });
   }
-  /**
-   * Get all supported file extensions
-   */
-  getSupportedExtensions() {
-    return Array.from(this.extensionMap.keys());
+  const consistency = toolOutputs.get("consistency");
+  if (consistency) {
+    factors.push({
+      name: "Code Consistency",
+      impact: Math.round((consistency.score - 50) * 2e-3 * 100)
+    });
   }
-  /**
-   * Get language for a file
-   */
-  getLanguageForFile(filePath) {
-    const ext = this.getFileExtension(filePath);
-    return this.extensionMap.get(ext) || null;
+  const aiSignalClarity = toolOutputs.get("ai-signal-clarity");
+  if (aiSignalClarity) {
+    factors.push({
+      name: "AI Signal Clarity",
+      impact: Math.round((50 - aiSignalClarity.score) * 2e-3 * 100)
+    });
   }
-  /**
-   * Extract file extension (with dot)
-   */
-  getFileExtension(filePath) {
-    const match = filePath.match(/\.[^.]+$/);
-    return match ? match[0].toLowerCase() : "";
+  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;
+  else if (toolOutputs.size >= 3) confidence = 0.65;
+  else if (toolOutputs.size >= 2) confidence = 0.5;
+  return { rate: Math.round(rate * 100) / 100, confidence, factors };
+}
+
+// src/business/risk-metrics.ts
+function calculateKnowledgeConcentration(params) {
+  const { uniqueConceptFiles, totalFiles, singleAuthorFiles, orphanFiles } = params;
+  const concentrationRatio = totalFiles > 0 ? (uniqueConceptFiles + singleAuthorFiles) / (totalFiles * 2) : 0;
+  const score = Math.round(
+    Math.min(
+      100,
+      concentrationRatio * 100 + orphanFiles / Math.max(1, totalFiles) * 20
+    )
+  );
+  let rating;
+  if (score < 30) rating = "low";
+  else if (score < 50) rating = "moderate";
+  else if (score < 75) rating = "high";
+  else rating = "critical";
+  const recommendations = [];
+  if (singleAuthorFiles > 0)
+    recommendations.push(
+      `Distribute knowledge for ${singleAuthorFiles} single-author files.`
+    );
+  if (orphanFiles > 0)
+    recommendations.push(
+      `Link ${orphanFiles} orphan files to the rest of the codebase.`
+    );
+  return {
+    score,
+    rating,
+    recommendations,
+    analysis: {
+      uniqueConceptFiles,
+      totalFiles,
+      concentrationRatio,
+      singleAuthorFiles,
+      orphanFiles
+    }
+  };
+}
+function calculateDebtInterest(principal, monthlyGrowthRate) {
+  const monthlyRate = monthlyGrowthRate;
+  const annualRate = Math.pow(1 + monthlyRate, 12) - 1;
+  const monthlyCost = principal * monthlyRate;
+  return {
+    monthlyRate,
+    annualRate,
+    principal,
+    monthlyCost,
+    projections: {
+      months6: principal * Math.pow(1 + monthlyRate, 6),
+      months12: principal * Math.pow(1 + monthlyRate, 12),
+      months24: principal * Math.pow(1 + monthlyRate, 24)
+    }
+  };
+}
+
+// src/business/comprehension-metrics.ts
+function calculateTechnicalValueChain(params) {
+  const { businessLogicDensity, dataAccessComplexity, apiSurfaceArea } = params;
+  const score = (businessLogicDensity * 0.5 + (1 - dataAccessComplexity / 10) * 0.3 + (1 - apiSurfaceArea / 20) * 0.2) * 100;
+  return {
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    density: businessLogicDensity,
+    complexity: dataAccessComplexity,
+    surface: apiSurfaceArea
+  };
+}
+function calculateComprehensionDifficulty(contextBudget, importDepth, fragmentation, modelTier = "frontier") {
+  const tierMap = {
+    compact: "compact",
+    standard: "standard",
+    extended: "extended",
+    frontier: "frontier",
+    easy: "frontier",
+    // Map legacy 'easy' to 'frontier'
+    moderate: "standard",
+    difficult: "compact"
+  };
+  const tier = tierMap[modelTier] || "frontier";
+  const threshold = CONTEXT_TIER_THRESHOLDS[tier];
+  const budgetRatio = contextBudget / threshold.idealTokens;
+  const score = (budgetRatio * 0.6 + importDepth / 10 * 0.2 + fragmentation * 0.2) * 100;
+  const finalScore = Math.round(Math.max(0, Math.min(100, score)));
+  let rating;
+  if (finalScore < 20) rating = "trivial";
+  else if (finalScore < 40) rating = "easy";
+  else if (finalScore < 60) rating = "moderate";
+  else if (finalScore < 85) rating = "difficult";
+  else rating = "expert";
+  return {
+    score: finalScore,
+    rating,
+    factors: { budgetRatio, depthRatio: importDepth / 10, fragmentation }
+  };
+}
+
+// src/business-metrics.ts
+function calculateBusinessROI(params) {
+  const model = getModelPreset(params.modelId || "claude-4.6");
+  const devCount = params.developerCount || 5;
+  const budget = calculateTokenBudget({
+    totalContextTokens: params.tokenWaste * 2.5,
+    wastedTokens: {
+      duplication: params.tokenWaste * 0.7,
+      fragmentation: params.tokenWaste * 0.3,
+      chattiness: 0
+    }
+  });
+  const cost = estimateCostFromBudget(budget, model, {
+    developerCount: devCount
+  });
+  const productivity = calculateProductivityImpact(params.issues);
+  const monthlySavings = cost.total;
+  const productivityGainHours = productivity.totalHours;
+  const annualValue = (monthlySavings + productivityGainHours * 75) * 12;
+  return {
+    monthlySavings: Math.round(monthlySavings),
+    productivityGainHours: Math.round(productivityGainHours),
+    annualValue: Math.round(annualValue)
+  };
+}
+function formatCost(cost) {
+  if (cost < 1) {
+    return `$${cost.toFixed(2)}`;
+  } else if (cost < 1e3) {
+    return `$${cost.toFixed(0)}`;
+  } else {
+    return `$${(cost / 1e3).toFixed(1)}k`;
   }
-  /**
-   * Reset factory (useful for testing)
-   */
-  static reset() {
-    _ParserFactory.instance = new _ParserFactory();
+}
+function formatHours(hours) {
+  if (hours < 1) {
+    return `${Math.round(hours * 60)}min`;
+  } else if (hours < 8) {
+    return `${hours.toFixed(1)}h`;
+  } else if (hours < 40) {
+    return `${Math.round(hours)}h`;
+  } else {
+    return `${(hours / 40).toFixed(1)} weeks`;
   }
-};
-function getParser(filePath) {
-  return ParserFactory.getInstance().getParserForFile(filePath);
 }
-function isFileSupported(filePath) {
-  return ParserFactory.getInstance().isSupported(filePath);
+function formatAcceptanceRate(rate) {
+  return `${Math.round(rate * 100)}%`;
 }
-function getSupportedLanguages() {
-  return ParserFactory.getInstance().getSupportedLanguages();
+function generateValueChain(params) {
+  const { issueType, count, severity } = params;
+  const impacts = {
+    "duplicate-pattern": {
+      ai: "Ambiguous context leads to code generation variants. AI picks wrong implementation 40% of the time.",
+      dev: "Developers must manually resolve conflicts between suggested variants.",
+      risk: "high"
+    },
+    "context-fragmentation": {
+      ai: "Context window overflow causes model to forget mid-file dependencies resulting in hallucinations.",
+      dev: "Slower AI responses and increased need for manual context pinning.",
+      risk: "critical"
+    },
+    "naming-inconsistency": {
+      ai: "Degraded intent inference. AI misidentifies domain concepts across file boundaries.",
+      dev: "Increased cognitive load for new devs during onboarding.",
+      risk: "moderate"
+    }
+  };
+  const impact = impacts[issueType] || {
+    ai: "Reduced suggestion quality.",
+    dev: "Slowed development velocity.",
+    risk: "moderate"
+  };
+  const productivityLoss = severity === "critical" ? 0.25 : severity === "major" ? 0.1 : 0.05;
+  return {
+    issueType,
+    technicalMetric: "Issue Count",
+    technicalValue: count,
+    aiImpact: {
+      description: impact.ai,
+      scoreImpact: severity === "critical" ? -15 : -5
+    },
+    developerImpact: {
+      description: impact.dev,
+      productivityLoss
+    },
+    businessOutcome: {
+      directCost: count * 12,
+      opportunityCost: productivityLoss * 15e3,
+      riskLevel: impact.risk
+    }
+  };
 }
 
 // src/metrics/remediation-utils.ts
@@ -3394,6 +3651,7 @@ function getRepoMetadata(directory) {
   getToolWeight,
   handleCLIError,
   handleJSONOutput,
+  initializeParsers,
   isFileSupported,
   isSourceFile,
   loadConfig,