@aiready/core 0.23.19 → 0.23.21

package/dist/index.mjs

@@ -12,8 +12,6 @@ import {
   IssueSchema,
   IssueType,
   IssueTypeSchema,
-  LANGUAGE_EXTENSIONS,
-  Language,
   LeadSchema,
   LeadSource,
   LeadSourceSchema,
@@ -23,7 +21,6 @@ import {
   MetricsSchema,
   ModelTier,
   ModelTierSchema,
-  ParseError,
   ReadinessRating,
   RecommendationPriority,
   SCORING_PROFILES,
@@ -41,16 +38,47 @@ import {
   formatScore,
   formatToolScore,
   generateHTML,
+  getPriorityIcon,
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingEmoji,
+  getRatingLabel,
+  getRatingMetadata,
   getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
+  getToolEmoji,
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-RMH2TPAT.mjs";
+} from "./chunk-WVNVC2PP.mjs";
+import {
+  TypeScriptParser
+} from "./chunk-UTCRW3N7.mjs";
+import {
+  PythonParser
+} from "./chunk-LZHO636W.mjs";
+import {
+  JavaParser
+} from "./chunk-SWZOT67M.mjs";
+import {
+  CSharpParser
+} from "./chunk-QZNY7B2N.mjs";
+import {
+  GoParser
+} from "./chunk-GTS642BQ.mjs";
+import "./chunk-L6BKANJC.mjs";
+import {
+  getWasmPath,
+  initTreeSitter,
+  setupParser
+} from "./chunk-2N7ISIKE.mjs";
+import {
+  LANGUAGE_EXTENSIONS,
+  Language,
+  ParseError
+} from "./chunk-U3IY2CFC.mjs";
 
 // src/utils/normalization.ts
 function normalizeIssue(raw) {
@@ -504,6 +532,30 @@ import {
 } from "fs";
 import { join as join2, dirname as dirname2, resolve as resolvePath } from "path";
 import chalk from "chalk";
+function ensureDir(path) {
+  const dir = dirname2(path);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function normalizeSeverity(s) {
+  if (!s) return null;
+  const lower = s.toLowerCase();
+  if (["critical", "high-risk", "blind-risk"].includes(lower))
+    return "critical" /* Critical */;
+  if (["major", "moderate-risk"].includes(lower)) return "major" /* Major */;
+  if (["minor", "safe"].includes(lower)) return "minor" /* Minor */;
+  if (lower === "info") return "info" /* Info */;
+  return null;
+}
+function getFilesByPattern(dir, pattern) {
+  if (!existsSync2(dir)) return [];
+  try {
+    return readdirSync(dir).filter((f) => pattern.test(f));
+  } catch {
+    return [];
+  }
+}
 function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
   let outputPath;
   if (userPath) {
@@ -519,10 +571,7 @@ function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()
     const aireadyDir = join2(baseDir, ".aiready");
     outputPath = join2(aireadyDir, defaultFilename);
   }
-  const parentDir = dirname2(outputPath);
-  if (!existsSync2(parentDir)) {
-    mkdirSync(parentDir, { recursive: true });
-  }
+  ensureDir(outputPath);
   return outputPath;
 }
 async function loadMergedConfig(directory, defaults, cliOptions) {
@@ -537,16 +586,24 @@ async function loadMergedConfig(directory, defaults, cliOptions) {
 }
 function handleJSONOutput(data, outputFile, successMessage) {
   if (outputFile) {
-    const dir = dirname2(outputFile);
-    if (!existsSync2(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
+    ensureDir(outputFile);
     writeFileSync(outputFile, JSON.stringify(data, null, 2));
     console.log(successMessage || `\u2705 Results saved to ${outputFile}`);
   } else {
     console.log(JSON.stringify(data, null, 2));
   }
 }
+function getTerminalDivider(color = chalk.cyan, maxWidth = 60) {
+  const terminalWidth = process.stdout.columns || 80;
+  const dividerWidth = Math.min(maxWidth, terminalWidth - 2);
+  return color("\u2501".repeat(dividerWidth));
+}
+function printTerminalHeader(title, color = chalk.cyan) {
+  const divider = getTerminalDivider(color);
+  console.log(divider);
+  console.log(chalk.bold.white(`  ${title.toUpperCase()}`));
+  console.log(divider + "\n");
+}
 function handleCLIError(error, commandName) {
   console.error(`\u274C ${commandName} failed:`, error);
   process.exit(1);
@@ -579,33 +636,30 @@ function emitProgress(processed, total, toolId, message, onProgress, throttleCou
   }
 }
 function getSeverityColor(severity, chalkInstance = chalk) {
-  switch (severity.toLowerCase()) {
-    case "critical":
-    case "high-risk":
-    case "blind-risk":
+  const normalized = normalizeSeverity(severity);
+  switch (normalized) {
+    case "critical" /* Critical */:
       return chalkInstance.red;
-    case "major":
-    case "moderate-risk":
+    case "major" /* Major */:
       return chalkInstance.yellow;
-    case "minor":
-    case "safe":
+    case "minor" /* Minor */:
       return chalkInstance.green;
-    case "info":
+    case "info" /* Info */:
       return chalkInstance.blue;
     default:
       return chalkInstance.white;
   }
 }
 function getSeverityValue(s) {
-  if (!s) return 0;
-  switch (s.toLowerCase()) {
-    case "critical":
+  const normalized = normalizeSeverity(s);
+  switch (normalized) {
+    case "critical" /* Critical */:
       return 4;
-    case "major":
+    case "major" /* Major */:
       return 3;
-    case "minor":
+    case "minor" /* Minor */:
       return 2;
-    case "info":
+    case "info" /* Info */:
       return 1;
     default:
       return 0;
@@ -640,24 +694,15 @@ function getSeverityEnum(s) {
       return "major";
     case 2:
       return "minor";
-    case 1:
-      return "info";
     default:
       return "info";
   }
 }
 function findLatestReport(dirPath) {
   const aireadyDir = resolvePath(dirPath, ".aiready");
-  if (!existsSync2(aireadyDir)) {
-    return null;
-  }
-  let files = readdirSync(aireadyDir).filter(
-    (f) => f.startsWith("aiready-report-") && f.endsWith(".json")
-  );
+  let files = getFilesByPattern(aireadyDir, /^aiready-report-.*\.json$/);
   if (files.length === 0) {
-    files = readdirSync(aireadyDir).filter(
-      (f) => f.startsWith("aiready-scan-") && f.endsWith(".json")
-    );
+    files = getFilesByPattern(aireadyDir, /^aiready-scan-.*\.json$/);
   }
   if (files.length === 0) {
     return null;
@@ -671,14 +716,8 @@ function findLatestReport(dirPath) {
 }
 function findLatestScanReport(scanReportsDir, reportFilePrefix) {
   try {
-    let reportFiles = [];
-    if (existsSync2(scanReportsDir)) {
-      const files = readdirSync(scanReportsDir);
-      if (files.length > 0) {
-        const prefixRegex = new RegExp(`^${reportFilePrefix}\\d+\\.json$`);
-        reportFiles = files.filter((file) => prefixRegex.test(file));
-      }
-    }
+    const prefixRegex = new RegExp(`^${reportFilePrefix}\\d+\\.json$`);
+    const reportFiles = getFilesByPattern(scanReportsDir, prefixRegex);
     if (reportFiles.length === 0) return null;
     reportFiles.sort((a, b) => {
       const idA = parseInt(a.match(/\d+/)?.[0] || "0", 10);
@@ -692,6 +731,53 @@ function findLatestScanReport(scanReportsDir, reportFilePrefix) {
   }
 }
 
+// src/utils/cli-action-helpers.ts
+import { resolve as resolvePath2 } from "path";
+function getReportTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function handleStandardJSONOutput({
+  outputData,
+  outputFile,
+  resolvedDir,
+  prefix = "aiready-report"
+}) {
+  const outputPath = resolveOutputPath(
+    outputFile,
+    `${prefix}-${getReportTimestamp()}.json`,
+    resolvedDir
+  );
+  handleJSONOutput(outputData, outputPath, `\u2705 Results saved to ${outputPath}`);
+}
+function resolveOutputFormat(options, config) {
+  const format = options.output ?? config.output?.format ?? "console";
+  const file = options.outputFile ?? config.output?.file;
+  return { format, file };
+}
+async function prepareActionConfig(directory, defaults, cliOptions) {
+  const resolvedDir = resolvePath2(process.cwd(), directory ?? ".");
+  const finalOptions = await loadMergedConfig(
+    resolvedDir,
+    defaults,
+    cliOptions
+  );
+  return { resolvedDir, finalOptions };
+}
+function formatStandardReport(params) {
+  const { results, report, summary, elapsedTime, score } = params;
+  const baseData = report ? { ...report } : { results, summary };
+  return {
+    ...baseData,
+    summary: {
+      ...baseData.summary || summary,
+      executionTime: parseFloat(elapsedTime)
+    },
+    ...score && { scoring: score }
+  };
+}
+
 // src/utils/provider-utils.ts
 function groupIssuesByFile(issues) {
   const fileIssuesMap = /* @__PURE__ */ new Map();
@@ -765,1828 +851,129 @@ function calculateImportSimilarity(export1, export2) {
 }
 
 // src/utils/dependency-analyzer.ts
-import { parse as parse2 } from "@typescript-eslint/typescript-estree";
-
-// src/parsers/typescript-parser.ts
 import { parse } from "@typescript-eslint/typescript-estree";
-var TypeScriptParser = class {
+
+// src/parsers/parser-factory.ts
+var ParserFactory = class _ParserFactory {
+  /**
+   * Create a new ParserFactory instance
+   */
   constructor() {
-    this.language = "typescript" /* TypeScript */;
-    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
-  }
-  async initialize() {
-  }
-  canHandle(filePath) {
-    return this.extensions.some((ext) => filePath.endsWith(ext));
-  }
-  async getAST(code, filePath) {
-    try {
-      return parse(code, {
-        filePath,
-        loc: true,
-        range: true,
-        tokens: true,
-        comment: true,
-        jsx: filePath.endsWith("x")
-      });
-    } catch (error) {
-      throw new ParseError(error.message, filePath, {
-        line: error.lineNumber || 1,
-        column: error.column || 0
-      });
-    }
-  }
-  parse(code, filePath) {
-    try {
-      const ast = parse(code, {
-        filePath,
-        loc: true,
-        range: true,
-        tokens: true,
-        comment: true,
-        jsx: filePath.endsWith("x")
-      });
-      const imports = this.extractImports(ast);
-      const exports = this.extractExports(ast, code);
-      return {
-        exports,
-        imports,
-        language: this.language
-      };
-    } catch (error) {
-      throw new ParseError(error.message, filePath, {
-        line: error.lineNumber || 1,
-        column: error.column || 0
-      });
-    }
-  }
-  getNamingConventions() {
-    return {
-      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
-      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      constantPattern: /^[A-Z][A-Z0-9_]*$/,
-      typePattern: /^[A-Z][a-zA-Z0-9]*$/,
-      interfacePattern: /^I?[A-Z][a-zA-Z0-9]*$/
-    };
-  }
-  analyzeMetadata(node, code) {
-    if (!code) return {};
-    return {
-      isPure: this.isLikelyPure(node),
-      hasSideEffects: !this.isLikelyPure(node)
-    };
-  }
-  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, code) {
-    const exports = [];
-    for (const node of ast.body) {
-      if (node.type === "ExportNamedDeclaration") {
-        if (node.declaration) {
-          const declaration = node.declaration;
-          if ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") && declaration.id) {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "function",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code
-              )
-            );
-          } else if (declaration.type === "ClassDeclaration" && declaration.id) {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "class",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code
-              )
-            );
-          } else if (declaration.type === "TSTypeAliasDeclaration") {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "type",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code
-              )
-            );
-          } else if (declaration.type === "TSInterfaceDeclaration") {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "interface",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code
-              )
-            );
-          } else if (declaration.type === "VariableDeclaration") {
-            for (const decl of declaration.declarations) {
-              if (decl.id.type === "Identifier") {
-                exports.push(
-                  this.createExport(
-                    decl.id.name,
-                    "const",
-                    node,
-                    // Pass the outer ExportNamedDeclaration
-                    code,
-                    decl.init
-                  )
-                );
-              }
-            }
-          }
-        }
-      } else if (node.type === "ExportDefaultDeclaration") {
-        exports.push(this.createExport("default", "default", node, code));
-      }
-    }
-    return exports;
-  }
-  createExport(name, type, node, code, initializer) {
-    const documentation = this.extractDocumentation(node, code);
-    let methodCount;
-    let propertyCount;
-    let parameters;
-    let isPrimitive = false;
-    if (initializer) {
-      if (initializer.type === "Literal" || initializer.type === "TemplateLiteral" && initializer.expressions.length === 0) {
-        isPrimitive = true;
-      }
-    }
-    const structNode = node.type === "ExportNamedDeclaration" ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-    if (structNode.type === "ClassDeclaration" || structNode.type === "TSInterfaceDeclaration") {
-      const body = structNode.type === "ClassDeclaration" ? structNode.body.body : structNode.body.body;
-      methodCount = body.filter(
-        (m) => m.type === "MethodDefinition" || m.type === "TSMethodSignature"
-      ).length;
-      propertyCount = body.filter(
-        (m) => m.type === "PropertyDefinition" || m.type === "TSPropertySignature"
-      ).length;
-      if (structNode.type === "ClassDeclaration") {
-        const constructor = body.find(
-          (m) => m.type === "MethodDefinition" && m.kind === "constructor"
-        );
-        if (constructor && constructor.value && constructor.value.params) {
-          parameters = constructor.value.params.map((p) => {
-            if (p.type === "Identifier") return p.name;
-            if (p.type === "TSParameterProperty" && p.parameter.type === "Identifier") {
-              return p.parameter.name;
-            }
-            return void 0;
-          }).filter(Boolean);
-        }
-      }
-    }
-    if (!parameters && (structNode.type === "FunctionDeclaration" || structNode.type === "TSDeclareFunction" || structNode.type === "MethodDefinition")) {
-      const funcNode = structNode.type === "MethodDefinition" ? structNode.value : structNode;
-      if (funcNode && funcNode.params) {
-        parameters = funcNode.params.map((p) => {
-          if (p.type === "Identifier") return p.name;
-          return void 0;
-        }).filter(Boolean);
-      }
-    }
-    return {
-      name,
-      type,
-      isPrimitive,
-      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,
-      documentation,
-      methodCount,
-      propertyCount,
-      parameters,
-      isPure: this.isLikelyPure(node),
-      hasSideEffects: !this.isLikelyPure(node)
-    };
-  }
-  extractDocumentation(node, code) {
-    if (node.range) {
-      const start = node.range[0];
-      const precedingCode = code.substring(0, start);
-      const jsdocMatch = precedingCode.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
-      if (jsdocMatch) {
-        return {
-          content: jsdocMatch[1].trim(),
-          type: "jsdoc"
-        };
-      }
-    }
-    return void 0;
+    this.parsers = /* @__PURE__ */ new Map();
+    this.registeredParsers = /* @__PURE__ */ new Map();
+    this.extensionMap = new Map(
+      Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
+    );
+    this.registerLazyParser("typescript" /* TypeScript */, async () => {
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-ZJKROMQG.mjs");
+      return new TypeScriptParser2();
+    });
+    this.registerLazyParser("javascript" /* JavaScript */, async () => {
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-ZJKROMQG.mjs");
+      return new TypeScriptParser2();
+    });
+    this.registerLazyParser("python" /* Python */, async () => {
+      const { PythonParser: PythonParser2 } = await import("./python-parser-FNFK2473.mjs");
+      return new PythonParser2();
+    });
+    this.registerLazyParser("java" /* Java */, async () => {
+      const { JavaParser: JavaParser2 } = await import("./java-parser-3KHXOXRQ.mjs");
+      return new JavaParser2();
+    });
+    this.registerLazyParser("csharp" /* CSharp */, async () => {
+      const { CSharpParser: CSharpParser2 } = await import("./csharp-parser-5HKICCRR.mjs");
+      return new CSharpParser2();
+    });
+    this.registerLazyParser("go" /* Go */, async () => {
+      const { GoParser: GoParser2 } = await import("./go-parser-XOM232XZ.mjs");
+      return new GoParser2();
+    });
   }
-  isLikelyPure(node) {
-    const structNode = node.type === "ExportNamedDeclaration" ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-    if (structNode.type === "VariableDeclaration" && structNode.kind === "const")
-      return true;
-    if (structNode.type === "FunctionDeclaration" || structNode.type === "TSDeclareFunction" || structNode.type === "MethodDefinition" && structNode.value) {
-      const body = structNode.type === "MethodDefinition" ? structNode.value.body : structNode.body;
-      if (body && body.type === "BlockStatement") {
-        const bodyContent = JSON.stringify(body);
-        if (bodyContent.includes('"name":"console"') || bodyContent.includes('"name":"process"') || bodyContent.includes('"type":"AssignmentExpression"')) {
-          return false;
-        }
-        return true;
-      }
-      return true;
-    }
-    return false;
+  /**
+   * Register a lazy-loaded parser
+   */
+  registerLazyParser(language, loader) {
+    this.registeredParsers.set(language, loader);
   }
-};
-
-// src/parsers/metadata-utils.ts
-function analyzeNodeMetadata(node, code, options) {
-  const metadata = {
-    isPure: true,
-    hasSideEffects: false
-  };
-  try {
-    let prev = node.previousSibling || null;
-    while (prev && /comment/i.test(prev.type)) {
-      const text = prev.text || "";
-      const loc = {
-        start: {
-          line: prev.startPosition.row + 1,
-          column: prev.startPosition.column
-        },
-        end: {
-          line: prev.endPosition.row + 1,
-          column: prev.endPosition.column
-        }
-      };
-      if (text.trim().startsWith("/**") || text.trim().startsWith("/*")) {
-        metadata.documentation = {
-          content: text.replace(/^[/*]+|[/*]+$/g, "").trim(),
-          type: "comment",
-          loc
-        };
-        break;
-      }
-      if (text.trim().startsWith("///")) {
-        metadata.documentation = {
-          content: text.replace(/^\/\/\//, "").trim(),
-          type: "xml-doc",
-          loc
-        };
-        break;
-      }
-      if (text.trim().startsWith("//")) {
-        metadata.documentation = {
-          content: text.replace(/^\/\//, "").trim(),
-          type: "comment",
-          loc
-        };
-        break;
-      }
-      prev = prev.previousSibling;
-    }
-    if (node.type === "function_definition" || node.type === "class_definition") {
-      const body2 = node.childForFieldName ? node.childForFieldName("body") : node.children.find((c) => c.type === "block");
-      if (body2 && body2.children.length > 0) {
-        const firstStmt = body2.children[0];
-        if (firstStmt.type === "expression_statement" && firstStmt.firstChild?.type === "string") {
-          metadata.documentation = {
-            content: firstStmt.firstChild.text.replace(/['"`]/g, "").trim(),
-            type: "docstring",
-            loc: {
-              start: {
-                line: firstStmt.startPosition.row + 1,
-                column: firstStmt.startPosition.column
-              },
-              end: {
-                line: firstStmt.endPosition.row + 1,
-                column: firstStmt.endPosition.column
-              }
-            }
-          };
-        }
-      }
+  /**
+   * Get the global singleton instance
+   *
+   * @returns The singleton ParserFactory instance
+   */
+  static getInstance() {
+    if (!_ParserFactory.instance) {
+      _ParserFactory.instance = new _ParserFactory();
     }
-  } catch {
+    return _ParserFactory.instance;
   }
-  const defaultSignatures = [
-    "console.",
-    "fmt.",
-    "panic(",
-    "os.Exit",
-    "log.",
-    "Console.Write",
-    "File.Write",
-    "System.out",
-    "System.err",
-    "Files.write",
-    "process.exit",
-    "exit("
-  ];
-  const signatures = Array.from(
-    /* @__PURE__ */ new Set([...options?.sideEffectSignatures || [], ...defaultSignatures])
-  );
-  const walk = (n) => {
-    try {
-      const t = n.type || "";
-      if (/assign|assignment|assignment_statement|assignment_expression|throw|throw_statement|send_statement|global_statement|nonlocal_statement/i.test(
-        t
-      )) {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      const text = n.text || "";
-      for (const s of signatures) {
-        if (text.includes(s)) {
-          metadata.isPure = false;
-          metadata.hasSideEffects = true;
-          break;
-        }
-      }
-      for (let i = 0; i < n.childCount; i++) {
-        const c = n.child(i);
-        if (c) walk(c);
-      }
-    } catch {
-    }
-  };
-  const body = node.childForFieldName?.("body") || node.children.find(
-    (c) => /body|block|class_body|declaration_list|function_body/.test(c.type)
-  );
-  if (body) walk(body);
-  return metadata;
-}
-
-// src/parsers/tree-sitter-utils.ts
-import * as Parser from "web-tree-sitter";
-import * as path from "path";
-import * as fs from "fs";
-var isTreeSitterInitialized = false;
-async function initTreeSitter() {
-  if (isTreeSitterInitialized) return;
-  try {
-    const wasmPath = getWasmPath("web-tree-sitter");
-    await Parser.Parser.init({
-      locateFile() {
-        return wasmPath || "web-tree-sitter.wasm";
-      }
+  /**
+   * 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);
     });
-    isTreeSitterInitialized = true;
-  } catch (error) {
-    console.error("Failed to initialize web-tree-sitter:", error);
-    isTreeSitterInitialized = true;
-  }
-}
-function findInPnpmStore(startDir, fileName, depth = 0) {
-  if (depth > 8) return null;
-  const pnpmDir = path.join(startDir, "node_modules", ".pnpm");
-  if (fs.existsSync(pnpmDir)) {
-    return findFileRecursively(pnpmDir, fileName, 0);
   }
-  const parent = path.dirname(startDir);
-  if (parent === startDir) return null;
-  return findInPnpmStore(parent, fileName, depth + 1);
-}
-function findFileRecursively(dir, fileName, depth) {
-  if (depth > 6) return null;
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name === fileName) {
-        return path.join(dir, entry.name);
-      }
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const found = findFileRecursively(
-          path.join(dir, entry.name),
-          fileName,
-          depth + 1
-        );
-        if (found) return found;
-      }
+  /**
+   * Get parser for a specific language
+   */
+  async getParserForLanguage(language) {
+    const parser = this.parsers.get(language);
+    if (parser) return parser;
+    const loader = this.registeredParsers.get(language);
+    if (loader) {
+      const loadedParser = await loader();
+      this.parsers.set(language, loadedParser);
+      return loadedParser;
     }
-  } catch {
-  }
-  return null;
-}
-function getWasmPath(language) {
-  const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
-  const immediatePaths = [
-    path.join(process.cwd(), wasmFileName),
-    path.join(__dirname, wasmFileName),
-    path.join(__dirname, "assets", wasmFileName)
-  ];
-  for (const p of immediatePaths) {
-    if (fs.existsSync(p)) return p;
-  }
-  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
-  if (pnpmPath) return pnpmPath;
-  const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
-  if (pnpmPathCwd) return pnpmPathCwd;
-  console.warn(
-    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
-  );
-  return null;
-}
-async function setupParser(language) {
-  await initTreeSitter();
-  const wasmPath = getWasmPath(language);
-  if (!wasmPath) {
-    return null;
-  }
-  try {
-    const parser = new Parser.Parser();
-    const Lang = await Parser.Language.load(wasmPath);
-    parser.setLanguage(Lang);
-    return parser;
-  } catch {
     return null;
   }
-}
-
-// src/parsers/base-parser.ts
-var BaseLanguageParser = class {
-  constructor() {
-    this.parser = null;
-    this.initialized = false;
-  }
   /**
-   * Initialize the tree-sitter parser
+   * Get parser for a file based on its extension
    */
-  async initialize() {
-    if (this.initialized) return;
-    try {
-      this.parser = await setupParser(this.getParserName());
-      this.initialized = true;
-    } catch (error) {
-      console.warn(`Failed to initialize ${this.language} parser:`, error);
-    }
-  }
-  async getAST(code, _filePath) {
-    void _filePath;
-    if (!this.initialized) await this.initialize();
-    if (!this.parser) return null;
-    return this.parser.parse(code);
-  }
-  parse(code, filePath) {
-    if (!this.initialized || !this.parser) {
-      return this.parseRegex(code, filePath);
-    }
-    try {
-      const tree = this.parser.parse(code);
-      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
-        return this.parseRegex(code, filePath);
-      }
-      const imports = this.extractImportsAST(tree.rootNode);
-      const exports = this.extractExportsAST(tree.rootNode, code);
-      return {
-        exports,
-        imports,
-        language: this.language,
-        warnings: []
-      };
-    } catch (error) {
-      console.warn(
-        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
-      );
-      return this.parseRegex(code, filePath);
+  async getParserForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    const language = this.extensionMap.get(ext);
+    if (!language) {
+      return null;
     }
+    return this.getParserForLanguage(language);
   }
-  canHandle(filePath) {
-    const lowerPath = filePath.toLowerCase();
-    return this.extensions.some((ext) => lowerPath.endsWith(ext));
+  /**
+   * Check if a file is supported (synchronous check based on extension)
+   */
+  isSupported(filePath) {
+    const ext = this.getFileExtension(filePath);
+    return this.extensionMap.has(ext);
   }
-};
-
-// src/parsers/python-parser.ts
-var PythonParser = class extends BaseLanguageParser {
-  constructor() {
-    super(...arguments);
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
+  /**
+   * Get all registered languages
+   */
+  getSupportedLanguages() {
+    const languages = /* @__PURE__ */ new Set([
+      ...this.parsers.keys(),
+      ...this.registeredParsers.keys()
+    ]);
+    return Array.from(languages);
   }
-  getParserName() {
-    return "python";
+  /**
+   * Get all supported file extensions
+   */
+  getSupportedExtensions() {
+    return Array.from(this.extensionMap.keys());
   }
   /**
-   * Analyze metadata for a Python node (purity, side effects).
-   *
-   * @param node - Tree-sitter node to analyze.
-   * @param code - Source code for context.
-   * @returns Partial ExportInfo containing discovered metadata.
+   * Get language for a file
    */
-  analyzeMetadata(node, code) {
-    return analyzeNodeMetadata(node, code, {
-      sideEffectSignatures: ["print(", "input(", "open("]
-    });
+  getLanguageForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    return this.extensionMap.get(ext) || null;
   }
   /**
-   * Extract import information using AST walk.
-   *
-   * @param rootNode - Root node of the Python AST.
-   * @returns Array of discovered FileImport objects.
-   */
-  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;
-  }
-  /**
-   * Extract export information using AST walk.
-   *
-   * @param rootNode - Root node of the Python AST.
-   * @param code - Source code for documentation extraction.
-   * @returns Array of discovered ExportInfo objects.
-   */
-  extractExportsAST(rootNode, code) {
-    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) {
-            const metadata = this.analyzeMetadata(node, code);
-            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),
-              ...metadata
-            });
-          }
-        }
-      } else if (node.type === "class_definition") {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          const metadata = this.analyzeMetadata(node, code);
-          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
-              }
-            },
-            ...metadata
-          });
-        }
-      } 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;
-  }
-  /**
-   * Extract parameter names from a function definition node.
-   *
-   * @param node - Function definition node.
-   * @returns Array of parameter name strings.
-   */
-  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";
-    });
-  }
-  /**
-   * Fallback regex-based parsing when tree-sitter is unavailable.
-   *
-   * @param code - Source code content.
-   * @param filePath - Path to the file being parsed.
-   * @returns Consolidated ParseResult.
-   */
-  parseRegex(code, filePath) {
-    try {
-      const imports = this.extractImportsRegex(code, filePath);
-      const exports = this.extractExportsRegex(code, filePath);
-      return {
-        exports,
-        imports,
-        language: "python" /* Python */,
-        warnings: [
-          "Python parsing is currently using regex-based extraction as tree-sitter wasm was not available."
-        ]
-      };
-    } catch (error) {
-      const wrapper = new Error(
-        `Failed to parse Python file ${filePath}: ${error.message}`
-      );
-      wrapper.cause = error;
-      throw wrapper;
-    }
-  }
-  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__"
-      ]
-    };
-  }
-  canHandle(filePath) {
-    return filePath.toLowerCase().endsWith(".py");
-  }
-  extractImportsRegex(code, _filePath) {
-    void _filePath;
-    const imports = [];
-    const lines = code.split("\n");
-    const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
-    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((module) => {
-          imports.push({
-            source: module,
-            specifiers: [module],
-            loc: {
-              start: { line: idx + 1, column: 0 },
-              end: { line: idx + 1, column: line.length }
-            }
-          });
-        });
-        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 }
-            }
-          });
-          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) {
-    void _filePath;
-    const exports = [];
-    const lines = code.split("\n");
-    const funcRegex = /^def\s+([a-zA-Z0-9_]+)\s*\(/;
-    const classRegex = /^class\s+([a-zA-Z0-9_]+)/;
-    lines.forEach((line, idx) => {
-      const indent = line.search(/\S/);
-      if (indent !== 0) return;
-      const classMatch = line.match(classRegex);
-      if (classMatch) {
-        exports.push({
-          name: classMatch[1],
-          type: "class",
-          visibility: "public",
-          isPure: true,
-          hasSideEffects: false,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-        return;
-      }
-      const funcMatch = line.match(funcRegex);
-      if (funcMatch) {
-        const name = funcMatch[1];
-        if (name.startsWith("_") && !name.startsWith("__")) return;
-        let docContent;
-        const nextLines = lines.slice(idx + 1, idx + 4);
-        for (const nextLine of nextLines) {
-          const docMatch = nextLine.match(/^\s*"""([\s\S]*?)"""/) || nextLine.match(/^\s*'''([\s\S]*?)'''/);
-          if (docMatch) {
-            docContent = docMatch[1].trim();
-            break;
-          }
-          if (nextLine.trim() && !nextLine.trim().startsWith('"""') && !nextLine.trim().startsWith("'''"))
-            break;
-        }
-        const isImpure = name.toLowerCase().includes("impure") || line.includes("print(") || idx + 1 < lines.length && lines[idx + 1].includes("print(");
-        exports.push({
-          name,
-          type: "function",
-          visibility: "public",
-          isPure: !isImpure,
-          hasSideEffects: isImpure,
-          documentation: docContent ? { content: docContent, type: "docstring" } : void 0,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return exports;
-  }
-};
-
-// src/parsers/shared-parser-utils.ts
-var SIDE_EFFECT_KEYWORDS = [
-  "print(",
-  "console.",
-  "System.out",
-  "System.err",
-  "fmt.",
-  "File.Write",
-  "Files.write",
-  "os.Exit",
-  "panic(",
-  "throw ",
-  "Logging.",
-  "log."
-];
-function analyzeGeneralMetadata(node, code, options = {}) {
-  const metadata = {
-    isPure: true,
-    hasSideEffects: false
-  };
-  try {
-    let prev = node.previousSibling || null;
-    while (prev && /comment/i.test(prev.type)) {
-      const text = prev.text || "";
-      if (text.trim().startsWith("/**")) {
-        metadata.documentation = {
-          content: text.replace(/^[/*]+|[/*]+$/g, "").trim(),
-          type: "jsdoc"
-        };
-        break;
-      }
-      if (text.trim().startsWith("///")) {
-        metadata.documentation = {
-          content: text.replace(/^\/\/\//, "").trim(),
-          type: "xml-doc"
-        };
-        break;
-      }
-      if (text.trim().startsWith("//")) {
-        metadata.documentation = {
-          content: text.replace(/^\/\//, "").trim(),
-          type: "comment"
-        };
-        break;
-      }
-      prev = prev.previousSibling;
-    }
-  } catch {
-  }
-  const signatures = [
-    ...SIDE_EFFECT_KEYWORDS,
-    ...options.sideEffectSignatures || []
-  ];
-  const walk = (n) => {
-    if (/assign|assignment|assignment_statement|assignment_expression/i.test(
-      n.type
-    )) {
-      metadata.isPure = false;
-      metadata.hasSideEffects = true;
-    }
-    const text = n.text;
-    for (const sig of signatures) {
-      if (text.includes(sig)) {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-        break;
-      }
-    }
-    if (!metadata.hasSideEffects) {
-      for (let i = 0; i < n.childCount; i++) {
-        const child = n.child(i);
-        if (child) walk(child);
-      }
-    }
-  };
-  walk(node);
-  return metadata;
-}
-function extractParameterNames(node) {
-  const params = [];
-  const candidates = [
-    // common field name
-    node.childForFieldName ? node.childForFieldName("parameters") : null,
-    node.childForFieldName ? node.childForFieldName("parameter_list") : null,
-    node.children.find((c) => c.type === "parameter_list") || null,
-    node.children.find((c) => c.type === "parameters") || null,
-    node.children.find((c) => c.type === "formal_parameters") || null,
-    node.children.find((c) => c.type === "formal_parameter") || null
-  ];
-  const list = candidates.find(Boolean);
-  if (!list) return params;
-  for (const child of list.children) {
-    if (!child) continue;
-    const id = child.childForFieldName?.("name") || child.children.find(
-      (c) => [
-        "identifier",
-        "variable_name",
-        "name",
-        "parameter",
-        "formal_parameter"
-      ].includes(c.type)
-    ) || (child.type === "identifier" ? child : void 0);
-    if (id && typeof id.text === "string") params.push(id.text);
-  }
-  return params;
-}
-
-// src/parsers/java-parser.ts
-var JavaParser = class extends BaseLanguageParser {
-  constructor() {
-    super(...arguments);
-    this.language = "java" /* Java */;
-    this.extensions = [".java"];
-  }
-  getParserName() {
-    return "java";
-  }
-  /**
-   * Analyze metadata for a Java node (purity, side effects).
-   *
-   * @param node - Tree-sitter node to analyze.
-   * @param code - Source code for context.
-   * @returns Partial ExportInfo containing discovered metadata.
-   */
-  analyzeMetadata(node, code) {
-    return analyzeGeneralMetadata(node, code, {
-      sideEffectSignatures: [
-        "System.out",
-        "System.err",
-        "Files.write",
-        "Logging."
-      ]
-    });
-  }
-  parseRegex(code) {
-    const lines = code.split("\n");
-    const exports = [];
-    const imports = [];
-    const importRegex = /^import\s+([a-zA-Z0-9_.]+)/;
-    const classRegex = /^\s*(?:public\s+)?(?:class|interface|enum)\s+([a-zA-Z0-9_]+)/;
-    const methodRegex = /^\s*public\s+(?:static\s+)?[a-zA-Z0-9_<>[\]]+\s+([a-zA-Z0-9_]+)\s*\(/;
-    let currentClassName = "";
-    lines.forEach((line, idx) => {
-      const importMatch = line.match(importRegex);
-      if (importMatch) {
-        const source = importMatch[1];
-        imports.push({
-          source,
-          specifiers: [source.split(".").pop() || source],
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const classMatch = line.match(classRegex);
-      if (classMatch) {
-        currentClassName = classMatch[1];
-        exports.push({
-          name: currentClassName,
-          type: line.includes("interface") ? "interface" : "class",
-          visibility: "public",
-          isPure: true,
-          hasSideEffects: false,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const methodMatch = line.match(methodRegex);
-      if (methodMatch && currentClassName) {
-        const name = methodMatch[1];
-        let docContent;
-        const prevLines = lines.slice(Math.max(0, idx - 5), idx);
-        const prevText = prevLines.join("\n");
-        const javadocMatch = prevText.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
-        if (javadocMatch) {
-          docContent = javadocMatch[1].replace(/^\s*\*+/gm, "").trim();
-        }
-        const isImpure = name.toLowerCase().includes("impure") || line.includes("System.out");
-        exports.push({
-          name,
-          type: "function",
-          parentClass: currentClassName,
-          visibility: "public",
-          isPure: !isImpure,
-          hasSideEffects: isImpure,
-          documentation: docContent ? { content: docContent, type: "jsdoc" } : void 0,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return {
-      exports,
-      imports,
-      language: "java" /* Java */,
-      warnings: ["Parser falling back to regex-based analysis"]
-    };
-  }
-  /**
-   * Extract import information using AST walk.
-   *
-   * @param rootNode - Root node of the Java AST.
-   * @returns Array of discovered FileImport objects.
-   */
-  extractImportsAST(rootNode) {
-    const imports = [];
-    for (const node of rootNode.children) {
-      if (node.type === "import_declaration") {
-        const sourceArr = [];
-        let isWildcard = false;
-        for (const child of node.children) {
-          if (child.type === "scoped_identifier" || child.type === "identifier") {
-            sourceArr.push(child.text);
-          }
-          if (child.type === "asterisk") isWildcard = true;
-        }
-        const source = sourceArr.join(".");
-        if (source) {
-          imports.push({
-            source: isWildcard ? `${source}.*` : source,
-            specifiers: isWildcard ? ["*"] : [source.split(".").pop() || source],
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            }
-          });
-        }
-      }
-    }
-    return imports;
-  }
-  /**
-   * Extract export information (classes, interfaces, methods) using AST walk.
-   *
-   * @param rootNode - Root node of the Java AST.
-   * @param code - Source code for documentation extraction.
-   * @returns Array of discovered ExportInfo objects.
-   */
-  extractExportsAST(rootNode, code) {
-    const exports = [];
-    for (const node of rootNode.children) {
-      if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration") {
-        const nameNode = node.children.find((c) => c.type === "identifier");
-        if (nameNode) {
-          const modifiers = this.getModifiers(node);
-          const metadata = this.analyzeMetadata(node, code);
-          exports.push({
-            name: nameNode.text,
-            type: node.type === "class_declaration" ? "class" : "interface",
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            },
-            visibility: modifiers.includes("public") ? "public" : "private",
-            ...metadata
-          });
-          this.extractSubExports(node, nameNode.text, exports, code);
-        }
-      }
-    }
-    return exports;
-  }
-  /**
-   * Extract modifiers (visibility, static, etc.) from a node.
-   *
-   * @param node - AST node to extract modifiers from.
-   * @returns Array of modifier strings.
-   */
-  getModifiers(node) {
-    const modifiersNode = node.children.find((c) => c.type === "modifiers");
-    if (!modifiersNode) return [];
-    return modifiersNode.children.map((c) => c.text);
-  }
-  /**
-   * Extract methods and nested exports from a class or interface body.
-   *
-   * @param parentNode - Class or interface declaration node.
-   * @param parentName - Name of the parent class/interface.
-   * @param exports - Array to collect discovered exports into.
-   * @param code - Source code for context.
-   */
-  extractSubExports(parentNode, parentName, exports, code) {
-    const bodyNode = parentNode.children.find((c) => c.type === "class_body");
-    if (!bodyNode) return;
-    for (const node of bodyNode.children) {
-      if (node.type === "method_declaration") {
-        const nameNode = node.children.find((c) => c.type === "identifier");
-        const modifiers = this.getModifiers(node);
-        if (nameNode && modifiers.includes("public")) {
-          const metadata = this.analyzeMetadata(node, code);
-          exports.push({
-            name: nameNode.text,
-            type: "function",
-            parentClass: parentName,
-            visibility: "public",
-            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),
-            ...metadata
-          });
-        }
-      }
-    }
-  }
-  extractParameters(node) {
-    return extractParameterNames(node);
-  }
-  getNamingConventions() {
-    return {
-      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
-      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      constantPattern: /^[A-Z][A-Z0-9_]*$/,
-      exceptions: ["main", "serialVersionUID"]
-    };
-  }
-  canHandle(filePath) {
-    return filePath.toLowerCase().endsWith(".java");
-  }
-};
-
-// src/parsers/csharp-parser.ts
-var CSharpParser = class extends BaseLanguageParser {
-  constructor() {
-    super(...arguments);
-    this.language = "csharp" /* CSharp */;
-    this.extensions = [".cs"];
-  }
-  getParserName() {
-    return "c_sharp";
-  }
-  /**
-   * Analyze metadata for a C# node (purity, side effects).
-   *
-   * @param node - Tree-sitter node to analyze.
-   * @param code - Source code for context.
-   * @returns Partial ExportInfo containing discovered metadata.
-   */
-  analyzeMetadata(node, code) {
-    return analyzeGeneralMetadata(node, code, {
-      sideEffectSignatures: ["Console.Write", "File.Write", "Logging."]
-    });
-  }
-  /**
-   * Fallback regex-based parsing when tree-sitter is unavailable.
-   *
-   * @param code - Source code content.
-   * @returns Consolidated ParseResult.
-   */
-  parseRegex(code) {
-    const lines = code.split("\n");
-    const exports = [];
-    const imports = [];
-    const usingRegex = /^using\s+([a-zA-Z0-9_.]+);/;
-    const classRegex = /^\s*(?:public\s+)?class\s+([a-zA-Z0-9_]+)/;
-    const methodRegex = /^\s*(?:public|protected)\s+(?:static\s+)?[a-zA-Z0-9_.]+\s+([a-zA-Z0-9_]+)\s*\(/;
-    let currentClassName = "";
-    lines.forEach((line, idx) => {
-      const usingMatch = line.match(usingRegex);
-      if (usingMatch) {
-        const source = usingMatch[1];
-        imports.push({
-          source,
-          specifiers: [source.split(".").pop() || source],
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const classMatch = line.match(classRegex);
-      if (classMatch) {
-        currentClassName = classMatch[1];
-        exports.push({
-          name: currentClassName,
-          type: "class",
-          visibility: "public",
-          isPure: true,
-          hasSideEffects: false,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const methodMatch = line.match(methodRegex);
-      if (methodMatch && currentClassName) {
-        const name = methodMatch[1];
-        const isImpure = name.toLowerCase().includes("impure") || line.includes("Console.WriteLine");
-        exports.push({
-          name,
-          type: "function",
-          parentClass: currentClassName,
-          visibility: "public",
-          isPure: !isImpure,
-          hasSideEffects: isImpure,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return {
-      exports,
-      imports,
-      language: "csharp" /* CSharp */,
-      warnings: ["Parser falling back to regex-based analysis"]
-    };
-  }
-  /**
-   * Extract import information (usings) using AST walk.
-   *
-   * @param rootNode - Root node of the C# AST.
-   * @returns Array of discovered FileImport objects.
-   */
-  extractImportsAST(rootNode) {
-    const imports = [];
-    const findUsings = (node) => {
-      if (node.type === "using_directive") {
-        const nameNode = node.childForFieldName("name") || node.children.find(
-          (c) => c.type === "qualified_name" || c.type === "identifier"
-        );
-        if (nameNode) {
-          const aliasNode = node.childForFieldName("alias");
-          imports.push({
-            source: nameNode.text,
-            specifiers: aliasNode ? [aliasNode.text] : [nameNode.text.split(".").pop() || nameNode.text],
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            }
-          });
-        }
-      }
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child) findUsings(child);
-      }
-    };
-    findUsings(rootNode);
-    return imports;
-  }
-  /**
-   * Extract export information (classes, methods, properties) using AST walk.
-   * Handles nested namespaces and classes.
-   *
-   * @param rootNode - Root node of the C# AST.
-   * @param code - Source code for documentation extraction.
-   * @returns Array of discovered ExportInfo objects.
-   */
-  extractExportsAST(rootNode, code) {
-    const exports = [];
-    const traverse = (node, currentNamespace, currentClass) => {
-      let nextNamespace = currentNamespace;
-      let nextClass = currentClass;
-      if (node.type === "namespace_declaration" || node.type === "file_scoped_namespace_declaration") {
-        const nameNode = node.childForFieldName("name") || node.children.find(
-          (c) => c.type === "identifier" || c.type === "qualified_name"
-        );
-        if (nameNode) {
-          nextNamespace = currentNamespace ? `${currentNamespace}.${nameNode.text}` : nameNode.text;
-        }
-      } else if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration" || node.type === "struct_declaration" || node.type === "record_declaration") {
-        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
-        if (nameNode) {
-          const modifiers = this.getModifiers(node);
-          const isPublic = modifiers.includes("public") || modifiers.includes("protected");
-          if (isPublic) {
-            const metadata = this.analyzeMetadata(node, code);
-            const type = node.type.replace("_declaration", "");
-            const fullName = nextClass ? `${nextClass}.${nameNode.text}` : nextNamespace ? `${nextNamespace}.${nameNode.text}` : nameNode.text;
-            exports.push({
-              name: fullName,
-              type: type === "record" ? "class" : type,
-              loc: {
-                start: {
-                  line: node.startPosition.row + 1,
-                  column: node.startPosition.column
-                },
-                end: {
-                  line: node.endPosition.row + 1,
-                  column: node.endPosition.column
-                }
-              },
-              visibility: modifiers.includes("public") ? "public" : "protected",
-              ...metadata
-            });
-            nextClass = fullName;
-          }
-        }
-      } else if (node.type === "method_declaration" || node.type === "property_declaration") {
-        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
-        if (nameNode) {
-          const modifiers = this.getModifiers(node);
-          const isPublic = modifiers.includes("public") || modifiers.includes("protected");
-          if (isPublic) {
-            const metadata = this.analyzeMetadata(node, code);
-            exports.push({
-              name: nameNode.text,
-              type: node.type === "method_declaration" ? "function" : "property",
-              parentClass: currentClass,
-              loc: {
-                start: {
-                  line: node.startPosition.row + 1,
-                  column: node.startPosition.column
-                },
-                end: {
-                  line: node.endPosition.row + 1,
-                  column: node.endPosition.column
-                }
-              },
-              visibility: modifiers.includes("public") ? "public" : "protected",
-              parameters: node.type === "method_declaration" ? this.extractParameters(node) : void 0,
-              ...metadata
-            });
-          }
-        }
-      }
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child) traverse(child, nextNamespace, nextClass);
-      }
-    };
-    traverse(rootNode);
-    return exports;
-  }
-  getModifiers(node) {
-    const modifiers = [];
-    for (const child of node.children) {
-      if (child.type === "modifier") {
-        modifiers.push(child.text);
-      }
-    }
-    return modifiers;
-  }
-  extractParameters(node) {
-    return extractParameterNames(node);
-  }
-  getNamingConventions() {
-    return {
-      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
-      functionPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      constantPattern: /^[A-Z][a-zA-Z0-9_]*$/
-    };
-  }
-  canHandle(filePath) {
-    return filePath.toLowerCase().endsWith(".cs");
-  }
-};
-
-// src/parsers/go-parser.ts
-var GoParser = class extends BaseLanguageParser {
-  constructor() {
-    super(...arguments);
-    this.language = "go" /* Go */;
-    this.extensions = [".go"];
-  }
-  getParserName() {
-    return "go";
-  }
-  /**
-   * Analyze metadata for a Go node (purity, side effects).
-   *
-   * @param node - Tree-sitter node to analyze.
-   * @param code - Source code for context.
-   * @returns Partial ExportInfo containing discovered metadata.
-   */
-  analyzeMetadata(node, code) {
-    return analyzeGeneralMetadata(node, code, {
-      sideEffectSignatures: ["<-", "fmt.Print", "fmt.Fprintf", "os.Exit"]
-    });
-  }
-  /**
-   * Fallback regex-based parsing when tree-sitter is unavailable.
-   *
-   * @param code - Source code content.
-   * @returns Consolidated ParseResult.
-   */
-  parseRegex(code) {
-    const lines = code.split("\n");
-    const exports = [];
-    const imports = [];
-    const importRegex = /^import\s+"([^"]+)"/;
-    const funcRegex = /^func\s+([A-Z][a-zA-Z0-9_]*)\s*\(/;
-    const typeRegex = /^type\s+([A-Z][a-zA-Z0-9_]*)\s+(struct|interface)/;
-    lines.forEach((line, idx) => {
-      const importMatch = line.match(importRegex);
-      if (importMatch) {
-        const source = importMatch[1];
-        imports.push({
-          source,
-          specifiers: [source.split("/").pop() || source],
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const funcMatch = line.match(funcRegex);
-      if (funcMatch) {
-        const name = funcMatch[1];
-        const isPublic = /^[A-Z]/.test(name);
-        let docContent;
-        const prevLines = lines.slice(Math.max(0, idx - 3), idx);
-        for (let i = prevLines.length - 1; i >= 0; i--) {
-          const prevLine = prevLines[i].trim();
-          if (prevLine.startsWith("//")) {
-            const content = prevLine.slice(2).trim();
-            docContent = docContent ? content + "\n" + docContent : content;
-          } else if (prevLine.endsWith("*/")) {
-            const blockMatch = prevLine.match(/\/\*([\s\S]*)\*\//);
-            if (blockMatch) docContent = blockMatch[1].trim();
-            break;
-          } else if (!prevLine) {
-            if (docContent) break;
-          } else {
-            break;
-          }
-        }
-        const isImpure = name.toLowerCase().includes("impure") || line.includes("fmt.Print");
-        exports.push({
-          name,
-          type: "function",
-          visibility: isPublic ? "public" : "private",
-          isPure: !isImpure,
-          hasSideEffects: isImpure,
-          documentation: docContent ? { content: docContent, type: "comment" } : void 0,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-      const typeMatch = line.match(typeRegex);
-      if (typeMatch) {
-        exports.push({
-          name: typeMatch[1],
-          type: typeMatch[2] === "struct" ? "class" : "interface",
-          visibility: "public",
-          isPure: true,
-          hasSideEffects: false,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return {
-      exports,
-      imports,
-      language: "go" /* Go */,
-      warnings: ["Parser falling back to regex-based analysis"]
-    };
-  }
-  /**
-   * Extract import information using AST walk.
-   *
-   * @param rootNode - Root node of the Go AST.
-   * @returns Array of discovered FileImport objects.
-   */
-  extractImportsAST(rootNode) {
-    const imports = [];
-    const findImports = (node) => {
-      if (node.type === "import_spec") {
-        const pathNode = node.children.find(
-          (c) => c.type === "interpreted_string_literal"
-        );
-        if (pathNode) {
-          const source = pathNode.text.replace(/"/g, "");
-          imports.push({
-            source,
-            specifiers: [source.split("/").pop() || source],
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            }
-          });
-        }
-      }
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child) findImports(child);
-      }
-    };
-    findImports(rootNode);
-    return imports;
-  }
-  /**
-   * Extract export information (functions, types, vars) using AST walk.
-   *
-   * @param rootNode - Root node of the Go AST.
-   * @param code - Source code for documentation extraction.
-   * @returns Array of discovered ExportInfo objects.
-   */
-  extractExportsAST(rootNode, code) {
-    const exports = [];
-    const isExported = (name) => {
-      return /^[A-Z]/.test(name);
-    };
-    const traverse = (node) => {
-      if (node.type === "function_declaration" || node.type === "method_declaration") {
-        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
-        if (nameNode && isExported(nameNode.text)) {
-          const metadata = this.analyzeMetadata(node, code);
-          exports.push({
-            name: nameNode.text,
-            type: "function",
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            },
-            visibility: "public",
-            parameters: this.extractParameters(node),
-            ...metadata
-          });
-        }
-      } else if (node.type === "type_spec") {
-        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "type_identifier");
-        if (nameNode && isExported(nameNode.text)) {
-          const metadata = this.analyzeMetadata(node.parent || node, code);
-          const type = node.children.some((c) => c.type === "struct_type") ? "class" : "interface";
-          exports.push({
-            name: nameNode.text,
-            type,
-            loc: {
-              start: {
-                line: node.startPosition.row + 1,
-                column: node.startPosition.column
-              },
-              end: {
-                line: node.endPosition.row + 1,
-                column: node.endPosition.column
-              }
-            },
-            visibility: "public",
-            ...metadata
-          });
-        }
-      } else if (node.type === "var_spec" || node.type === "const_spec") {
-        const identifiers = node.children.filter(
-          (c) => c.type === "identifier"
-        );
-        for (const idNode of identifiers) {
-          if (isExported(idNode.text)) {
-            const metadata = this.analyzeMetadata(node, code);
-            exports.push({
-              name: idNode.text,
-              type: "variable",
-              loc: {
-                start: {
-                  line: idNode.startPosition.row + 1,
-                  column: idNode.startPosition.column
-                },
-                end: {
-                  line: idNode.endPosition.row + 1,
-                  column: idNode.endPosition.column
-                }
-              },
-              visibility: "public",
-              ...metadata
-            });
-          }
-        }
-      }
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child) traverse(child);
-      }
-    };
-    traverse(rootNode);
-    return exports;
-  }
-  extractParameters(node) {
-    return extractParameterNames(node);
-  }
-  getNamingConventions() {
-    return {
-      variablePattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
-      functionPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
-      classPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
-      constantPattern: /^[a-zA-Z_][a-zA-Z0-9_]*$/
-    };
-  }
-  canHandle(filePath) {
-    return filePath.toLowerCase().endsWith(".go");
-  }
-};
-
-// src/parsers/parser-factory.ts
-var ParserFactory = class _ParserFactory {
-  /**
-   * Create a new ParserFactory instance
-   */
-  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());
-    this.registerParser(new JavaParser());
-    this.registerParser(new CSharpParser());
-    this.registerParser(new GoParser());
-  }
-  /**
-   * Get the global singleton instance
-   *
-   * @returns The singleton ParserFactory 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)
+   * Extract file extension (with dot)
    */
   getFileExtension(filePath) {
     const match = filePath.match(/\.[^.]+$/);
@@ -2608,7 +995,7 @@ var ParserFactory = class _ParserFactory {
     await Promise.all(promises);
   }
 };
-function getParser(filePath) {
+async function getParser(filePath) {
   return ParserFactory.getInstance().getParserForFile(filePath);
 }
 async function initializeParsers() {
@@ -2795,10 +1182,11 @@ function extractTypeReferences(node) {
 }
 
 // src/utils/dependency-analyzer.ts
-function parseFileExports(code, filePath) {
-  const parser = getParser(filePath);
+async function parseFileExports(code, filePath) {
+  const parser = await getParser(filePath);
   if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
     try {
+      await parser.initialize();
       const result = parser.parse(code, filePath);
       return {
         exports: result.exports.map((e) => ({
@@ -2823,7 +1211,7 @@ function parseFileExports(code, filePath) {
     }
   }
   try {
-    const ast = parse2(code, {
+    const ast = parse(code, {
       loc: true,
       range: true,
       jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
@@ -2843,8 +1231,8 @@ function estimateTokens(text) {
 }
 
 // src/utils/config.ts
-import { readFileSync, existsSync as existsSync4 } from "fs";
-import { join as join4, resolve, dirname as dirname4 } from "path";
+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",
@@ -2859,7 +1247,7 @@ async function loadConfig(rootDir) {
   while (true) {
     const foundConfigs = [];
     for (const configFile of CONFIG_FILES) {
-      if (existsSync4(join4(currentDir, configFile))) {
+      if (existsSync3(join3(currentDir, configFile))) {
         foundConfigs.push(configFile);
       }
     }
@@ -2873,7 +1261,7 @@ async function loadConfig(rootDir) {
       } else {
       }
       const configFile = foundConfigs[0];
-      const configPath = join4(currentDir, configFile);
+      const configPath = join3(currentDir, configFile);
       try {
         let config;
         if (configFile.endsWith(".js")) {
@@ -2915,7 +1303,7 @@ async function loadConfig(rootDir) {
         throw configError;
       }
     }
-    const parent = dirname4(currentDir);
+    const parent = dirname3(currentDir);
     if (parent === currentDir) {
       break;
     }
@@ -2947,6 +1335,450 @@ function mergeConfigWithDefaults(userConfig, defaults) {
   return mergedConfig;
 }
 
+// src/utils/report-formatters.ts
+function generateReportHead(title) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 2rem; background-color: #f9f9f9; }
+    h1, h2, h3 { color: #1a1a1a; border-bottom: 2px solid #eaeaea; padding-bottom: 0.5rem; }
+    .card { background: white; padding: 1.5rem; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); margin-bottom: 2rem; border: 1px solid #eaeaea; }
+    .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+    .stat-card { background: #fff; padding: 1rem; border-radius: 6px; text-align: center; border: 1px solid #eaeaea; }
+    .stat-value { font-size: 1.8rem; font-weight: bold; color: #2563eb; }
+    .stat-label { font-size: 0.875rem; color: #666; text-transform: uppercase; }
+    .hero { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 8px; margin-bottom: 30px; }
+    .hero h1 { border: none; color: white; margin: 0; }
+    .hero p { margin: 10px 0 0 0; opacity: 0.9; }
+    table { width: 100%; border-collapse: collapse; margin-top: 1rem; background: white; border-radius: 4px; overflow: hidden; }
+    th, td { text-align: left; padding: 0.875rem 1rem; border-bottom: 1px solid #eaeaea; }
+    th { background-color: #f8fafc; font-weight: 600; color: #475569; }
+    tr:last-child td { border-bottom: none; }
+    .critical { color: #dc2626; font-weight: bold; }
+    .major { color: #ea580c; font-weight: bold; }
+    .minor { color: #2563eb; }
+    .issue-critical { color: #dc2626; font-weight: bold; text-transform: uppercase; }
+    .issue-major { color: #ea580c; font-weight: bold; text-transform: uppercase; }
+    .issue-minor { color: #2563eb; font-weight: bold; text-transform: uppercase; }
+    code { background: #f1f5f9; padding: 0.2rem 0.4rem; border-radius: 4px; font-size: 0.875rem; color: #334155; }
+    .footer { margin-top: 4rem; text-align: center; color: #94a3b8; font-size: 0.875rem; }
+    a { color: #2563eb; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+  </style>
+</head>`;
+}
+function generateReportHero(title, subtitle) {
+  const subtitleHtml = subtitle ? `<p>${subtitle}</p>` : "";
+  return `<div class="hero">
+    <h1>${title}</h1>
+    ${subtitleHtml}
+  </div>`;
+}
+function generateStatCards(cards) {
+  const cardsHtml = cards.map(
+    (card) => `
+    <div class="stat-card">
+      <div class="stat-value"${card.color ? ` style="color: ${card.color}"` : ""}>${card.value}</div>
+      <div class="stat-label">${card.label}</div>
+    </div>`
+  ).join("");
+  return `<div class="stats">${cardsHtml}</div>`;
+}
+function generateScoreCard(value, label) {
+  return `<div class="stat-card" style="margin-bottom: 2rem;">
+    <div class="stat-label">${label}</div>
+    <div class="stat-value">${value}</div>
+  </div>`;
+}
+function generateTable(config) {
+  const headersHtml = config.headers.map((h) => `<th>${h}</th>`).join("");
+  const rowsHtml = config.rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join("")}</tr>`).join("");
+  return `<table>
+    <thead><tr>${headersHtml}</tr></thead>
+    <tbody>${rowsHtml}</tbody>
+  </table>`;
+}
+function generateIssueSummary(critical, major, minor, potentialSavings) {
+  const savingsHtml = potentialSavings ? `<p><strong>Potential Savings:</strong> ${potentialSavings.toLocaleString()} tokens</p>` : "";
+  return `<div class="card" style="margin-bottom: 30px;">
+    <h2>\u26A0\uFE0F Issues Summary</h2>
+    <p>
+      <span class="critical">\u{1F534} Critical: ${critical}</span> &nbsp;
+      <span class="major">\u{1F7E1} Major: ${major}</span> &nbsp;
+      <span class="minor">\u{1F535} Minor: ${minor}</span>
+    </p>
+    ${savingsHtml}
+  </div>`;
+}
+function generateReportFooter(options) {
+  const versionText = options.version ? ` v${options.version}` : "";
+  const links = [];
+  if (options.packageUrl) {
+    links.push(`<a href="${options.packageUrl}">Star us on GitHub</a>`);
+  }
+  if (options.bugUrl) {
+    links.push(`<a href="${options.bugUrl}">Report it here</a>`);
+  }
+  const linksHtml = links.length ? links.map((l) => `<p>Like AIReady? ${l}</p>`).join("\n    ") : "";
+  return `<div class="footer">
+    <p>Generated by <strong>@aiready/${options.packageName}</strong>${versionText}</p>
+    ${linksHtml}
+  </div>`;
+}
+function wrapInCard(content, title) {
+  const titleHtml = title ? `<h2>${title}</h2>` : "";
+  return `<div class="card">
+    ${titleHtml}
+    ${content}
+  </div>`;
+}
+function generateCompleteReport(options, bodyContent) {
+  return `${generateReportHead(options.title)}
+<body>
+  ${bodyContent}
+  ${generateReportFooter(options)}
+</body>
+</html>`;
+}
+
+// src/utils/scoring-helpers.ts
+function buildFactorsFromDimensions(dimensions, dimensionNames, rawData) {
+  return Object.entries(dimensionNames).map(([key, name]) => {
+    const val = dimensions[key] ?? 50;
+    return {
+      name,
+      impact: Math.round(val - 50),
+      description: formatDimensionDescription(key, rawData) || `${val}/100`
+    };
+  });
+}
+function formatDimensionDescription(key, rawData) {
+  if (key === "testCoverageRatio" && rawData.testFiles !== void 0) {
+    return `${rawData.testFiles} test files / ${rawData.sourceFiles} source files`;
+  }
+  if (key === "purityScore" && rawData.pureFunctions !== void 0) {
+    return `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`;
+  }
+  if (key === "dependencyInjectionScore" && rawData.injectionPatterns !== void 0) {
+    return `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`;
+  }
+  if (key === "structureClarityScore" && rawData.deepDirectories !== void 0) {
+    return `${rawData.deepDirectories} of ${rawData.totalDirectories} dirs exceed recommended depth`;
+  }
+  if (key === "apiClarityScore" && rawData.untypedExports !== void 0) {
+    return `${rawData.untypedExports} of ${rawData.totalExports} exports lack type annotations`;
+  }
+  if (key === "graphStabilityScore") {
+    return `${rawData.score}/100`;
+  }
+  return void 0;
+}
+function buildStandardToolScore(params) {
+  const {
+    toolName,
+    score,
+    rawData,
+    dimensions,
+    dimensionNames,
+    recommendations,
+    recommendationImpact = 8,
+    rating
+  } = params;
+  const factors = buildFactorsFromDimensions(
+    dimensions,
+    dimensionNames,
+    rawData
+  );
+  const recs = recommendations.map(
+    (action) => ({
+      action,
+      estimatedImpact: recommendationImpact,
+      priority: score < 50 || [
+        "high-risk",
+        "blind-risk",
+        "explosive",
+        "fragile",
+        "critical"
+      ].includes(rating || "") ? "high" /* High */ : "medium" /* Medium */
+    })
+  );
+  return {
+    toolName,
+    score,
+    rawMetrics: {
+      ...rawData,
+      rating: rating || rawData.rating
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+// src/utils/similarity.ts
+function calculateStringSimilarity(a, b) {
+  if (a === b) return 1;
+  const tokensA = a.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
+  const tokensB = b.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
+  if (tokensA.length === 0 || tokensB.length === 0) return 0;
+  const setA = new Set(tokensA);
+  const setB = new Set(tokensB);
+  const intersection = new Set([...setA].filter((x) => setB.has(x)));
+  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+  return intersection.size / union.size;
+}
+function calculateHeuristicConfidence(similarity, tokens, lines) {
+  let confidence = similarity;
+  if (lines > 20) confidence += 0.05;
+  if (tokens > 200) confidence += 0.05;
+  if (lines < 5) confidence -= 0.1;
+  return Math.max(0, Math.min(1, confidence));
+}
+
+// src/utils/cli-factory.ts
+import chalk2 from "chalk";
+function createStandardProgressCallback(toolName) {
+  return (processed, total, message) => {
+    const percent = Math.round(processed / Math.max(1, total) * 100);
+    process.stdout.write(
+      `\r\x1B[K   [${toolName}] ${chalk2.cyan(`${percent}%`)} ${message}`
+    );
+    if (processed === total) {
+      process.stdout.write("\n");
+    }
+  };
+}
+function formatStandardCliResult(toolName, score, issuesCount) {
+  const scoreColor = score >= 75 ? chalk2.green : score >= 50 ? chalk2.yellow : chalk2.red;
+  console.log(`
+${chalk2.bold(toolName.toUpperCase())} Analysis Complete`);
+  console.log(`  Overall Score: ${scoreColor(score)}/100`);
+  console.log(
+    `  Issues Found: ${issuesCount > 0 ? chalk2.red(issuesCount) : chalk2.green("None")}`
+  );
+}
+async function runStandardCliAction(toolName, action) {
+  try {
+    const { score, issuesCount } = await action();
+    formatStandardCliResult(toolName, score, issuesCount);
+  } catch (error) {
+    console.error(
+      chalk2.red(`
+\u274C [${toolName}] critical error: ${error.message}`)
+    );
+    process.exit(1);
+  }
+}
+
+// src/utils/reporting.ts
+import chalk3 from "chalk";
+function getScoreColor(score) {
+  if (score >= 85) return chalk3.green;
+  if (score >= 70) return chalk3.cyan;
+  if (score >= 50) return chalk3.yellow;
+  if (score >= 30) return chalk3.red;
+  return chalk3.bgRed.white;
+}
+function displayStandardConsoleReport(data) {
+  const {
+    title,
+    score,
+    rating,
+    dimensions,
+    stats = [],
+    issues,
+    recommendations = [],
+    elapsedTime,
+    noIssuesMessage = "\u2728 No issues found!",
+    safetyRating
+  } = data;
+  console.log(chalk3.bold(`
+${title}
+`));
+  if (safetyRating) {
+    if (safetyRating === "blind-risk" || safetyRating === "\u{1F480} blind-risk") {
+      console.log(
+        chalk3.bgRed.white.bold(
+          "  \u{1F480} BLIND RISK \u2014 NO TESTS DETECTED. AI-GENERATED CHANGES CANNOT BE VERIFIED.  "
+        )
+      );
+      console.log();
+    } else if (safetyRating === "high-risk" || safetyRating === "\u{1F534} high-risk") {
+      console.log(
+        chalk3.red.bold(
+          `  \u{1F534} HIGH RISK \u2014 Insufficient test coverage. AI changes may introduce silent bugs.`
+        )
+      );
+      console.log();
+    }
+  }
+  const safetyColor = safetyRating ? getSeverityColor(safetyRating, chalk3) : getScoreColor(score);
+  if (safetyRating) {
+    console.log(
+      `AI Change Safety: ${safetyColor(`${getSafetyIcon(safetyRating)} ${safetyRating.toUpperCase()}`)}`
+    );
+  }
+  console.log(
+    `Score:            ${getScoreColor(score)(score + "/100")} (${rating.toUpperCase()})`
+  );
+  if (stats.length > 0) {
+    const statsStr = stats.map((s) => `${s.label}: ${chalk3.cyan(s.value)}`).join("   ");
+    console.log(statsStr);
+  }
+  console.log(`Analysis Time:    ${chalk3.gray(elapsedTime + "s")}
+`);
+  console.log(chalk3.bold("\u{1F4D0} Dimension Scores\n"));
+  for (const dim of dimensions) {
+    const color = getScoreColor(dim.value);
+    console.log(
+      `  ${dim.name.padEnd(22)} ${color(getScoreBar(dim.value))} ${dim.value}/100`
+    );
+  }
+  if (issues.length > 0) {
+    console.log(chalk3.bold("\n\u26A0\uFE0F  Issues\n"));
+    for (const issue of issues) {
+      const sev = getSeverityColor(issue.severity, chalk3);
+      console.log(`${sev(issue.severity.toUpperCase())}  ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(
+          `         ${chalk3.dim("\u2192")} ${chalk3.italic(issue.suggestion)}`
+        );
+      }
+      console.log();
+    }
+  } else {
+    console.log(chalk3.green(`
+${noIssuesMessage}
+`));
+  }
+  if (recommendations.length > 0) {
+    console.log(chalk3.bold("\u{1F4A1} Recommendations\n"));
+    recommendations.forEach((rec, i) => {
+      console.log(`${i + 1}. ${rec}`);
+    });
+  }
+  console.log();
+}
+
+// src/utils/code-extractor.ts
+function inferPatternType(keyword, name) {
+  const n = name.toLowerCase();
+  if (keyword === "handler" || n.includes("handler") || n.includes("controller") || n.startsWith("app.")) {
+    return "api-handler";
+  }
+  if (n.includes("validate") || n.includes("schema")) return "validator";
+  if (n.includes("util") || n.includes("helper")) return "utility";
+  if (keyword === "class") return "class-method";
+  if (n.match(/^[A-Z]/)) return "component";
+  if (keyword === "function" || keyword === "def") return "function";
+  return "unknown";
+}
+function extractCodeBlocks(file, content) {
+  const isPython = file.toLowerCase().endsWith(".py");
+  if (isPython) {
+    return extractBlocksPython(file, content);
+  }
+  const blocks = [];
+  const lines = content.split("\n");
+  const blockRegex = /^\s*(?:export\s+)?(?:async\s+)?(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|readonly\s+|virtual\s+|abstract\s+|override\s+)*(function|class|interface|type|enum|record|struct|void|func|[a-zA-Z0-9_<>[]]+)\s+([a-zA-Z0-9_]+)(?:\s*\(|(?:\s+extends|\s+implements|\s+where)?\s*\{)|^\s*(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*[a-zA-Z0-9_.]+\.object\(|^\s*(app\.(?:get|post|put|delete|patch|use))\(/gm;
+  let match;
+  while ((match = blockRegex.exec(content)) !== null) {
+    const startLine = content.substring(0, match.index).split("\n").length;
+    let type;
+    let name;
+    if (match[1]) {
+      type = match[1];
+      name = match[2];
+    } else if (match[3]) {
+      type = "const";
+      name = match[3];
+    } else {
+      type = "handler";
+      name = match[4];
+    }
+    let endLine = -1;
+    let openBraces = 0;
+    let foundStart = false;
+    const lineEnd = content.indexOf("\n", match.index);
+    const lineText = content.substring(
+      match.index,
+      lineEnd === -1 ? content.length : lineEnd
+    );
+    if (lineText.includes("{") && lineText.includes("}")) {
+      endLine = startLine;
+    } else {
+      for (let i = match.index; i < content.length; i++) {
+        if (content[i] === "{") {
+          openBraces++;
+          foundStart = true;
+        } else if (content[i] === "}") {
+          openBraces--;
+        }
+        if (foundStart && openBraces === 0) {
+          endLine = content.substring(0, i + 1).split("\n").length;
+          break;
+        }
+      }
+    }
+    if (endLine === -1) {
+      endLine = startLine;
+    }
+    endLine = Math.max(startLine, endLine);
+    const blockCode = lines.slice(startLine - 1, endLine).join("\n");
+    const tokens = estimateTokens(blockCode);
+    blocks.push({
+      file,
+      startLine,
+      endLine,
+      code: blockCode,
+      tokens,
+      patternType: inferPatternType(type, name)
+    });
+  }
+  return blocks;
+}
+function extractBlocksPython(file, content) {
+  const blocks = [];
+  const lines = content.split("\n");
+  const blockRegex = /^\s*(?:async\s+)?(def|class)\s+([a-zA-Z0-9_]+)/gm;
+  let match;
+  while ((match = blockRegex.exec(content)) !== null) {
+    const startLinePos = content.substring(0, match.index).split("\n").length;
+    const startLineIdx = startLinePos - 1;
+    const initialIndent = lines[startLineIdx].search(/\S/);
+    let endLineIdx = startLineIdx;
+    for (let i = startLineIdx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().length === 0) {
+        endLineIdx = i;
+        continue;
+      }
+      const currentIndent = line.search(/\S/);
+      if (currentIndent <= initialIndent) {
+        break;
+      }
+      endLineIdx = i;
+    }
+    while (endLineIdx > startLineIdx && lines[endLineIdx].trim().length === 0) {
+      endLineIdx--;
+    }
+    const blockCode = lines.slice(startLineIdx, endLineIdx + 1).join("\n");
+    const tokens = estimateTokens(blockCode);
+    blocks.push({
+      file,
+      startLine: startLinePos,
+      endLine: endLineIdx + 1,
+      code: blockCode,
+      tokens,
+      patternType: inferPatternType(match[1], match[2])
+    });
+  }
+  return blocks;
+}
+
 // src/business/pricing-models.ts
 var MODEL_PRICING_PRESETS = {
   "gpt-5.4-mini": {
@@ -3010,20 +1842,52 @@ var DEFAULT_COST_CONFIG = {
   developerCount: 5,
   daysPerMonth: 30
 };
-function calculateMonthlyCost(tokenWaste, config = {}) {
-  const multiplier = tokenWaste > 5e4 ? 5 : tokenWaste > 1e4 ? 3.5 : 2.5;
+function calculateMonthlyCost(tokenWaste, config = {}, options) {
+  const baseMultiplier = tokenWaste > 5e4 ? 5 : tokenWaste > 1e4 ? 3.5 : 2.5;
+  const contextMultiplier = options?.avgContextBudget ? options.avgContextBudget / Math.max(1, tokenWaste) : baseMultiplier;
+  const fragRatio = options?.fragmentationScore ?? 0.3;
+  const dupRatio = 1 - fragRatio;
   const budget = calculateTokenBudget({
-    totalContextTokens: tokenWaste * multiplier,
+    totalContextTokens: tokenWaste * contextMultiplier,
     wastedTokens: {
-      duplication: tokenWaste * 0.7,
-      fragmentation: tokenWaste * 0.3,
+      duplication: tokenWaste * dupRatio * (options?.potentialSavings ? 1.2 : 1),
+      fragmentation: tokenWaste * fragRatio,
       chattiness: 0.1 * tokenWaste
-      // Added baseline chattiness
     }
   });
-  const preset = getModelPreset("gpt-5.4-mini");
+  const preset = getModelPreset("claude-3.5-sonnet");
   return estimateCostFromBudget(budget, preset, config);
 }
+function calculateDetailedTokenROI(params) {
+  const {
+    totalTokens,
+    avgContextBudget,
+    potentialSavings,
+    fragmentationScore,
+    developerCount,
+    queriesPerDevPerDay = 60
+  } = params;
+  const budget = calculateTokenBudget({
+    totalContextTokens: avgContextBudget,
+    wastedTokens: {
+      duplication: potentialSavings * 0.8,
+      // 80% of potential savings are duplication-based
+      fragmentation: totalTokens * fragmentationScore * 0.5,
+      // fragmentation impact
+      chattiness: totalTokens * 0.1
+    }
+  });
+  const model = getModelPreset("claude-3.5-sonnet");
+  const cost = estimateCostFromBudget(budget, model, {
+    developerCount,
+    queriesPerDevPerDay
+  });
+  return {
+    monthlySavings: Math.round(cost.total),
+    contextTaxPerDev: Math.round(cost.total / (developerCount || 1) * 100) / 100,
+    efficiencyGain: Math.round(budget.efficiencyRatio * 100) / 100
+  };
+}
 function calculateTokenBudget(params) {
   const { totalContextTokens, wastedTokens } = params;
   const estimatedResponseTokens = params.estimatedResponseTokens ?? totalContextTokens * 0.2;
@@ -3579,45 +2443,175 @@ function calculatePatternEntropy(files) {
     recommendations
   };
 }
-function calculateConceptCohesion(params) {
-  const { exports } = params;
-  if (exports.length === 0) {
-    return {
-      score: 1,
-      rating: "excellent",
-      analysis: {
-        uniqueDomains: 0,
-        domainConcentration: 0,
-        exportPurposeClarity: 1
-      }
-    };
+function calculateConceptCohesion(params) {
+  const { exports } = params;
+  if (exports.length === 0) {
+    return {
+      score: 1,
+      rating: "excellent",
+      analysis: {
+        uniqueDomains: 0,
+        domainConcentration: 0,
+        exportPurposeClarity: 1
+      }
+    };
+  }
+  const allDomains = [];
+  for (const exp of exports) {
+    if (exp.inferredDomain) allDomains.push(exp.inferredDomain);
+    if (exp.domains) allDomains.push(...exp.domains);
+  }
+  const uniqueDomains = new Set(allDomains);
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const d of allDomains)
+    domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+  const maxCount = Math.max(...Array.from(domainCounts.values()), 1);
+  const domainConcentration = maxCount / allDomains.length;
+  const exportPurposeClarity = 1 - (uniqueDomains.size - 1) / Math.max(1, exports.length);
+  const score = domainConcentration * 0.5 + exportPurposeClarity * 0.5;
+  let rating;
+  if (score > 0.8) rating = "excellent";
+  else if (score > 0.6) rating = "good";
+  else if (score > 0.4) rating = "moderate";
+  else rating = "poor";
+  return {
+    score: Math.round(score * 100) / 100,
+    rating,
+    analysis: {
+      uniqueDomains: uniqueDomains.size,
+      domainConcentration: Math.round(domainConcentration * 100) / 100,
+      exportPurposeClarity: Math.round(exportPurposeClarity * 100) / 100
+    }
+  };
+}
+
+// src/future-proof-metrics.ts
+function calculateFutureProofScore(params) {
+  const loadScore = 100 - params.cognitiveLoad.score;
+  const entropyScore = 100 - params.patternEntropy.entropy * 100;
+  const cohesionScore = params.conceptCohesion.score * 100;
+  const overall = Math.round(
+    loadScore * 0.4 + entropyScore * 0.3 + cohesionScore * 0.3
+  );
+  const factors = [
+    {
+      name: "Cognitive Load",
+      impact: Math.round(loadScore - 50),
+      description: params.cognitiveLoad.rating
+    },
+    {
+      name: "Pattern Entropy",
+      impact: Math.round(entropyScore - 50),
+      description: params.patternEntropy.rating
+    },
+    {
+      name: "Concept Cohesion",
+      impact: Math.round(cohesionScore - 50),
+      description: params.conceptCohesion.rating
+    }
+  ];
+  const recommendations = collectBaseFutureProofRecommendations({
+    patternEntropy: params.patternEntropy,
+    conceptCohesion: params.conceptCohesion
+  });
+  const semanticDistanceAvg = params.semanticDistances?.length ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
+  return {
+    toolName: "future-proof",
+    score: overall,
+    rawMetrics: {
+      cognitiveLoadScore: params.cognitiveLoad.score,
+      entropyScore: params.patternEntropy.entropy,
+      cohesionScore: params.conceptCohesion.score,
+      semanticDistanceAvg
+    },
+    factors,
+    recommendations
+  };
+}
+function calculateExtendedFutureProofScore(params) {
+  const loadScore = 100 - params.cognitiveLoad.score;
+  const entropyScore = 100 - params.patternEntropy.entropy * 100;
+  const cohesionScore = params.conceptCohesion.score * 100;
+  const aiSignalClarityScore = 100 - params.aiSignalClarity.score;
+  const groundingScore = params.agentGrounding.score;
+  const testabilityScore = params.testability.score;
+  const docDriftScore = params.docDrift ? 100 - params.docDrift.score : 100;
+  const depsHealthScore = params.dependencyHealth?.score ?? 100;
+  let totalWeight = 0.8;
+  let overall = loadScore * 0.15 + entropyScore * 0.1 + cohesionScore * 0.1 + aiSignalClarityScore * 0.15 + groundingScore * 0.15 + testabilityScore * 0.15;
+  if (params.docDrift) {
+    overall += docDriftScore * 0.1;
+    totalWeight += 0.1;
   }
-  const allDomains = [];
-  for (const exp of exports) {
-    if (exp.inferredDomain) allDomains.push(exp.inferredDomain);
-    if (exp.domains) allDomains.push(...exp.domains);
+  if (params.dependencyHealth) {
+    overall += depsHealthScore * 0.1;
+    totalWeight += 0.1;
   }
-  const uniqueDomains = new Set(allDomains);
-  const domainCounts = /* @__PURE__ */ new Map();
-  for (const d of allDomains)
-    domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
-  const maxCount = Math.max(...Array.from(domainCounts.values()), 1);
-  const domainConcentration = maxCount / allDomains.length;
-  const exportPurposeClarity = 1 - (uniqueDomains.size - 1) / Math.max(1, exports.length);
-  const score = domainConcentration * 0.5 + exportPurposeClarity * 0.5;
-  let rating;
-  if (score > 0.8) rating = "excellent";
-  else if (score > 0.6) rating = "good";
-  else if (score > 0.4) rating = "moderate";
-  else rating = "poor";
-  return {
-    score: Math.round(score * 100) / 100,
-    rating,
-    analysis: {
-      uniqueDomains: uniqueDomains.size,
-      domainConcentration: Math.round(domainConcentration * 100) / 100,
-      exportPurposeClarity: Math.round(exportPurposeClarity * 100) / 100
+  overall = Math.round(overall / totalWeight);
+  const factors = [
+    {
+      name: "Cognitive Load",
+      impact: Math.round(loadScore - 50),
+      description: params.cognitiveLoad.rating
+    },
+    {
+      name: "Pattern Entropy",
+      impact: Math.round(entropyScore - 50),
+      description: params.patternEntropy.rating
+    },
+    {
+      name: "Concept Cohesion",
+      impact: Math.round(cohesionScore - 50),
+      description: params.conceptCohesion.rating
+    },
+    {
+      name: "AI Signal Clarity",
+      impact: Math.round(aiSignalClarityScore - 50),
+      description: `${params.aiSignalClarity.rating} risk`
+    },
+    {
+      name: "Agent Grounding",
+      impact: Math.round(groundingScore - 50),
+      description: params.agentGrounding.rating
+    },
+    {
+      name: "Testability",
+      impact: Math.round(testabilityScore - 50),
+      description: params.testability.rating
     }
+  ];
+  if (params.docDrift) {
+    factors.push({
+      name: "Documentation Drift",
+      impact: Math.round(docDriftScore - 50),
+      description: params.docDrift.rating
+    });
+  }
+  if (params.dependencyHealth) {
+    factors.push({
+      name: "Dependency Health",
+      impact: Math.round(depsHealthScore - 50),
+      description: params.dependencyHealth.rating
+    });
+  }
+  const recommendations = collectFutureProofRecommendations(params);
+  const semanticDistanceAvg = params.semanticDistances?.length ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
+  return {
+    toolName: "future-proof",
+    score: overall,
+    rawMetrics: {
+      cognitiveLoadScore: params.cognitiveLoad.score,
+      entropyScore: params.patternEntropy.entropy,
+      cohesionScore: params.conceptCohesion.score,
+      aiSignalClarityScore: params.aiSignalClarity.score,
+      agentGroundingScore: params.agentGrounding.score,
+      testabilityScore: params.testability.score,
+      docDriftScore: params.docDrift?.score,
+      dependencyHealthScore: params.dependencyHealth?.score,
+      semanticDistanceAvg
+    },
+    factors,
+    recommendations
   };
 }
 
@@ -4173,145 +3167,15 @@ function calculateChangeAmplification(params) {
   };
 }
 
-// src/future-proof-metrics.ts
-function calculateFutureProofScore(params) {
-  const loadScore = 100 - params.cognitiveLoad.score;
-  const entropyScore = 100 - params.patternEntropy.entropy * 100;
-  const cohesionScore = params.conceptCohesion.score * 100;
-  const overall = Math.round(
-    loadScore * 0.4 + entropyScore * 0.3 + cohesionScore * 0.3
-  );
-  const factors = [
-    {
-      name: "Cognitive Load",
-      impact: Math.round(loadScore - 50),
-      description: params.cognitiveLoad.rating
-    },
-    {
-      name: "Pattern Entropy",
-      impact: Math.round(entropyScore - 50),
-      description: params.patternEntropy.rating
-    },
-    {
-      name: "Concept Cohesion",
-      impact: Math.round(cohesionScore - 50),
-      description: params.conceptCohesion.rating
-    }
-  ];
-  const recommendations = collectBaseFutureProofRecommendations({
-    patternEntropy: params.patternEntropy,
-    conceptCohesion: params.conceptCohesion
-  });
-  const semanticDistanceAvg = params.semanticDistances?.length ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
-  return {
-    toolName: "future-proof",
-    score: overall,
-    rawMetrics: {
-      cognitiveLoadScore: params.cognitiveLoad.score,
-      entropyScore: params.patternEntropy.entropy,
-      cohesionScore: params.conceptCohesion.score,
-      semanticDistanceAvg
-    },
-    factors,
-    recommendations
-  };
-}
-function calculateExtendedFutureProofScore(params) {
-  const loadScore = 100 - params.cognitiveLoad.score;
-  const entropyScore = 100 - params.patternEntropy.entropy * 100;
-  const cohesionScore = params.conceptCohesion.score * 100;
-  const aiSignalClarityScore = 100 - params.aiSignalClarity.score;
-  const groundingScore = params.agentGrounding.score;
-  const testabilityScore = params.testability.score;
-  const docDriftScore = params.docDrift ? 100 - params.docDrift.score : 100;
-  const depsHealthScore = params.dependencyHealth?.score ?? 100;
-  let totalWeight = 0.8;
-  let overall = loadScore * 0.15 + entropyScore * 0.1 + cohesionScore * 0.1 + aiSignalClarityScore * 0.15 + groundingScore * 0.15 + testabilityScore * 0.15;
-  if (params.docDrift) {
-    overall += docDriftScore * 0.1;
-    totalWeight += 0.1;
-  }
-  if (params.dependencyHealth) {
-    overall += depsHealthScore * 0.1;
-    totalWeight += 0.1;
-  }
-  overall = Math.round(overall / totalWeight);
-  const factors = [
-    {
-      name: "Cognitive Load",
-      impact: Math.round(loadScore - 50),
-      description: params.cognitiveLoad.rating
-    },
-    {
-      name: "Pattern Entropy",
-      impact: Math.round(entropyScore - 50),
-      description: params.patternEntropy.rating
-    },
-    {
-      name: "Concept Cohesion",
-      impact: Math.round(cohesionScore - 50),
-      description: params.conceptCohesion.rating
-    },
-    {
-      name: "AI Signal Clarity",
-      impact: Math.round(aiSignalClarityScore - 50),
-      description: `${params.aiSignalClarity.rating} risk`
-    },
-    {
-      name: "Agent Grounding",
-      impact: Math.round(groundingScore - 50),
-      description: params.agentGrounding.rating
-    },
-    {
-      name: "Testability",
-      impact: Math.round(testabilityScore - 50),
-      description: params.testability.rating
-    }
-  ];
-  if (params.docDrift) {
-    factors.push({
-      name: "Documentation Drift",
-      impact: Math.round(docDriftScore - 50),
-      description: params.docDrift.rating
-    });
-  }
-  if (params.dependencyHealth) {
-    factors.push({
-      name: "Dependency Health",
-      impact: Math.round(depsHealthScore - 50),
-      description: params.dependencyHealth.rating
-    });
-  }
-  const recommendations = collectFutureProofRecommendations(params);
-  const semanticDistanceAvg = params.semanticDistances?.length ? params.semanticDistances.reduce((s, d) => s + d.distance, 0) / params.semanticDistances.length : 0;
-  return {
-    toolName: "future-proof",
-    score: overall,
-    rawMetrics: {
-      cognitiveLoadScore: params.cognitiveLoad.score,
-      entropyScore: params.patternEntropy.entropy,
-      cohesionScore: params.conceptCohesion.score,
-      aiSignalClarityScore: params.aiSignalClarity.score,
-      agentGroundingScore: params.agentGrounding.score,
-      testabilityScore: params.testability.score,
-      docDriftScore: params.docDrift?.score,
-      dependencyHealthScore: params.dependencyHealth?.score,
-      semanticDistanceAvg
-    },
-    factors,
-    recommendations
-  };
-}
-
 // src/utils/history.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4, dirname as dirname4 } from "path";
 function getHistoryPath(rootDir) {
-  return join5(rootDir, ".aiready", "history.json");
+  return join4(rootDir, ".aiready", "history.json");
 }
 function loadScoreHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (!existsSync5(historyPath)) {
+  if (!existsSync4(historyPath)) {
     return [];
   }
   try {
@@ -4324,8 +3188,8 @@ function loadScoreHistory(rootDir) {
 }
 function saveScoreEntry(rootDir, entry) {
   const historyPath = getHistoryPath(rootDir);
-  const historyDir = dirname5(historyPath);
-  if (!existsSync5(historyDir)) {
+  const historyDir = dirname4(historyPath);
+  if (!existsSync4(historyDir)) {
     mkdirSync2(historyDir, { recursive: true });
   }
   const history = loadScoreHistory(rootDir);
@@ -4372,7 +3236,7 @@ function exportHistory(rootDir, format = "json") {
 }
 function clearHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
-  if (existsSync5(historyPath)) {
+  if (existsSync4(historyPath)) {
     writeFileSync2(historyPath, JSON.stringify([]));
   }
 }
@@ -4539,8 +3403,10 @@ export {
   TypeScriptParser,
   UnifiedReportSchema,
   VAGUE_FILE_NAMES,
+  buildFactorsFromDimensions,
   buildSimpleProviderScore,
   buildSpokeOutput,
+  buildStandardToolScore,
   calculateAgentGrounding,
   calculateAiSignalClarity,
   calculateBusinessROI,
@@ -4550,9 +3416,11 @@ export {
   calculateConceptCohesion,
   calculateDebtInterest,
   calculateDependencyHealth,
+  calculateDetailedTokenROI,
   calculateDocDrift,
   calculateExtendedFutureProofScore,
   calculateFutureProofScore,
+  calculateHeuristicConfidence,
   calculateImportSimilarity,
   calculateKnowledgeConcentration,
   calculateMonthlyCost,
@@ -4560,25 +3428,39 @@ export {
   calculatePatternEntropy,
   calculateProductivityImpact,
   calculateSemanticDistance,
+  calculateStringSimilarity,
   calculateTechnicalValueChain,
   calculateTestabilityIndex,
   calculateTokenBudget,
   clearHistory,
   createProvider,
+  createStandardProgressCallback,
+  displayStandardConsoleReport,
   emitAnnotation,
   emitIssuesAsAnnotations,
   emitProgress,
   estimateCostFromBudget,
   estimateTokens,
   exportHistory,
+  extractCodeBlocks,
   findLatestReport,
   findLatestScanReport,
   formatAcceptanceRate,
   formatCost,
   formatHours,
   formatScore,
+  formatStandardCliResult,
+  formatStandardReport,
   formatToolScore,
+  generateCompleteReport,
   generateHTML,
+  generateIssueSummary,
+  generateReportFooter,
+  generateReportHead,
+  generateReportHero,
+  generateScoreCard,
+  generateStatCards,
+  generateTable,
   generateValueChain,
   getElapsedTime,
   getFileCommitTimestamps,
@@ -4587,26 +3469,36 @@ export {
   getLineRangeLastModifiedCached,
   getModelPreset,
   getParser,
+  getPriorityIcon,
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingEmoji,
+  getRatingLabel,
+  getRatingMetadata,
   getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
   getRepoMetadata,
+  getReportTimestamp,
   getSafetyIcon,
   getScoreBar,
+  getScoreColor,
   getSeverityBadge,
   getSeverityColor,
   getSeverityEnum,
   getSeverityLevel,
   getSeverityValue,
   getSupportedLanguages,
+  getTerminalDivider,
+  getToolEmoji,
   getToolWeight,
   getWasmPath,
   groupIssuesByFile,
   handleCLIError,
   handleJSONOutput,
+  handleStandardJSONOutput,
+  inferPatternType,
   initTreeSitter,
   initializeParsers,
   isFileSupported,
@@ -4623,13 +3515,18 @@ export {
   parseFileExports,
   parseWeightString,
   predictAcceptanceRate,
+  prepareActionConfig,
+  printTerminalHeader,
   readFileContent,
+  resolveOutputFormat,
   resolveOutputPath,
+  runStandardCliAction,
   saveScoreEntry,
   scanEntries,
   scanFiles,
   setupParser,
   severityToAnnotationLevel,
   validateSpokeOutput,
-  validateWithSchema
+  validateWithSchema,
+  wrapInCard
 };