@aiready/core 0.23.7 → 0.23.9

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-CGOS2J6T.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) {
@@ -725,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 = [];
@@ -904,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;
   }
 };
 
@@ -1355,7 +1321,7 @@ var PythonParser = class extends BaseLanguageParser {
    * Extract import information using AST walk.
    *
    * @param rootNode - Root node of the Python AST.
-   * @returns Array of discovered ImportInfo objects.
+   * @returns Array of discovered FileImport objects.
    */
   extractImportsAST(rootNode) {
     const imports = [];
@@ -1912,7 +1878,7 @@ var JavaParser = class extends BaseLanguageParser {
    * Extract import information using AST walk.
    *
    * @param rootNode - Root node of the Java AST.
-   * @returns Array of discovered ImportInfo objects.
+   * @returns Array of discovered FileImport objects.
    */
   extractImportsAST(rootNode) {
     const imports = [];
@@ -2144,7 +2110,7 @@ var CSharpParser = class extends BaseLanguageParser {
    * Extract import information (usings) using AST walk.
    *
    * @param rootNode - Root node of the C# AST.
-   * @returns Array of discovered ImportInfo objects.
+   * @returns Array of discovered FileImport objects.
    */
   extractImportsAST(rootNode) {
     const imports = [];
@@ -2397,7 +2363,7 @@ var GoParser = class extends BaseLanguageParser {
    * Extract import information using AST walk.
    *
    * @param rootNode - Root node of the Go AST.
-   * @returns Array of discovered ImportInfo objects.
+   * @returns Array of discovered FileImport objects.
    */
   extractImportsAST(rootNode) {
     const imports = [];
@@ -2885,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(
@@ -2916,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
@@ -2937,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,
@@ -2958,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,
@@ -2995,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
@@ -3016,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) {
@@ -3846,6 +3818,40 @@ function calculateAgentGrounding(params) {
 }
 
 // src/metrics/testability-index.ts
+function isLikelyEntryPoint(filePath) {
+  const basename = filePath.split("/").pop() || "";
+  const lowerBasename = basename.toLowerCase();
+  const entryPointPatterns = [
+    "cli",
+    "main",
+    "bin",
+    "index",
+    // often used as entry point
+    "run",
+    "serve",
+    "start",
+    "boot",
+    "init"
+  ];
+  const nameWithoutExt = lowerBasename.replace(
+    /\.(ts|js|tsx|jsx|mjs|cjs)$/,
+    ""
+  );
+  if (entryPointPatterns.some(
+    (p) => nameWithoutExt === p || nameWithoutExt.endsWith(`-${p}`) || nameWithoutExt.startsWith(`${p}-`)
+  )) {
+    return true;
+  }
+  const cliDirPatterns = ["/bin/", "/cli/", "/cmd/", "/commands/"];
+  if (cliDirPatterns.some((p) => filePath.includes(p))) {
+    return true;
+  }
+  return false;
+}
+function calculateFilePurityScore(pureFunctions, totalFunctions) {
+  if (totalFunctions === 0) return 100;
+  return Math.round(pureFunctions / totalFunctions * 100);
+}
 function calculateTestabilityIndex(params) {
   const {
     testFiles,
@@ -3857,17 +3863,18 @@ function calculateTestabilityIndex(params) {
     bloatedInterfaces,
     totalInterfaces,
     externalStateMutations,
-    hasTestFramework
+    hasTestFramework,
+    fileDetails
   } = 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(
@@ -3883,7 +3890,39 @@ function calculateTestabilityIndex(params) {
     )
   );
   const frameworkWeight = hasTestFramework ? 1 : 0.8;
-  const rawScore = (testCoverageRatio * 0.3 + purityScore * 0.25 + dependencyInjectionScore * 0.2 + interfaceFocusScore * 0.1 + observabilityScore * 0.15) * frameworkWeight;
+  let fileMetrics;
+  let libraryPureFunctions = pureFunctions;
+  let libraryTotalFunctions = totalFunctions;
+  let entryPointCount = 0;
+  if (fileDetails && fileDetails.length > 0) {
+    fileMetrics = fileDetails.map((file) => {
+      const isEntryPoint = isLikelyEntryPoint(file.filePath);
+      const purityScore2 = calculateFilePurityScore(
+        file.pureFunctions,
+        file.totalFunctions
+      );
+      if (isEntryPoint) {
+        entryPointCount++;
+        libraryPureFunctions -= file.pureFunctions;
+        libraryTotalFunctions -= file.totalFunctions;
+      }
+      return {
+        filePath: file.filePath,
+        score: purityScore2,
+        // Simplified - just purity for file-level
+        purityScore: purityScore2,
+        isEntryPoint
+      };
+    });
+  }
+  const libraryPurityScore = Math.max(
+    0,
+    Math.round(
+      (libraryTotalFunctions > 0 ? libraryPureFunctions / libraryTotalFunctions : 0.7) * 100
+    )
+  );
+  const effectivePurityScore = fileDetails && fileDetails.length > 0 ? libraryPurityScore : purityScore;
+  const rawScore = (testCoverageRatio * 0.3 + effectivePurityScore * 0.25 + dependencyInjectionScore * 0.2 + interfaceFocusScore * 0.1 + observabilityScore * 0.15) * frameworkWeight;
   const score = Math.max(0, Math.min(100, Math.round(rawScore)));
   let rating;
   if (score >= 85) rating = "excellent";
@@ -3908,9 +3947,9 @@ function calculateTestabilityIndex(params) {
       `Add ~${neededTests} test files to reach 30% coverage ratio \u2014 minimum for safe AI assistance`
     );
   }
-  if (purityScore < 50)
+  if (effectivePurityScore < 50)
     recommendations.push(
-      "Extract pure functions from side-effectful code \u2014 pure functions are trivially AI-testable"
+      entryPointCount > 0 ? `Extract pure functions from library code (${entryPointCount} entry point files excluded) \u2014 pure functions are trivially AI-testable` : "Extract pure functions from side-effectful code \u2014 pure functions are trivially AI-testable"
     );
   if (dependencyInjectionScore < 50 && totalClasses > 0)
     recommendations.push(
@@ -3925,13 +3964,15 @@ function calculateTestabilityIndex(params) {
     rating,
     dimensions: {
       testCoverageRatio,
-      purityScore,
+      purityScore: effectivePurityScore,
       dependencyInjectionScore,
       interfaceFocusScore,
       observabilityScore
     },
     aiChangeSafetyRating,
-    recommendations
+    recommendations,
+    fileMetrics,
+    libraryScore: Math.max(0, fileMetrics ? libraryPurityScore : purityScore)
   };
 }
 
@@ -3948,9 +3989,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(
@@ -4415,6 +4456,7 @@ function emitIssuesAsAnnotations(issues) {
   });
 }
 export {
+  AIReadyConfigSchema,
   AnalysisResultSchema,
   AnalysisStatus,
   AnalysisStatusSchema,
@@ -4540,6 +4582,10 @@ export {
   loadMergedConfig,
   loadScoreHistory,
   mergeConfigWithDefaults,
+  normalizeAnalysisResult,
+  normalizeIssue,
+  normalizeMetrics,
+  normalizeSpokeOutput,
   normalizeToolName,
   parseFileExports,
   parseWeightString,