@aiready/core 0.23.6 → 0.23.8

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import {
+  AIReadyConfigSchema,
   AnalysisResultSchema,
   AnalysisStatus,
   AnalysisStatusSchema,
@@ -49,53 +50,102 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-Q55AMEFV.mjs";
+} from "./chunk-TJXR2CHZ.mjs";
+
+// src/utils/normalization.ts
+function normalizeIssue(raw) {
+  return {
+    type: raw.type ?? "pattern-inconsistency" /* PatternInconsistency */,
+    severity: raw.severity ?? raw.severityLevel ?? "info" /* Info */,
+    message: raw.message ?? "Unknown issue",
+    location: raw.location ?? {
+      file: raw.fileName ?? raw.file ?? raw.filePath ?? "unknown",
+      line: raw.line ?? 1,
+      column: raw.column
+    },
+    suggestion: raw.suggestion
+  };
+}
+function normalizeMetrics(raw) {
+  return {
+    tokenCost: raw.tokenCost ?? 0,
+    complexityScore: raw.complexityScore ?? 0,
+    consistencyScore: raw.consistencyScore,
+    docFreshnessScore: raw.docFreshnessScore,
+    aiSignalClarityScore: raw.aiSignalClarityScore,
+    agentGroundingScore: raw.agentGroundingScore,
+    testabilityScore: raw.testabilityScore,
+    docDriftScore: raw.docDriftScore,
+    dependencyHealthScore: raw.dependencyHealthScore,
+    modelContextTier: raw.modelContextTier,
+    estimatedMonthlyCost: raw.estimatedMonthlyCost,
+    estimatedDeveloperHours: raw.estimatedDeveloperHours,
+    comprehensionDifficultyIndex: raw.comprehensionDifficultyIndex,
+    totalSymbols: raw.totalSymbols,
+    totalExports: raw.totalExports
+  };
+}
+function normalizeAnalysisResult(raw) {
+  const fileName = raw.fileName ?? raw.file ?? raw.filePath ?? "unknown";
+  const rawIssues = Array.isArray(raw.issues) ? raw.issues : [];
+  return {
+    fileName,
+    issues: rawIssues.map((issue) => {
+      if (typeof issue === "string") {
+        return {
+          type: "pattern-inconsistency" /* PatternInconsistency */,
+          // Default fallback
+          severity: raw.severity ?? "info" /* Info */,
+          message: issue,
+          location: { file: fileName, line: 1 }
+        };
+      }
+      return normalizeIssue({
+        ...issue,
+        fileName: issue.fileName ?? fileName,
+        severity: issue.severity ?? raw.severity
+      });
+    }),
+    metrics: normalizeMetrics(raw.metrics ?? {})
+  };
+}
+function normalizeSpokeOutput(raw, toolName) {
+  const rawResults = Array.isArray(raw.results) ? raw.results : [];
+  return {
+    results: rawResults.map(normalizeAnalysisResult),
+    summary: raw.summary ?? {
+      totalFiles: rawResults.length,
+      totalIssues: 0,
+      criticalIssues: 0,
+      majorIssues: 0
+    },
+    metadata: {
+      toolName: raw.metadata?.toolName ?? toolName,
+      version: raw.metadata?.version,
+      timestamp: raw.metadata?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      config: raw.metadata?.config
+    }
+  };
+}
 
 // src/types/contract.ts
 function validateSpokeOutput(toolName, output) {
-  const errors = [];
   if (!output) {
     return { valid: false, errors: ["Output is null or undefined"] };
   }
-  if (!Array.isArray(output.results)) {
-    errors.push(`${toolName}: 'results' must be an array`);
-  } else {
-    output.results.forEach((res, idx) => {
-      const fileName = res.fileName || res.file || res.filePath;
-      if (!fileName)
-        errors.push(
-          `${toolName}: results[${idx}] missing 'fileName', 'file' or 'filePath'`
-        );
-      const issues = res.issues;
-      if (!Array.isArray(issues)) {
-        errors.push(`${toolName}: results[${idx}] 'issues' must be an array`);
-      } else if (issues.length > 0) {
-        issues.forEach((issue, iidx) => {
-          if (typeof issue === "string") return;
-          if (!issue.type && !res.file)
-            errors.push(
-              `${toolName}: results[${idx}].issues[${iidx}] missing 'type'`
-            );
-          if (!issue.severity && !res.severity)
-            errors.push(
-              `${toolName}: results[${idx}].issues[${iidx}] missing 'severity'`
-            );
-          const severity = issue.severity || res.severity;
-          if (severity && !["critical", "major", "minor", "info"].includes(severity)) {
-            errors.push(
-              `${toolName}: results[${idx}].issues[${iidx}] has invalid severity: ${severity}`
-            );
-          }
-        });
-      }
-    });
-  }
   if (!output.summary) {
-    errors.push(`${toolName}: missing 'summary'`);
+    return { valid: false, errors: [`${toolName}: missing 'summary'`] };
+  }
+  const normalized = normalizeSpokeOutput(output, toolName);
+  const result = SpokeOutputSchema.safeParse(normalized);
+  if (result.success) {
+    return { valid: true, errors: [] };
   }
   return {
-    valid: errors.length === 0,
-    errors
+    valid: false,
+    errors: result.error.issues.map(
+      (e) => `${toolName}: ${e.path.join(".")}: ${e.message}`
+    )
   };
 }
 function validateWithSchema(schema, data) {
@@ -464,7 +514,7 @@ function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()
       if (statSync(workingDir).isFile()) {
         baseDir = dirname2(workingDir);
       }
-    } catch (e) {
+    } catch {
     }
     const aireadyDir = join2(baseDir, ".aiready");
     outputPath = join2(aireadyDir, defaultFilename);
@@ -636,8 +686,8 @@ function findLatestScanReport(scanReportsDir, reportFilePrefix) {
       return idB - idA;
     });
     return join2(scanReportsDir, reportFiles[0]);
-  } catch (e) {
-    console.error("Error while finding latest scan report:", e);
+  } catch {
+    console.error("Error while finding latest scan report");
     return null;
   }
 }
@@ -702,7 +752,19 @@ function createProvider(config) {
   };
 }
 
-// src/utils/ast-parser.ts
+// src/utils/similarity-utils.ts
+function calculateImportSimilarity(export1, export2) {
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1;
+  }
+  const set1 = new Set(export1.imports);
+  const set2 = new Set(export2.imports);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+
+// src/utils/dependency-analyzer.ts
 import { parse as parse2 } from "@typescript-eslint/typescript-estree";
 
 // src/parsers/typescript-parser.ts
@@ -713,148 +775,67 @@ var TypeScriptParser = class {
     this.extensions = [".ts", ".tsx", ".js", ".jsx"];
   }
   async initialize() {
-    return Promise.resolve();
   }
-  async getAST(code, filePath) {
-    return parse(code, {
-      loc: true,
-      range: true,
-      jsx: filePath.match(/\.[jt]sx$/i) !== null,
-      filePath,
-      sourceType: "module",
-      ecmaVersion: "latest",
-      comment: true
-    });
+  canHandle(filePath) {
+    return this.extensions.some((ext) => filePath.endsWith(ext));
   }
-  analyzeMetadata(node, code) {
-    const metadata = {
-      isPure: true,
-      hasSideEffects: false
-    };
-    const start = node.range?.[0] ?? 0;
-    const preceding = code.slice(Math.max(0, start - 1e3), start);
-    const jsdocMatches = Array.from(
-      preceding.matchAll(/\/\*\*([\s\S]*?)\*\//g)
-    );
-    if (jsdocMatches.length > 0) {
-      const lastMatch = jsdocMatches[jsdocMatches.length - 1];
-      const matchEndIndex = (lastMatch.index || 0) + lastMatch[0].length;
-      const between = preceding.slice(matchEndIndex);
-      if (/^\s*$/.test(between)) {
-        const precedingStartOffset = Math.max(0, start - 1e3);
-        const absoluteStartOffset = precedingStartOffset + (lastMatch.index || 0);
-        const absoluteEndOffset = precedingStartOffset + matchEndIndex;
-        const codeBeforeStart = code.slice(0, absoluteStartOffset);
-        const startLines = codeBeforeStart.split("\n");
-        const startLine = startLines.length;
-        const startColumn = startLines[startLines.length - 1].length;
-        const codeBeforeEnd = code.slice(0, absoluteEndOffset);
-        const endLines = codeBeforeEnd.split("\n");
-        const endLine = endLines.length;
-        const endColumn = endLines[endLines.length - 1].length;
-        metadata.documentation = {
-          content: lastMatch[1].replace(/^\s*\*+/gm, "").trim(),
-          type: "jsdoc",
-          loc: {
-            start: { line: startLine, column: startColumn },
-            end: { line: endLine, column: endColumn }
-          }
-        };
-      }
-    }
-    const walk = (n) => {
-      if (!n) return;
-      if (n.type === "AssignmentExpression") {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      if (n.type === "UpdateExpression") {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      if (n.type === "CallExpression" && n.callee.type === "MemberExpression" && n.callee.object.type === "Identifier") {
-        const objName = n.callee.object.name;
-        if (["console", "process", "fs", "window", "document"].includes(objName)) {
-          metadata.isPure = false;
-          metadata.hasSideEffects = true;
-        }
-      }
-      if (n.type === "ThrowStatement") {
-        metadata.isPure = false;
-        metadata.hasSideEffects = true;
-      }
-      for (const key of Object.keys(n)) {
-        if (key === "parent") continue;
-        const child = n[key];
-        if (child && typeof child === "object") {
-          if (Array.isArray(child)) {
-            child.forEach((c) => c?.type && walk(c));
-          } else if (child.type) {
-            walk(child);
-          }
-        }
-      }
-    };
-    let nodeToAnalyze = node;
-    if (node.type === "ExportNamedDeclaration" && node.declaration) {
-      nodeToAnalyze = node.declaration;
-    } else if (node.type === "ExportDefaultDeclaration" && node.declaration) {
-      if (node.declaration.type !== "TSInterfaceDeclaration" && node.declaration.type !== "TSTypeAliasDeclaration") {
-        nodeToAnalyze = node.declaration;
-      }
-    }
-    if (nodeToAnalyze.type === "FunctionDeclaration" || nodeToAnalyze.type === "FunctionExpression" || nodeToAnalyze.type === "ArrowFunctionExpression") {
-      if (nodeToAnalyze.body) walk(nodeToAnalyze.body);
-    } else if (nodeToAnalyze.type === "ClassDeclaration" || nodeToAnalyze.type === "ClassExpression") {
-      walk(nodeToAnalyze.body);
+  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
+      });
     }
-    return metadata;
   }
   parse(code, filePath) {
     try {
-      const isJavaScript = filePath.match(/\.jsx?$/i);
       const ast = parse(code, {
+        filePath,
         loc: true,
         range: true,
-        jsx: filePath.match(/\.[jt]sx$/i) !== null,
-        filePath,
-        sourceType: "module",
-        ecmaVersion: "latest",
-        comment: true
+        tokens: true,
+        comment: true,
+        jsx: filePath.endsWith("x")
       });
       const imports = this.extractImports(ast);
-      const exports = this.extractExports(ast, imports, code);
+      const exports = this.extractExports(ast, code);
       return {
         exports,
         imports,
-        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
-        warnings: []
+        language: this.language
       };
     } catch (error) {
-      const err = error;
-      throw new ParseError(
-        `Failed to parse ${filePath}: ${err.message}`,
-        filePath
-      );
+      throw new ParseError(error.message, filePath, {
+        line: error.lineNumber || 1,
+        column: error.column || 0
+      });
     }
   }
   getNamingConventions() {
     return {
-      // camelCase for variables and functions
       variablePattern: /^[a-z][a-zA-Z0-9]*$/,
       functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-      // PascalCase for classes, types and interfaces
       classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-      typePattern: /^[A-Z][a-zA-Z0-9]*$/,
-      interfacePattern: /^[A-Z][a-zA-Z0-9]*$/,
-      // UPPER_CASE for constants
       constantPattern: /^[A-Z][A-Z0-9_]*$/,
-      // Common exceptions (React hooks, etc.)
-      exceptions: ["__filename", "__dirname", "__esModule"]
+      typePattern: /^[A-Z][a-zA-Z0-9]*$/,
+      interfacePattern: /^I?[A-Z][a-zA-Z0-9]*$/
     };
   }
-  canHandle(filePath) {
-    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
+  analyzeMetadata(node, code) {
+    if (!code) return {};
+    return {
+      isPure: this.isLikelyPure(node),
+      hasSideEffects: !this.isLikelyPure(node)
+    };
   }
   extractImports(ast) {
     const imports = [];
@@ -892,168 +873,165 @@ var TypeScriptParser = class {
     }
     return imports;
   }
-  extractExports(ast, imports, code) {
+  extractExports(ast, code) {
     const exports = [];
-    const importedNames = new Set(
-      imports.flatMap(
-        (imp) => imp.specifiers.filter((s) => s !== "*" && s !== "default")
-      )
-    );
     for (const node of ast.body) {
-      if (node.type === "ExportNamedDeclaration" && node.declaration) {
-        const extracted = this.extractFromDeclaration(
-          node.declaration,
-          importedNames,
-          code,
-          node
-          // Pass the ExportNamedDeclaration as parent for metadata
-        );
-        exports.push(...extracted);
-      } else if (node.type === "ExportDefaultDeclaration") {
-        const metadata = this.analyzeMetadata(node, code);
-        let name = "default";
-        let type = "default";
-        if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-          name = node.declaration.id.name;
-          type = "function";
-        } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
-          name = node.declaration.id.name;
-          type = "class";
+      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
+                  )
+                );
+              }
+            }
+          }
         }
-        exports.push({
-          name,
-          type,
-          loc: node.loc ? {
-            start: {
-              line: node.loc.start.line,
-              column: node.loc.start.column
-            },
-            end: { line: node.loc.end.line, column: node.loc.end.column }
-          } : void 0,
-          ...metadata
-        });
+      } else if (node.type === "ExportDefaultDeclaration") {
+        exports.push(this.createExport("default", "default", node, code));
       }
     }
     return exports;
   }
-  extractFromDeclaration(declaration, importedNames, code, parentNode) {
-    const exports = [];
-    const metadata = this.analyzeMetadata(parentNode || declaration, code);
-    if ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") && declaration.id) {
-      exports.push({
-        name: declaration.id.name,
-        type: "function",
-        parameters: declaration.params.map((p) => {
+  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;
-          if (p.type === "AssignmentPattern" && p.left.type === "Identifier")
-            return p.left.name;
-          if (p.type === "RestElement" && p.argument.type === "Identifier")
-            return p.argument.name;
-          return "unknown";
-        }),
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0,
-        ...metadata
-      });
-    } else if (declaration.type === "ClassDeclaration" && declaration.id) {
-      const body = declaration.body.body;
-      const methods = body.filter((m) => m.type === "MethodDefinition");
-      const properties = body.filter((m) => m.type === "PropertyDefinition");
-      const constructor = methods.find(
-        (m) => m.kind === "constructor"
-      );
-      const parameters = constructor ? 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 "unknown";
-      }) : [];
-      exports.push({
-        name: declaration.id.name,
-        type: "class",
-        methodCount: methods.length,
-        propertyCount: properties.length,
-        parameters,
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0,
-        ...metadata
-      });
-    } else if (declaration.type === "VariableDeclaration") {
-      for (const declarator of declaration.declarations) {
-        if (declarator.id.type === "Identifier") {
-          exports.push({
-            name: declarator.id.name,
-            type: "const",
-            loc: declarator.loc ? {
-              start: {
-                line: declarator.loc.start.line,
-                column: declarator.loc.start.column
-              },
-              end: {
-                line: declarator.loc.end.line,
-                column: declarator.loc.end.column
-              }
-            } : void 0,
-            ...metadata
-          });
+          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;
+  }
+  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;
       }
-    } else if (declaration.type === "TSTypeAliasDeclaration") {
-      exports.push({
-        name: declaration.id.name,
-        type: "type",
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0,
-        ...metadata
-      });
-    } else if (declaration.type === "TSInterfaceDeclaration") {
-      const body = declaration.body.body;
-      const methods = body.filter((m) => m.type === "TSMethodSignature");
-      const properties = body.filter((m) => m.type === "TSPropertySignature");
-      exports.push({
-        name: declaration.id.name,
-        type: "interface",
-        methodCount: methods.length,
-        propertyCount: properties.length || body.length,
-        // Fallback to body.length
-        loc: declaration.loc ? {
-          start: {
-            line: declaration.loc.start.line,
-            column: declaration.loc.start.column
-          },
-          end: {
-            line: declaration.loc.end.line,
-            column: declaration.loc.end.column
-          }
-        } : void 0,
-        ...metadata
-      });
+      return true;
     }
-    return exports;
+    return false;
   }
 };
 
@@ -1327,11 +1305,24 @@ var PythonParser = class extends BaseLanguageParser {
   getParserName() {
     return "python";
   }
+  /**
+   * 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.
+   */
   analyzeMetadata(node, code) {
     return analyzeNodeMetadata(node, code, {
       sideEffectSignatures: ["print(", "input(", "open("]
     });
   }
+  /**
+   * 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) => {
@@ -1413,6 +1404,13 @@ var PythonParser = class extends BaseLanguageParser {
     }
     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) {
@@ -1491,6 +1489,12 @@ var PythonParser = class extends BaseLanguageParser {
     }
     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 [];
@@ -1504,6 +1508,13 @@ var PythonParser = class extends BaseLanguageParser {
       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);
@@ -1777,6 +1788,13 @@ var JavaParser = class extends BaseLanguageParser {
   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: [
@@ -1856,6 +1874,12 @@ var JavaParser = class extends BaseLanguageParser {
       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) {
@@ -1889,6 +1913,13 @@ var JavaParser = class extends BaseLanguageParser {
     }
     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) {
@@ -1919,11 +1950,25 @@ var JavaParser = class extends BaseLanguageParser {
     }
     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;
@@ -1982,11 +2027,24 @@ var CSharpParser = class extends BaseLanguageParser {
   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 = [];
@@ -2048,6 +2106,12 @@ var CSharpParser = class extends BaseLanguageParser {
       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) => {
@@ -2081,6 +2145,14 @@ var CSharpParser = class extends BaseLanguageParser {
     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) => {
@@ -2192,11 +2264,24 @@ var GoParser = class extends BaseLanguageParser {
   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 = [];
@@ -2274,6 +2359,12 @@ var GoParser = class extends BaseLanguageParser {
       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) => {
@@ -2307,6 +2398,13 @@ var GoParser = class extends BaseLanguageParser {
     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) => {
@@ -2663,7 +2761,7 @@ function extractTypeReferences(node) {
   return Array.from(types);
 }
 
-// src/utils/ast-parser.ts
+// src/utils/dependency-analyzer.ts
 function parseFileExports(code, filePath) {
   const parser = getParser(filePath);
   if (parser && parser.language !== "typescript" /* TypeScript */ && parser.language !== "javascript" /* JavaScript */) {
@@ -2705,29 +2803,6 @@ function parseFileExports(code, filePath) {
     return { exports: [], imports: [] };
   }
 }
-function calculateImportSimilarity(export1, export2) {
-  if (export1.imports.length === 0 && export2.imports.length === 0) {
-    return 1;
-  }
-  const set1 = new Set(export1.imports);
-  const set2 = new Set(export2.imports);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
-function parseCode(_code, _language) {
-  void _code;
-  void _language;
-  return null;
-}
-function extractFunctions(_ast) {
-  void _ast;
-  return [];
-}
-function extractImports(_ast) {
-  void _ast;
-  return [];
-}
 
 // src/utils/metrics.ts
 function estimateTokens(text) {
@@ -2776,10 +2851,25 @@ async function loadConfig(rootDir) {
           const content = readFileSync(configPath, "utf-8");
           config = JSON.parse(content);
         }
-        if (typeof config !== "object" || config === null) {
-          throw new Error("Config must be an object");
+        const legacyKeys = ["toolConfigs"];
+        const rootLevelTools = [
+          "pattern-detect",
+          "context-analyzer",
+          "naming-consistency",
+          "ai-signal-clarity"
+        ];
+        const allKeys = Object.keys(config);
+        const foundLegacy = allKeys.filter(
+          (k) => legacyKeys.includes(k) || rootLevelTools.includes(k)
+        );
+        if (foundLegacy.length > 0) {
+          console.warn(
+            `\u26A0\uFE0F Legacy configuration keys found: ${foundLegacy.join(
+              ", "
+            )}. These are deprecated and should be moved under the "tools" key.`
+          );
         }
-        return config;
+        return AIReadyConfigSchema.parse(config);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const configError = new Error(
@@ -2807,12 +2897,10 @@ function mergeConfigWithDefaults(userConfig, defaults) {
     if (userConfig.scan.include) mergedConfig.include = userConfig.scan.include;
     if (userConfig.scan.exclude) mergedConfig.exclude = userConfig.scan.exclude;
   }
-  const toolOverrides = userConfig.tools && !Array.isArray(userConfig.tools) && typeof userConfig.tools === "object" ? userConfig.tools : userConfig.toolConfigs;
-  if (toolOverrides) {
+  if (userConfig.tools) {
     if (!mergedConfig.toolConfigs) mergedConfig.toolConfigs = {};
-    for (const [toolName, toolConfig] of Object.entries(toolOverrides)) {
+    for (const [toolName, toolConfig] of Object.entries(userConfig.tools)) {
       if (typeof toolConfig === "object" && toolConfig !== null) {
-        mergedConfig[toolName] = { ...mergedConfig[toolName], ...toolConfig };
         mergedConfig.toolConfigs[toolName] = {
           ...mergedConfig.toolConfigs[toolName],
           ...toolConfig
@@ -2828,6 +2916,13 @@ function mergeConfigWithDefaults(userConfig, defaults) {
 
 // src/business/pricing-models.ts
 var MODEL_PRICING_PRESETS = {
+  "gpt-5.4-mini": {
+    name: "GPT-5.4 Mini",
+    pricePer1KInputTokens: 1e-4,
+    pricePer1KOutputTokens: 4e-4,
+    contextTier: "extended",
+    typicalQueriesPerDevPerDay: 200
+  },
   "gpt-5.3": {
     name: "GPT-5.3",
     pricePer1KInputTokens: 2e-3,
@@ -2849,20 +2944,6 @@ var MODEL_PRICING_PRESETS = {
     contextTier: "frontier",
     typicalQueriesPerDevPerDay: 120
   },
-  "gpt-4o": {
-    name: "GPT-4o (legacy)",
-    pricePer1KInputTokens: 5e-3,
-    pricePer1KOutputTokens: 0.015,
-    contextTier: "extended",
-    typicalQueriesPerDevPerDay: 60
-  },
-  "claude-3-5-sonnet": {
-    name: "Claude 3.5 Sonnet (legacy)",
-    pricePer1KInputTokens: 3e-3,
-    pricePer1KOutputTokens: 0.015,
-    contextTier: "extended",
-    typicalQueriesPerDevPerDay: 80
-  },
   "gemini-1-5-pro": {
     name: "Gemini 1.5 Pro (legacy)",
     pricePer1KInputTokens: 125e-5,
@@ -2886,7 +2967,7 @@ var MODEL_PRICING_PRESETS = {
   }
 };
 function getModelPreset(modelId) {
-  return MODEL_PRICING_PRESETS[modelId] ?? MODEL_PRICING_PRESETS["claude-4.6"];
+  return MODEL_PRICING_PRESETS[modelId] ?? MODEL_PRICING_PRESETS["gpt-5.4-mini"];
 }
 
 // src/business/cost-metrics.ts
@@ -2907,7 +2988,7 @@ function calculateMonthlyCost(tokenWaste, config = {}) {
       // Added baseline chattiness
     }
   });
-  const preset = getModelPreset("claude-3.5-sonnet");
+  const preset = getModelPreset("gpt-5.4-mini");
   return estimateCostFromBudget(budget, preset, config);
 }
 function calculateTokenBudget(params) {
@@ -3753,12 +3834,12 @@ function calculateTestabilityIndex(params) {
   const rawCoverageRatio = sourceFiles > 0 ? testFiles / sourceFiles : 0;
   const testCoverageRatio = Math.min(100, Math.round(rawCoverageRatio * 100));
   const purityScore = Math.round(
-    (totalFunctions > 0 ? pureFunctions / totalFunctions : 0.5) * 100
+    (totalFunctions > 0 ? pureFunctions / totalFunctions : 0.7) * 100
   );
   const dependencyInjectionScore = Math.round(
     Math.min(
       100,
-      (totalClasses > 0 ? injectionPatterns / totalClasses : 0.5) * 100
+      (totalClasses > 0 ? injectionPatterns / totalClasses : 0.8) * 100
     )
   );
   const interfaceFocusScore = Math.max(
@@ -3839,9 +3920,9 @@ function calculateDocDrift(params) {
   const outdatedRatio = totalExports > 0 ? outdatedComments / totalExports : 0;
   const complexityRatio = totalExports > 0 ? undocumentedComplexity / totalExports : 0;
   const driftRatio = totalExports > 0 ? actualDrift / totalExports : 0;
-  const DRIFT_THRESHOLD = 0.2;
-  const OUTDATED_THRESHOLD = 0.4;
-  const COMPLEXITY_THRESHOLD = 0.2;
+  const DRIFT_THRESHOLD = 0.35;
+  const OUTDATED_THRESHOLD = 0.5;
+  const COMPLEXITY_THRESHOLD = 0.3;
   const UNCOMMENTED_THRESHOLD = 0.8;
   const driftRisk = Math.min(100, driftRatio / DRIFT_THRESHOLD * 100);
   const outdatedRisk = Math.min(
@@ -4306,6 +4387,7 @@ function emitIssuesAsAnnotations(issues) {
   });
 }
 export {
+  AIReadyConfigSchema,
   AnalysisResultSchema,
   AnalysisStatus,
   AnalysisStatusSchema,
@@ -4387,8 +4469,6 @@ export {
   estimateCostFromBudget,
   estimateTokens,
   exportHistory,
-  extractFunctions,
-  extractImports,
   findLatestReport,
   findLatestScanReport,
   formatAcceptanceRate,
@@ -4433,8 +4513,11 @@ export {
   loadMergedConfig,
   loadScoreHistory,
   mergeConfigWithDefaults,
+  normalizeAnalysisResult,
+  normalizeIssue,
+  normalizeMetrics,
+  normalizeSpokeOutput,
   normalizeToolName,
-  parseCode,
   parseFileExports,
   parseWeightString,
   predictAcceptanceRate,