@aiready/context-analyzer 0.9.25 → 0.9.28

package/dist/index.js

@@ -37,7 +37,7 @@ __export(python_context_exports, {
 });
 async function analyzePythonContext(files, rootDir) {
   const results = [];
-  const parser = (0, import_core2.getParser)("dummy.py");
+  const parser = (0, import_core3.getParser)("dummy.py");
   if (!parser) {
     console.warn("Python parser not available");
     return results;
@@ -86,7 +86,7 @@ async function analyzePythonContext(files, rootDir) {
 }
 async function buildPythonDependencyGraph(files, rootDir) {
   const graph = /* @__PURE__ */ new Map();
-  const parser = (0, import_core2.getParser)("dummy.py");
+  const parser = (0, import_core3.getParser)("dummy.py");
   if (!parser) return graph;
   for (const file of files) {
     try {
@@ -167,7 +167,7 @@ async function calculatePythonImportDepth(file, dependencyGraph, visited, depth
   return maxDepth;
 }
 function estimateContextBudget(code, imports, dependencyGraph) {
-  let budget = (0, import_core2.estimateTokens)(code);
+  let budget = (0, import_core3.estimateTokens)(code);
   const avgTokensPerDep = 500;
   budget += imports.length * avgTokensPerDep;
   return budget;
@@ -217,11 +217,11 @@ function detectCircularDependencies2(file, dependencyGraph) {
   dfs(file, []);
   return [...new Set(circular)];
 }
-var import_core2, import_path;
+var import_core3, import_path;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
     "use strict";
-    import_core2 = require("@aiready/core");
+    import_core3 = require("@aiready/core");
     import_path = require("path");
   }
 });
@@ -244,7 +244,7 @@ __export(index_exports, {
   inferDomainFromSemantics: () => inferDomainFromSemantics
 });
 module.exports = __toCommonJS(index_exports);
-var import_core3 = require("@aiready/core");
+var import_core4 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core = require("@aiready/core");
@@ -645,9 +645,9 @@ function calculatePathEntropy(files) {
   if (counts.length <= 1) return 0;
   const total = counts.reduce((s, v) => s + v, 0);
   let entropy = 0;
-  for (const c of counts) {
-    const p = c / total;
-    entropy -= p * Math.log2(p);
+  for (const count of counts) {
+    const prob = count / total;
+    entropy -= prob * Math.log2(prob);
   }
   const maxEntropy = Math.log2(counts.length);
   return maxEntropy > 0 ? entropy / maxEntropy : 0;
@@ -915,8 +915,8 @@ function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
   }
   if (probs.length <= 1) return 1;
   let entropy = 0;
-  for (const p of probs) {
-    entropy -= p * Math.log2(p);
+  for (const prob of probs) {
+    entropy -= prob * Math.log2(prob);
   }
   const maxEntropy = Math.log2(probs.length);
   return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
@@ -956,10 +956,10 @@ function calculateDomainCohesion(exports2) {
   }
   const total = domains.length;
   let entropy = 0;
-  for (const count of domainCounts.values()) {
-    const p = count / total;
-    if (p > 0) {
-      entropy -= p * Math.log2(p);
+  for (const domainCount of domainCounts.values()) {
+    const prob = domainCount / total;
+    if (prob > 0) {
+      entropy -= prob * Math.log2(prob);
     }
   }
   const maxEntropy = Math.log2(total);
@@ -976,13 +976,39 @@ function classifyFile(node, cohesionScore, domains) {
   if (isConfigOrSchemaFile(node)) {
     return "cohesive-module";
   }
+  if (isLambdaHandler(node)) {
+    return "lambda-handler";
+  }
+  if (isDataAccessFile(node)) {
+    return "cohesive-module";
+  }
+  if (isEmailTemplate(node)) {
+    return "email-template";
+  }
+  if (isParserFile(node)) {
+    return "parser-file";
+  }
+  if (isServiceFile(node)) {
+    return "service-file";
+  }
+  if (isSessionFile(node)) {
+    return "cohesive-module";
+  }
+  if (isNextJsPage(node)) {
+    return "nextjs-page";
+  }
+  if (isUtilityFile(node)) {
+    return "utility-module";
+  }
+  if (file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/")) {
+    return "utility-module";
+  }
   const uniqueDomains = domains.filter((d) => d !== "unknown");
   const hasSingleDomain = uniqueDomains.length <= 1;
-  const hasReasonableCohesion = cohesionScore >= 0.5;
   if (hasSingleDomain) {
     return "cohesive-module";
   }
-  if (isUtilityFile(node)) {
+  if (allExportsShareEntityNoun(exports2)) {
     return "cohesive-module";
   }
   const hasMultipleDomains = uniqueDomains.length > 1;
@@ -1017,10 +1043,14 @@ function isTypeDefinitionFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase();
   const isTypesFile = fileName?.includes("types") || fileName?.includes(".d.ts") || fileName === "types.ts" || fileName === "interfaces.ts";
+  const lowerPath = file.toLowerCase();
+  const isTypesPath = lowerPath.includes("/types/") || lowerPath.includes("/typings/") || lowerPath.includes("/@types/") || lowerPath.startsWith("types/") || lowerPath.startsWith("typings/");
   const typeExports = exports2.filter((e) => e.type === "type" || e.type === "interface");
   const runtimeExports = exports2.filter((e) => e.type === "function" || e.type === "class" || e.type === "const");
   const mostlyTypes = exports2.length > 0 && typeExports.length > runtimeExports.length && typeExports.length / exports2.length > 0.7;
-  return isTypesFile || mostlyTypes;
+  const pureTypeFile = exports2.length > 0 && typeExports.length === exports2.length;
+  const emptyOrReExportInTypesDir = isTypesPath && exports2.length === 0;
+  return isTypesFile || isTypesPath || mostlyTypes || pureTypeFile || emptyOrReExportInTypesDir;
 }
 function isConfigOrSchemaFile(node) {
   const { file, exports: exports2 } = node;
@@ -1057,21 +1087,405 @@ function isUtilityFile(node) {
     "helpers",
     "common",
     "shared",
-    "lib",
     "toolbox",
     "toolkit",
     ".util.",
     "-util.",
-    "_util."
+    "_util.",
+    "-utils.",
+    ".utils."
   ];
   const isUtilityName = utilityPatterns.some(
     (pattern) => fileName?.includes(pattern)
   );
-  const isUtilityPath = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/") || file.toLowerCase().includes("/lib/") || file.toLowerCase().includes("/common/");
-  const hasManySmallExports = exports2.length >= 3 && exports2.every(
-    (e) => e.type === "function" || e.type === "const"
+  const isUtilityPath = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/") || file.toLowerCase().includes("/common/") || file.toLowerCase().endsWith("-utils.ts") || file.toLowerCase().endsWith("-util.ts") || file.toLowerCase().endsWith("-helper.ts") || file.toLowerCase().endsWith("-helpers.ts");
+  const hasManySmallExportsInUtilityContext = exports2.length >= 3 && exports2.every((e) => e.type === "function" || e.type === "const") && (isUtilityName || isUtilityPath);
+  return isUtilityName || isUtilityPath || hasManySmallExportsInUtilityContext;
+}
+function splitCamelCase(name) {
+  return name.replace(/([A-Z])/g, " $1").trim().toLowerCase().split(/[\s_-]+/).filter(Boolean);
+}
+var SKIP_WORDS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "create",
+  "update",
+  "delete",
+  "fetch",
+  "save",
+  "load",
+  "parse",
+  "format",
+  "validate",
+  "convert",
+  "transform",
+  "build",
+  "generate",
+  "render",
+  "send",
+  "receive",
+  "find",
+  "list",
+  "add",
+  "remove",
+  "insert",
+  "upsert",
+  "put",
+  "read",
+  "write",
+  "check",
+  "handle",
+  "process",
+  "compute",
+  "calculate",
+  "init",
+  "reset",
+  "clear",
+  "pending",
+  "active",
+  "current",
+  "new",
+  "old",
+  "all",
+  "by",
+  "with",
+  "from",
+  "to",
+  "and",
+  "or",
+  "is",
+  "has",
+  "in",
+  "on",
+  "of",
+  "the"
+]);
+function simpleSingularize(word) {
+  if (word.endsWith("ies") && word.length > 3) return word.slice(0, -3) + "y";
+  if (word.endsWith("ses") && word.length > 4) return word.slice(0, -2);
+  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+function extractEntityNouns(name) {
+  return splitCamelCase(name).filter((token) => !SKIP_WORDS.has(token) && token.length > 2).map(simpleSingularize);
+}
+function allExportsShareEntityNoun(exports2) {
+  if (exports2.length < 2 || exports2.length > 30) return false;
+  const nounSets = exports2.map((e) => new Set(extractEntityNouns(e.name)));
+  if (nounSets.some((s) => s.size === 0)) return false;
+  const [first, ...rest] = nounSets;
+  const commonNouns = Array.from(first).filter(
+    (noun) => rest.every((s) => s.has(noun))
+  );
+  return commonNouns.length > 0;
+}
+function isDataAccessFile(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const dalPatterns = [
+    "dynamo",
+    "database",
+    "repository",
+    "repo",
+    "dao",
+    "firestore",
+    "postgres",
+    "mysql",
+    "mongo",
+    "redis",
+    "sqlite",
+    "supabase",
+    "prisma"
+  ];
+  const isDalName = dalPatterns.some((p) => fileName?.includes(p));
+  const isDalPath = file.toLowerCase().includes("/repositories/") || file.toLowerCase().includes("/dao/") || file.toLowerCase().includes("/data/");
+  const hasDalExportPattern = exports2.length >= 1 && exports2.length <= 10 && allExportsShareEntityNoun(exports2);
+  const isUtilityPathLocal = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/");
+  return isDalPath || isDalName && hasDalExportPattern && !isUtilityPathLocal;
+}
+function isLambdaHandler(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const handlerPatterns = [
+    "handler",
+    ".handler.",
+    "-handler.",
+    "lambda",
+    ".lambda.",
+    "-lambda."
+  ];
+  const isHandlerName = handlerPatterns.some(
+    (pattern) => fileName?.includes(pattern)
+  );
+  const isHandlerPath = file.toLowerCase().includes("/handlers/") || file.toLowerCase().includes("/lambdas/") || file.toLowerCase().includes("/lambda/") || file.toLowerCase().includes("/functions/");
+  const hasHandlerExport = exports2.some(
+    (e) => e.name.toLowerCase() === "handler" || e.name.toLowerCase() === "main" || e.name.toLowerCase() === "lambdahandler" || e.name.toLowerCase().endsWith("handler")
+  );
+  const hasSingleEntryInHandlerContext = exports2.length === 1 && (exports2[0].type === "function" || exports2[0].name === "default") && (isHandlerPath || isHandlerName);
+  return isHandlerName || isHandlerPath || hasHandlerExport || hasSingleEntryInHandlerContext;
+}
+function isServiceFile(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const servicePatterns = [
+    "service",
+    ".service.",
+    "-service.",
+    "_service."
+  ];
+  const isServiceName = servicePatterns.some(
+    (pattern) => fileName?.includes(pattern)
+  );
+  const isServicePath = file.toLowerCase().includes("/services/");
+  const hasServiceNamedExport = exports2.some(
+    (e) => e.name.toLowerCase().includes("service") || e.name.toLowerCase().endsWith("service")
+  );
+  const hasClassExport = exports2.some((e) => e.type === "class");
+  return isServiceName || isServicePath || hasServiceNamedExport && hasClassExport;
+}
+function isEmailTemplate(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const emailTemplatePatterns = [
+    "-email-",
+    ".email.",
+    "_email_",
+    "-template",
+    ".template.",
+    "_template",
+    "-mail.",
+    ".mail."
+  ];
+  const isEmailTemplateName = emailTemplatePatterns.some(
+    (pattern) => fileName?.includes(pattern)
+  );
+  const isSpecificTemplateName = fileName?.includes("receipt") || fileName?.includes("invoice-email") || fileName?.includes("welcome-email") || fileName?.includes("notification-email") || fileName?.includes("writer") && fileName.includes("receipt");
+  const isEmailPath = file.toLowerCase().includes("/emails/") || file.toLowerCase().includes("/mail/") || file.toLowerCase().includes("/notifications/");
+  const hasTemplateFunction = exports2.some(
+    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("render") || e.name.toLowerCase().startsWith("generate") || e.name.toLowerCase().includes("template") && e.name.toLowerCase().includes("email"))
+  );
+  const hasEmailExport = exports2.some(
+    (e) => e.name.toLowerCase().includes("template") && e.type === "function" || e.name.toLowerCase().includes("render") && e.type === "function" || e.name.toLowerCase().includes("email") && e.type !== "class"
+  );
+  return isEmailPath || isEmailTemplateName || isSpecificTemplateName || hasTemplateFunction && hasEmailExport;
+}
+function isParserFile(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const parserPatterns = [
+    "parser",
+    ".parser.",
+    "-parser.",
+    "_parser.",
+    "transform",
+    ".transform.",
+    "-transform.",
+    "converter",
+    ".converter.",
+    "-converter.",
+    "mapper",
+    ".mapper.",
+    "-mapper.",
+    "serializer",
+    ".serializer.",
+    "deterministic"
+    // For base-parser-deterministic.ts pattern
+  ];
+  const isParserName = parserPatterns.some(
+    (pattern) => fileName?.includes(pattern)
+  );
+  const isParserPath = file.toLowerCase().includes("/parsers/") || file.toLowerCase().includes("/transformers/") || file.toLowerCase().includes("/converters/") || file.toLowerCase().includes("/mappers/");
+  const hasParserExport = exports2.some(
+    (e) => e.name.toLowerCase().includes("parse") || e.name.toLowerCase().includes("transform") || e.name.toLowerCase().includes("convert") || e.name.toLowerCase().includes("map") || e.name.toLowerCase().includes("serialize") || e.name.toLowerCase().includes("deserialize")
+  );
+  const hasParseFunction = exports2.some(
+    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("convert") || e.name.toLowerCase().startsWith("map") || e.name.toLowerCase().startsWith("extract"))
+  );
+  return isParserName || isParserPath || hasParserExport || hasParseFunction;
+}
+function isSessionFile(node) {
+  const { file, exports: exports2 } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const sessionPatterns = [
+    "session",
+    ".session.",
+    "-session.",
+    "state",
+    ".state.",
+    "-state.",
+    "context",
+    ".context.",
+    "-context.",
+    "store",
+    ".store.",
+    "-store."
+  ];
+  const isSessionName = sessionPatterns.some(
+    (pattern) => fileName?.includes(pattern)
+  );
+  const isSessionPath = file.toLowerCase().includes("/sessions/") || file.toLowerCase().includes("/state/") || file.toLowerCase().includes("/context/") || file.toLowerCase().includes("/store/");
+  const hasSessionExport = exports2.some(
+    (e) => e.name.toLowerCase().includes("session") || e.name.toLowerCase().includes("state") || e.name.toLowerCase().includes("context") || e.name.toLowerCase().includes("manager") || e.name.toLowerCase().includes("store")
+  );
+  return isSessionName || isSessionPath || hasSessionExport;
+}
+function isNextJsPage(node) {
+  const { file, exports: exports2 } = node;
+  const lowerPath = file.toLowerCase();
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const isInAppDir = lowerPath.includes("/app/") || lowerPath.startsWith("app/");
+  const isPageFile = fileName === "page.tsx" || fileName === "page.ts";
+  if (!isInAppDir || !isPageFile) {
+    return false;
+  }
+  const exportNames = exports2.map((e) => e.name.toLowerCase());
+  const hasDefaultExport = exports2.some((e) => e.type === "default");
+  const nextJsExports = ["metadata", "generatemetadata", "faqjsonld", "jsonld", "icon", "viewport", "dynamic"];
+  const hasNextJsExports = exportNames.some(
+    (name) => nextJsExports.includes(name) || name.includes("jsonld")
   );
-  return isUtilityName || isUtilityPath || hasManySmallExports;
+  return hasDefaultExport || hasNextJsExports;
+}
+function adjustCohesionForClassification(baseCohesion, classification, node) {
+  switch (classification) {
+    case "barrel-export":
+      return 1;
+    case "type-definition":
+      return 1;
+    case "utility-module": {
+      if (node) {
+        const exportNames = node.exports.map((e) => e.name.toLowerCase());
+        const hasRelatedNames = hasRelatedExportNames(exportNames);
+        if (hasRelatedNames) {
+          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
+        }
+      }
+      return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
+    }
+    case "service-file": {
+      if (node?.exports.some((e) => e.type === "class")) {
+        return Math.max(0.78, Math.min(1, baseCohesion + 0.4));
+      }
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    }
+    case "lambda-handler": {
+      if (node) {
+        const hasSingleEntry = node.exports.length === 1 || node.exports.some((e) => e.name.toLowerCase() === "handler");
+        if (hasSingleEntry) {
+          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
+        }
+      }
+      return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
+    }
+    case "email-template": {
+      if (node) {
+        const hasTemplateFunc = node.exports.some(
+          (e) => e.name.toLowerCase().includes("render") || e.name.toLowerCase().includes("generate") || e.name.toLowerCase().includes("template")
+        );
+        if (hasTemplateFunc) {
+          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
+        }
+      }
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    }
+    case "parser-file": {
+      if (node) {
+        const hasParseFunc = node.exports.some(
+          (e) => e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("convert")
+        );
+        if (hasParseFunc) {
+          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
+        }
+      }
+      return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
+    }
+    case "nextjs-page":
+      return 1;
+    case "cohesive-module":
+      return Math.max(baseCohesion, 0.7);
+    case "mixed-concerns":
+      return baseCohesion;
+    default:
+      return Math.min(1, baseCohesion + 0.1);
+  }
+}
+function hasRelatedExportNames(exportNames) {
+  if (exportNames.length < 2) return true;
+  const stems = /* @__PURE__ */ new Set();
+  const domains = /* @__PURE__ */ new Set();
+  for (const name of exportNames) {
+    const verbs = ["get", "set", "create", "update", "delete", "fetch", "save", "load", "parse", "format", "validate", "convert", "transform", "build", "generate", "render", "send", "receive"];
+    for (const verb of verbs) {
+      if (name.startsWith(verb) && name.length > verb.length) {
+        stems.add(name.slice(verb.length).toLowerCase());
+      }
+    }
+    const domainPatterns = ["user", "order", "product", "session", "email", "file", "db", "s3", "dynamo", "api", "config"];
+    for (const domain of domainPatterns) {
+      if (name.includes(domain)) {
+        domains.add(domain);
+      }
+    }
+  }
+  if (stems.size === 1 && exportNames.length >= 2) return true;
+  if (domains.size === 1 && exportNames.length >= 2) return true;
+  const prefixes = exportNames.map((name) => {
+    const match = name.match(/^([a-z]+)/);
+    return match ? match[1] : "";
+  }).filter((p) => p.length >= 3);
+  if (prefixes.length >= 2) {
+    const uniquePrefixes = new Set(prefixes);
+    if (uniquePrefixes.size === 1) return true;
+  }
+  const nounSets = exportNames.map((name) => {
+    const tokens = name.replace(/([A-Z])/g, " $1").trim().toLowerCase().split(/[\s_-]+/).filter(Boolean);
+    const skip = /* @__PURE__ */ new Set([
+      "get",
+      "set",
+      "create",
+      "update",
+      "delete",
+      "fetch",
+      "save",
+      "load",
+      "parse",
+      "format",
+      "validate",
+      "convert",
+      "transform",
+      "build",
+      "generate",
+      "render",
+      "send",
+      "receive",
+      "find",
+      "list",
+      "add",
+      "remove",
+      "insert",
+      "upsert",
+      "put",
+      "read",
+      "write",
+      "check",
+      "handle",
+      "process",
+      "pending",
+      "active",
+      "current",
+      "new",
+      "old",
+      "all"
+    ]);
+    const singularize2 = (w) => w.endsWith("s") && w.length > 3 ? w.slice(0, -1) : w;
+    return new Set(tokens.filter((t) => !skip.has(t) && t.length > 2).map(singularize2));
+  });
+  if (nounSets.length >= 2 && nounSets.every((s) => s.size > 0)) {
+    const [first, ...rest] = nounSets;
+    const commonNouns = Array.from(first).filter((n) => rest.every((s) => s.has(n)));
+    if (commonNouns.length > 0) return true;
+  }
+  return false;
 }
 function adjustFragmentationForClassification(baseFragmentation, classification) {
   switch (classification) {
@@ -1079,6 +1493,13 @@ function adjustFragmentationForClassification(baseFragmentation, classification)
       return 0;
     case "type-definition":
       return 0;
+    case "utility-module":
+    case "service-file":
+    case "lambda-handler":
+    case "email-template":
+    case "parser-file":
+    case "nextjs-page":
+      return baseFragmentation * 0.2;
     case "cohesive-module":
       return baseFragmentation * 0.3;
     case "mixed-concerns":
@@ -1104,6 +1525,36 @@ function getClassificationRecommendations(classification, file, issues) {
         "Module has good cohesion despite its size",
         "Consider documenting the module boundaries for AI assistants"
       ];
+    case "utility-module":
+      return [
+        "Utility module detected - multiple domains are acceptable here",
+        "Consider grouping related utilities by prefix or domain for better discoverability"
+      ];
+    case "service-file":
+      return [
+        "Service file detected - orchestration of multiple dependencies is expected",
+        "Consider documenting service boundaries and dependencies"
+      ];
+    case "lambda-handler":
+      return [
+        "Lambda handler detected - coordination of services is expected",
+        "Ensure handler has clear single responsibility"
+      ];
+    case "email-template":
+      return [
+        "Email template detected - references multiple domains for rendering",
+        "Template structure is cohesive by design"
+      ];
+    case "parser-file":
+      return [
+        "Parser/transformer file detected - handles multiple data sources",
+        "Consider documenting input/output schemas"
+      ];
+    case "nextjs-page":
+      return [
+        "Next.js App Router page detected - metadata/JSON-LD/component pattern is cohesive",
+        "Multiple exports (metadata, faqJsonLd, default) serve single page purpose"
+      ];
     case "mixed-concerns":
       return [
         "Consider splitting this file by domain",
@@ -1116,7 +1567,8 @@ function getClassificationRecommendations(classification, file, issues) {
 }
 
 // src/scoring.ts
-function calculateContextScore(summary) {
+var import_core2 = require("@aiready/core");
+function calculateContextScore(summary, costConfig) {
   const {
     avgContextBudget,
     maxContextBudget,
@@ -1205,6 +1657,14 @@ function calculateContextScore(summary) {
       priority: "high"
     });
   }
+  const cfg = { ...import_core2.DEFAULT_COST_CONFIG, ...costConfig };
+  const totalContextBudget = avgContextBudget * summary.totalFiles;
+  const estimatedMonthlyCost = (0, import_core2.calculateMonthlyCost)(totalContextBudget, cfg);
+  const issues = [
+    ...Array(criticalIssues).fill({ severity: "critical" }),
+    ...Array(majorIssues).fill({ severity: "major" })
+  ];
+  const productivityImpact = (0, import_core2.calculateProductivityImpact)(issues);
   return {
     toolName: "context-analyzer",
     score,
@@ -1215,7 +1675,10 @@ function calculateContextScore(summary) {
       maxImportDepth,
       avgFragmentation: Math.round(avgFragmentation * 100) / 100,
       criticalIssues,
-      majorIssues
+      majorIssues,
+      // Business value metrics
+      estimatedMonthlyCost,
+      estimatedDeveloperHours: productivityImpact.totalHours
     },
     factors,
     recommendations
@@ -1224,7 +1687,7 @@ function calculateContextScore(summary) {
 
 // src/index.ts
 async function getSmartDefaults(directory, userOptions) {
-  const files = await (0, import_core3.scanFiles)({
+  const files = await (0, import_core4.scanFiles)({
     rootDir: directory,
     include: userOptions.include,
     exclude: userOptions.exclude
@@ -1277,7 +1740,7 @@ async function analyzeContext(options) {
     includeNodeModules = false,
     ...scanOptions
   } = options;
-  const files = await (0, import_core3.scanFiles)({
+  const files = await (0, import_core4.scanFiles)({
     ...scanOptions,
     // Only add node_modules to exclude if includeNodeModules is false
     // The DEFAULT_EXCLUDE already includes node_modules, so this is only needed
@@ -1289,7 +1752,7 @@ async function analyzeContext(options) {
   const fileContents = await Promise.all(
     files.map(async (file) => ({
       file,
-      content: await (0, import_core3.readFileContent)(file)
+      content: await (0, import_core4.readFileContent)(file)
     }))
   );
   const graph = buildDependencyGraph(fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py")));
@@ -1352,7 +1815,7 @@ async function analyzeContext(options) {
     const importDepth = focus === "depth" || focus === "all" ? calculateImportDepth(file, graph) : 0;
     const dependencyList = focus === "depth" || focus === "all" ? getTransitiveDependencies(file, graph) : [];
     const contextBudget = focus === "all" ? calculateContextBudget(file, graph) : node.tokenCost;
-    const cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports, file) : 1;
+    const cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports, file, { coUsageMatrix: graph.coUsageMatrix }) : 1;
     const fragmentationScore = fragmentationMap.get(file) || 0;
     const relatedFiles = [];
     for (const cluster of clusters) {
@@ -1377,6 +1840,11 @@ async function analyzeContext(options) {
       ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
     ];
     const fileClassification = classifyFile(node, cohesionScore, domains);
+    const adjustedCohesionScore = adjustCohesionForClassification(
+      cohesionScore,
+      fileClassification,
+      node
+    );
     const adjustedFragmentationScore = adjustFragmentationForClassification(
       fragmentationScore,
       fileClassification
@@ -1395,7 +1863,8 @@ async function analyzeContext(options) {
       file,
       importDepth,
       contextBudget,
-      cohesionScore,
+      cohesionScore: adjustedCohesionScore,
+      // Use adjusted cohesion
       fragmentationScore: adjustedFragmentationScore,
       maxDepth,
       maxContextBudget,
@@ -1411,7 +1880,8 @@ async function analyzeContext(options) {
       dependencyCount: dependencyList.length,
       dependencyList,
       circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
-      cohesionScore,
+      cohesionScore: adjustedCohesionScore,
+      // Report adjusted cohesion
       domains,
       exportCount: node.exports.length,
       contextBudget,