@aiready/core 0.21.13 → 0.21.14

package/dist/index.mjs

@@ -467,904 +467,477 @@ function getSeverityColor(severity, chalk) {
 }
 
 // src/utils/ast-parser.ts
+import { parse as parse2 } from "@typescript-eslint/typescript-estree";
+
+// src/parsers/typescript-parser.ts
 import { parse } from "@typescript-eslint/typescript-estree";
-function parseFileExports(code, filePath) {
-  try {
-    const ast = parse(code, {
-      loc: true,
-      range: true,
-      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
-      filePath
-    });
-    const imports = extractFileImports(ast);
-    const exports = extractExportsWithDependencies(ast, imports);
-    return { exports, imports };
-  } catch (error) {
-    return { exports: [], imports: [] };
+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 exports = [];
-  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);
-          exports.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);
-      exports.push({
-        name: "default",
-        type: "default",
-        imports: usedImports,
-        dependencies: [],
-        typeReferences,
-        loc: node.loc
+  parse(code, filePath) {
+    try {
+      const isJavaScript = filePath.match(/\.jsx?$/i);
+      const ast = parse(code, {
+        loc: true,
+        range: true,
+        jsx: filePath.match(/\.[jt]sx$/i) !== null,
+        filePath,
+        sourceType: "module",
+        ecmaVersion: "latest"
       });
+      const imports = this.extractImports(ast);
+      const exports = this.extractExports(ast, imports);
+      return {
+        exports,
+        imports,
+        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
+        warnings: []
+      };
+    } catch (error) {
+      const err = error;
+      throw new ParseError(
+        `Failed to parse ${filePath}: ${err.message}`,
+        filePath
+      );
     }
   }
-  return exports;
-}
-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 exports = [];
+    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
+        );
+        exports.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";
+        }
+        exports.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 exports;
   }
-  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
-import { readFileSync, existsSync as existsSync3 } from "fs";
-import { join as join3, resolve, dirname as dirname3 } from "path";
-import { pathToFileURL } from "url";
-var CONFIG_FILES = [
-  "aiready.json",
-  "aiready.config.json",
-  ".aiready.json",
-  ".aireadyrc.json",
-  "aiready.config.js",
-  ".aireadyrc.js"
-];
-async function loadConfig(rootDir) {
-  let currentDir = resolve(rootDir);
-  while (true) {
-    for (const configFile of CONFIG_FILES) {
-      const configPath = join3(currentDir, configFile);
-      if (existsSync3(configPath)) {
-        try {
-          let config;
-          if (configFile.endsWith(".js")) {
-            const fileUrl = pathToFileURL(configPath).href;
-            const module = await import(`${fileUrl}?t=${Date.now()}`);
-            config = module.default || module;
-          } else {
-            const content = readFileSync(configPath, "utf-8");
-            config = JSON.parse(content);
+  extractFromDeclaration(declaration, importedNames) {
+    const exports = [];
+    if (declaration.type === "FunctionDeclaration" && declaration.id) {
+      exports.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) {
+      exports.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") {
+          exports.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") {
+      exports.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") {
+      exports.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 exports;
+  }
+};
+
+// src/parsers/python-parser.ts
+import * as Parser from "web-tree-sitter";
+import * as path from "path";
+import * as fs from "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 = dirname3(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 exports = this.extractExportsAST(rootNode);
+      return {
+        exports,
+        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 exports = [];
+    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) {
+            exports.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) {
+          exports.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) {
+              exports.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 exports;
   }
-  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/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)
-      }
-    }
-  };
-}
-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)
-    });
-  }
-  const consistency = toolOutputs.get("consistency");
-  if (consistency) {
-    factors.push({
-      name: "Code Consistency",
-      impact: Math.round((consistency.score - 50) * 2e-3 * 100)
-    });
-  }
-  const aiSignalClarity = toolOutputs.get("ai-signal-clarity");
-  if (aiSignalClarity) {
-    factors.push({
-      name: "AI Signal Clarity",
-      impact: Math.round((50 - aiSignalClarity.score) * 2e-3 * 100)
-    });
-  }
-  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`;
-  }
-}
-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 formatAcceptanceRate(rate) {
-  return `${Math.round(rate * 100)}%`;
-}
-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/parsers/typescript-parser.ts
-import { parse as parse2 } from "@typescript-eslint/typescript-estree";
-var TypeScriptParser = class {
-  constructor() {
-    this.language = "typescript" /* TypeScript */;
-    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
-  }
-  parse(code, filePath) {
-    try {
-      const isJavaScript = filePath.match(/\.jsx?$/i);
-      const ast = parse2(code, {
-        loc: true,
-        range: true,
-        jsx: filePath.match(/\.[jt]sx$/i) !== null,
-        filePath,
-        sourceType: "module",
-        ecmaVersion: "latest"
-      });
-      const imports = this.extractImports(ast);
-      const exports = this.extractExports(ast, imports);
-      return {
-        exports,
-        imports,
-        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
-        warnings: []
-      };
-    } catch (error) {
-      const err = error;
-      throw new ParseError(
-        `Failed to parse ${filePath}: ${err.message}`,
-        filePath
-      );
-    }
-  }
-  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"]
-    };
-  }
-  canHandle(filePath) {
-    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
-  }
-  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("*");
-          }
-        }
-        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 exports = [];
-    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
-        );
-        exports.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";
-        }
-        exports.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 exports;
-  }
-  extractFromDeclaration(declaration, importedNames) {
-    const exports = [];
-    if (declaration.type === "FunctionDeclaration" && declaration.id) {
-      exports.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
-          }
-        } : void 0
-      });
-    } else if (declaration.type === "ClassDeclaration" && declaration.id) {
-      exports.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
-          }
-        } : void 0
-      });
-    } else if (declaration.type === "VariableDeclaration") {
-      for (const declarator of declaration.declarations) {
-        if (declarator.id.type === "Identifier") {
-          exports.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") {
-      exports.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") {
-      exports.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 exports;
-  }
-};
-
-// src/parsers/python-parser.ts
-var PythonParser = class {
-  constructor() {
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
-    this.parser = null;
-    this.initialized = false;
-  }
-  /**
-   * 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}`
-      );
-    }
-  }
-  parse(code, filePath) {
+  parseRegex(code, filePath) {
     try {
       const imports = this.extractImportsRegex(code, filePath);
       const exports = this.extractExportsRegex(code, filePath);
@@ -1373,7 +946,7 @@ var PythonParser = class {
         imports,
         language: "python" /* Python */,
         warnings: [
-          "Python parsing is currently using regex-based extraction. Tree-sitter support coming soon."
+          "Python parsing is currently using regex-based extraction as tree-sitter wasm was not available."
         ]
       };
     } catch (error) {
@@ -1385,14 +958,10 @@ var PythonParser = class {
   }
   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__",
@@ -1414,10 +983,7 @@ var PythonParser = class {
   canHandle(filePath) {
     return filePath.toLowerCase().endsWith(".py");
   }
-  /**
-   * Regex-based import extraction (temporary implementation)
-   */
-  extractImportsRegex(code, filePath) {
+  extractImportsRegex(code, _filePath) {
     const imports = [];
     const lines = code.split("\n");
     const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
@@ -1439,202 +1005,892 @@ var PythonParser = class {
         });
         return;
       }
-      const fromMatch = line.match(fromImportRegex);
-      if (fromMatch) {
-        const module = fromMatch[1];
-        const imports_str = fromMatch[2];
-        if (imports_str.trim() === "*") {
-          imports.push({
-            source: module,
-            specifiers: ["*"],
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
+      const fromMatch = line.match(fromImportRegex);
+      if (fromMatch) {
+        const module = fromMatch[1];
+        const imports_str = fromMatch[2];
+        if (imports_str.trim() === "*") {
+          imports.push({
+            source: module,
+            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: module,
+          specifiers,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return imports;
+  }
+  extractExportsRegex(code, _filePath) {
+    const exports = [];
+    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) {
+          exports.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("__")) {
+          exports.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 && !exports.find((e) => e.name === name)) {
+            exports.push({
+              name,
+              type: "variable",
+              loc: {
+                start: { line: idx + 1, column: 0 },
+                end: { line: idx + 1, column: line.length }
+              }
+            });
+          }
+        });
+      }
+    });
+    return exports;
+  }
+};
+
+// 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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);
+}
+async function initializeParsers() {
+  await ParserFactory.getInstance().initializeAll();
+}
+function isFileSupported(filePath) {
+  return ParserFactory.getInstance().isSupported(filePath);
+}
+function getSupportedLanguages() {
+  return ParserFactory.getInstance().getSupportedLanguages();
+}
+
+// src/utils/ast-parser.ts
+function parseFileExports(code, filePath) {
+  const parser = getParser(filePath);
+  if (parser && parser.language === "python" /* Python */) {
+    try {
+      const result = parser.parse(code, filePath);
+      return {
+        exports: result.exports.map((e) => ({
+          name: e.name,
+          type: e.type,
+          imports: e.imports || [],
+          dependencies: e.dependencies || [],
+          typeReferences: e.typeReferences || [],
+          loc: e.loc ? {
+            start: { line: e.loc.start.line, column: e.loc.start.column },
+            end: { line: e.loc.end.line, column: e.loc.end.column }
+          } : void 0
+        })),
+        imports: result.imports.map((i) => ({
+          source: i.source,
+          specifiers: i.specifiers,
+          isTypeOnly: i.isTypeOnly || false
+        }))
+      };
+    } catch (e) {
+      return { exports: [], imports: [] };
+    }
+  }
+  try {
+    const ast = parse2(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      filePath
+    });
+    const imports = extractFileImports(ast);
+    const exports = extractExportsWithDependencies(ast, imports);
+    return { exports, imports };
+  } catch (error) {
+    return { exports: [], imports: [] };
+  }
+}
+function 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 exports = [];
+  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);
+          exports.push({
+            ...exp,
+            imports: usedImports,
+            dependencies: [],
+            typeReferences,
+            loc: node.loc
           });
-          return;
         }
-        const specifiers = imports_str.split(",").map((s) => s.trim().split(" as ")[0]);
-        imports.push({
-          source: module,
-          specifiers,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
       }
-    });
-    return imports;
+    } else if (node.type === "ExportDefaultDeclaration") {
+      const usedImports = findUsedImports(node.declaration, importedNames);
+      const typeReferences = extractTypeReferences(node.declaration);
+      exports.push({
+        name: "default",
+        type: "default",
+        imports: usedImports,
+        dependencies: [],
+        typeReferences,
+        loc: node.loc
+      });
+    }
   }
-  /**
-   * 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 exports = [];
-    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;
+  return exports;
+}
+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" });
       }
-      if (inClass) {
-        const classMatch = line.match(classRegex);
-        if (classMatch) {
-          exports.push({
-            name: classMatch[1],
-            type: "class",
-            loc: {
-              start: { line: idx + 1, column: indent },
-              end: { line: idx + 1, column: line.length }
+    }
+  } 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);
         }
-        return;
       }
-      const funcMatch = line.match(functionRegex);
-      if (funcMatch && indent === 0) {
-        const name = funcMatch[1];
-        if (!name.startsWith("_") || name.startsWith("__")) {
-          exports.push({
-            name,
-            type: "function",
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
+    }
+  }
+  visit(node);
+  return Array.from(usedImports);
+}
+function calculateImportSimilarity(export1, export2) {
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1;
+  }
+  const set1 = new Set(export1.imports);
+  const set2 = new Set(export2.imports);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function extractTypeReferences(node) {
+  const types = /* @__PURE__ */ new Set();
+  function visit(n) {
+    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);
         }
       }
-      const allMatch = line.match(allRegex);
-      if (allMatch) {
-        const names = allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, ""));
-        names.forEach((name) => {
-          if (name && !exports.find((e) => e.name === name)) {
-            exports.push({
-              name,
-              type: "variable",
-              loc: {
-                start: { line: idx + 1, column: 0 },
-                end: { line: idx + 1, column: line.length }
-              }
-            });
+    }
+    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);
+      }
+    }
+  }
+  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
+import { readFileSync, existsSync as existsSync4 } from "fs";
+import { join as join4, resolve, dirname as dirname3 } from "path";
+import { pathToFileURL } from "url";
+var CONFIG_FILES = [
+  "aiready.json",
+  "aiready.config.json",
+  ".aiready.json",
+  ".aireadyrc.json",
+  "aiready.config.js",
+  ".aireadyrc.js"
+];
+async function loadConfig(rootDir) {
+  let currentDir = resolve(rootDir);
+  while (true) {
+    for (const configFile of CONFIG_FILES) {
+      const configPath = join4(currentDir, configFile);
+      if (existsSync4(configPath)) {
+        try {
+          let config;
+          if (configFile.endsWith(".js")) {
+            const fileUrl = pathToFileURL(configPath).href;
+            const module = await import(`${fileUrl}?t=${Date.now()}`);
+            config = module.default || module;
+          } else {
+            const content = readFileSync(configPath, "utf-8");
+            config = JSON.parse(content);
+          }
+          if (typeof config !== "object" || config === null) {
+            throw new Error("Config must be an object");
+          }
+          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;
+        }
       }
-    });
-    return exports;
+    }
+    const parent = dirname3(currentDir);
+    if (parent === currentDir) {
+      break;
+    }
+    currentDir = parent;
   }
-};
-
-// 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());
+  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;
   }
-  /**
-   * Get singleton instance
-   */
-  static getInstance() {
-    if (!_ParserFactory.instance) {
-      _ParserFactory.instance = new _ParserFactory();
+  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
+        };
+      }
     }
-    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);
-    });
+  if (userConfig.output) {
+    result.output = { ...result.output, ...userConfig.output };
   }
-  /**
-   * 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
@@ -2477,14 +2733,14 @@ function calculateExtendedFutureProofScore(params) {
 }
 
 // src/utils/history.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
 function getHistoryPath(rootDir) {
-  return join4(rootDir, ".aiready", "history.json");
+  return join5(rootDir, ".aiready", "history.json");
 }
 function loadScoreHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (!existsSync4(historyPath)) {
+  if (!existsSync5(historyPath)) {
     return [];
   }
   try {
@@ -2498,7 +2754,7 @@ function loadScoreHistory(rootDir) {
 function saveScoreEntry(rootDir, entry) {
   const historyPath = getHistoryPath(rootDir);
   const historyDir = dirname4(historyPath);
-  if (!existsSync4(historyDir)) {
+  if (!existsSync5(historyDir)) {
     mkdirSync2(historyDir, { recursive: true });
   }
   const history = loadScoreHistory(rootDir);
@@ -2545,7 +2801,7 @@ function exportHistory(rootDir, format = "json") {
 }
 function clearHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (existsSync4(historyPath)) {
+  if (existsSync5(historyPath)) {
     writeFileSync2(historyPath, JSON.stringify([]));
   }
 }
@@ -2715,6 +2971,7 @@ export {
   getToolWeight,
   handleCLIError,
   handleJSONOutput,
+  initializeParsers,
   isFileSupported,
   isSourceFile,
   loadConfig,