@aiready/context-analyzer 0.21.10 → 0.21.12

package/dist/index.js

@@ -336,7 +336,7 @@ var import_core11 = require("@aiready/core");
 // src/provider.ts
 var import_core9 = require("@aiready/core");
 
-// src/analyzer.ts
+// src/orchestrator.ts
 var import_core6 = require("@aiready/core");
 
 // src/metrics.ts
@@ -649,16 +649,17 @@ function calculateEnhancedCohesion(exports2, filePath, options) {
   if (filePath && isTestFile(filePath)) return 1;
   const domains = exports2.map((e) => e.inferredDomain || "unknown");
   const domainCounts = /* @__PURE__ */ new Map();
-  for (const d of domains) domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+  for (const domain of domains)
+    domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
   if (domainCounts.size === 1 && domains[0] !== "unknown") {
     if (!options?.weights) return 1;
   }
   const probs = Array.from(domainCounts.values()).map(
-    (c) => c / exports2.length
+    (count) => count / exports2.length
   );
   let domainEntropy = 0;
-  for (const p of probs) {
-    if (p > 0) domainEntropy -= p * Math.log2(p);
+  for (const prob of probs) {
+    if (prob > 0) domainEntropy -= prob * Math.log2(prob);
   }
   const maxEntropy = Math.log2(Math.max(2, domainCounts.size));
   const domainScore = 1 - domainEntropy / maxEntropy;
@@ -719,7 +720,7 @@ function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
 function calculateFragmentation(files, domain, options) {
   if (files.length <= 1) return 0;
   const directories = new Set(
-    files.map((f) => f.split("/").slice(0, -1).join("/"))
+    files.map((file) => file.split("/").slice(0, -1).join("/"))
   );
   const uniqueDirs = directories.size;
   let score = options?.useLogScale ? uniqueDirs <= 1 ? 0 : Math.log(uniqueDirs) / Math.log(options.logBase || Math.E) / (Math.log(files.length) / Math.log(options.logBase || Math.E)) : (uniqueDirs - 1) / (files.length - 1);
@@ -732,13 +733,13 @@ function calculateFragmentation(files, domain, options) {
 function calculatePathEntropy(files) {
   if (!files || files.length === 0) return 0;
   const dirCounts = /* @__PURE__ */ new Map();
-  for (const f of files) {
-    const dir = f.split("/").slice(0, -1).join("/") || ".";
+  for (const file of files) {
+    const dir = file.split("/").slice(0, -1).join("/") || ".";
     dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
   }
   const counts = Array.from(dirCounts.values());
   if (counts.length <= 1) return 0;
-  const total = counts.reduce((s, v) => s + v, 0);
+  const total = counts.reduce((sum, value) => sum + value, 0);
   let entropy = 0;
   for (const count of counts) {
     const prob = count / total;
@@ -749,11 +750,11 @@ function calculatePathEntropy(files) {
 }
 function calculateDirectoryDistance(files) {
   if (!files || files.length <= 1) return 0;
-  const pathSegments = (p) => p.split("/").filter(Boolean);
-  const commonAncestorDepth = (a, b) => {
-    const minLen = Math.min(a.length, b.length);
+  const pathSegments = (pathStr) => pathStr.split("/").filter(Boolean);
+  const commonAncestorDepth = (pathA, pathB) => {
+    const minLen = Math.min(pathA.length, pathB.length);
     let i = 0;
-    while (i < minLen && a[i] === b[i]) i++;
+    while (i < minLen && pathA[i] === pathB[i]) i++;
     return i;
   };
   let totalNormalized = 0;
@@ -1002,86 +1003,67 @@ function detectCircularDependencies(graph) {
   return detectGraphCycles(graph.edges);
 }
 
-// src/cluster-detector.ts
-function detectModuleClusters(graph, options) {
-  const domainMap = /* @__PURE__ */ new Map();
-  for (const [file, node] of graph.nodes.entries()) {
-    const primaryDomain = node.exports[0]?.inferredDomain || "unknown";
-    if (!domainMap.has(primaryDomain)) {
-      domainMap.set(primaryDomain, []);
-    }
-    domainMap.get(primaryDomain).push(file);
-  }
-  const clusters = [];
-  const generateSuggestedStructure = (files, tokens, fragmentation) => {
-    const targetFiles = Math.max(1, Math.ceil(tokens / 1e4));
-    const plan = [];
-    if (fragmentation > 0.5) {
-      plan.push(
-        `Consolidate ${files.length} files scattered across multiple directories into ${targetFiles} core module(s)`
-      );
-    }
-    if (tokens > 2e4) {
-      plan.push(
-        `Domain logic is very large (${Math.round(tokens / 1e3)}k tokens). Ensure clear sub-domain boundaries.`
-      );
-    }
-    return { targetFiles, consolidationPlan: plan };
-  };
-  for (const [domain, files] of domainMap.entries()) {
-    if (files.length < 2 || domain === "unknown") continue;
-    const totalTokens = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node?.tokenCost || 0);
-    }, 0);
-    let sharedImportRatio = 0;
-    if (files.length >= 2) {
-      const allImportSets = files.map(
-        (f) => new Set(graph.nodes.get(f)?.imports || [])
-      );
-      let intersection = new Set(allImportSets[0]);
-      const union = new Set(allImportSets[0]);
-      for (let i = 1; i < allImportSets.length; i++) {
-        const nextSet = allImportSets[i];
-        intersection = new Set([...intersection].filter((x) => nextSet.has(x)));
-        for (const x of nextSet) union.add(x);
-      }
-      sharedImportRatio = union.size > 0 ? intersection.size / union.size : 0;
-    }
-    const fragmentation = calculateFragmentation(files, domain, {
-      ...options,
-      sharedImportRatio
-    });
-    let totalCohesion = 0;
-    files.forEach((f) => {
-      const node = graph.nodes.get(f);
-      if (node) totalCohesion += calculateEnhancedCohesion(node.exports);
-    });
-    const avgCohesion = totalCohesion / files.length;
-    clusters.push({
-      domain,
-      files,
-      totalTokens,
-      fragmentationScore: fragmentation,
-      avgCohesion,
-      suggestedStructure: generateSuggestedStructure(
-        files,
-        totalTokens,
-        fragmentation
-      )
-    });
-  }
-  return clusters;
-}
-
 // src/heuristics.ts
+var BARREL_EXPORT_MIN_EXPORTS = 5;
+var BARREL_EXPORT_TOKEN_LIMIT = 1e3;
+var HANDLER_NAME_PATTERNS = [
+  "handler",
+  ".handler.",
+  "-handler.",
+  "lambda",
+  ".lambda.",
+  "-lambda."
+];
+var SERVICE_NAME_PATTERNS = [
+  "service",
+  ".service.",
+  "-service.",
+  "_service."
+];
+var EMAIL_NAME_PATTERNS = [
+  "-email-",
+  ".email.",
+  "_email_",
+  "-template",
+  ".template.",
+  "_template",
+  "-mail.",
+  ".mail."
+];
+var PARSER_NAME_PATTERNS = [
+  "parser",
+  ".parser.",
+  "-parser.",
+  "_parser.",
+  "transform",
+  "converter",
+  "mapper",
+  "serializer"
+];
+var SESSION_NAME_PATTERNS = ["session", "state", "context", "store"];
+var NEXTJS_METADATA_EXPORTS = [
+  "metadata",
+  "generatemetadata",
+  "faqjsonld",
+  "jsonld",
+  "icon"
+];
+var CONFIG_NAME_PATTERNS = [
+  ".config.",
+  "tsconfig",
+  "jest.config",
+  "package.json",
+  "aiready.json",
+  "next.config",
+  "sst.config"
+];
 function isBarrelExport(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase();
   const isIndexFile = fileName === "index.ts" || fileName === "index.js";
-  const isSmallAndManyExports = node.tokenCost < 1e3 && (exports2 || []).length > 5;
-  const isReexportPattern = (exports2 || []).length >= 5 && (exports2 || []).every(
-    (e) => ["const", "function", "type", "interface"].includes(e.type)
+  const isSmallAndManyExports = node.tokenCost < BARREL_EXPORT_TOKEN_LIMIT && (exports2 || []).length > BARREL_EXPORT_MIN_EXPORTS;
+  const isReexportPattern = (exports2 || []).length >= BARREL_EXPORT_MIN_EXPORTS && (exports2 || []).every(
+    (exp) => ["const", "function", "type", "interface"].includes(exp.type)
   );
   return !!isIndexFile || !!isSmallAndManyExports || !!isReexportPattern;
 }
@@ -1090,7 +1072,9 @@ function isTypeDefinition(node) {
   if (file.endsWith(".d.ts")) return true;
   const nodeExports = node.exports || [];
   const hasExports = nodeExports.length > 0;
-  const areAllTypes = hasExports && nodeExports.every((e) => e.type === "type" || e.type === "interface");
+  const areAllTypes = hasExports && nodeExports.every(
+    (exp) => exp.type === "type" || exp.type === "interface"
+  );
   const isTypePath = /\/(types|interfaces|models)\//i.test(file);
   return !!areAllTypes || isTypePath && hasExports;
 }
@@ -1104,81 +1088,65 @@ function isUtilityModule(node) {
 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((p) => fileName.includes(p));
+  const isHandlerName = HANDLER_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isHandlerPath = /\/(handlers|lambdas|lambda|functions)\//i.test(file);
   const hasHandlerExport = (exports2 || []).some(
-    (e) => ["handler", "main", "lambdahandler"].includes(e.name.toLowerCase()) || e.name.toLowerCase().endsWith("handler")
+    (exp) => ["handler", "main", "lambdahandler"].includes(exp.name.toLowerCase()) || exp.name.toLowerCase().endsWith("handler")
   );
   return isHandlerName || isHandlerPath || hasHandlerExport;
 }
 function isServiceFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase() || "";
-  const servicePatterns = ["service", ".service.", "-service.", "_service."];
-  const isServiceName = servicePatterns.some((p) => fileName.includes(p));
+  const isServiceName = SERVICE_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isServicePath = file.toLowerCase().includes("/services/");
   const hasServiceNamedExport = (exports2 || []).some(
-    (e) => e.name.toLowerCase().includes("service")
+    (exp) => exp.name.toLowerCase().includes("service")
+  );
+  const hasClassExport = (exports2 || []).some(
+    (exp) => exp.type === "class"
   );
-  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 emailPatterns = [
-    "-email-",
-    ".email.",
-    "_email_",
-    "-template",
-    ".template.",
-    "_template",
-    "-mail.",
-    ".mail."
-  ];
-  const isEmailName = emailPatterns.some((p) => fileName.includes(p));
+  const isEmailName = EMAIL_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isEmailPath = /\/(emails|mail|notifications)\//i.test(file);
   const hasTemplateFunction = (exports2 || []).some(
-    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("render") || e.name.toLowerCase().startsWith("generate"))
+    (exp) => exp.type === "function" && (exp.name.toLowerCase().startsWith("render") || exp.name.toLowerCase().startsWith("generate"))
   );
   return isEmailPath || isEmailName || hasTemplateFunction;
 }
 function isParserFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase() || "";
-  const parserPatterns = [
-    "parser",
-    ".parser.",
-    "-parser.",
-    "_parser.",
-    "transform",
-    "converter",
-    "mapper",
-    "serializer"
-  ];
-  const isParserName = parserPatterns.some((p) => fileName.includes(p));
+  const isParserName = PARSER_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isParserPath = /\/(parsers|transformers)\//i.test(file);
   const hasParseFunction = (exports2 || []).some(
-    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform"))
+    (exp) => exp.type === "function" && (exp.name.toLowerCase().startsWith("parse") || exp.name.toLowerCase().startsWith("transform"))
   );
   return isParserName || isParserPath || hasParseFunction;
 }
 function isSessionFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase() || "";
-  const sessionPatterns = ["session", "state", "context", "store"];
-  const isSessionName = sessionPatterns.some((p) => fileName.includes(p));
+  const isSessionName = SESSION_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isSessionPath = /\/(sessions|state)\//i.test(file);
   const hasSessionExport = (exports2 || []).some(
-    (e) => ["session", "state", "store"].some((p) => e.name.toLowerCase().includes(p))
+    (exp) => ["session", "state", "store"].some(
+      (pattern) => exp.name.toLowerCase().includes(pattern)
+    )
   );
   return isSessionName || isSessionPath || hasSessionExport;
 }
@@ -1189,16 +1157,11 @@ function isNextJsPage(node) {
   const isInAppDir = lowerPath.includes("/app/") || lowerPath.startsWith("app/");
   if (!isInAppDir || fileName !== "page.tsx" && fileName !== "page.ts")
     return false;
-  const hasDefaultExport = (exports2 || []).some((e) => e.type === "default");
-  const nextJsExports = [
-    "metadata",
-    "generatemetadata",
-    "faqjsonld",
-    "jsonld",
-    "icon"
-  ];
+  const hasDefaultExport = (exports2 || []).some(
+    (exp) => exp.type === "default"
+  );
   const hasNextJsExport = (exports2 || []).some(
-    (e) => nextJsExports.includes(e.name.toLowerCase())
+    (exp) => NEXTJS_METADATA_EXPORTS.includes(exp.name.toLowerCase())
   );
   return hasDefaultExport || hasNextJsExport;
 }
@@ -1206,24 +1169,21 @@ function isConfigFile(node) {
   const { file, exports: exports2 } = node;
   const lowerPath = file.toLowerCase();
   const fileName = file.split("/").pop()?.toLowerCase() || "";
-  const configPatterns = [
-    ".config.",
-    "tsconfig",
-    "jest.config",
-    "package.json",
-    "aiready.json",
-    "next.config",
-    "sst.config"
-  ];
-  const isConfigName = configPatterns.some((p) => fileName.includes(p));
+  const isConfigName = CONFIG_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
   const isConfigPath = /\/(config|settings|schemas)\//i.test(lowerPath);
   const hasSchemaExport = (exports2 || []).some(
-    (e) => ["schema", "config", "setting"].some(
-      (p) => e.name.toLowerCase().includes(p)
+    (exp) => ["schema", "config", "setting"].some(
+      (pattern) => exp.name.toLowerCase().includes(pattern)
     )
   );
   return isConfigName || isConfigPath || hasSchemaExport;
 }
+function isHubAndSpokeFile(node) {
+  const { file } = node;
+  return /\/packages\/[a-zA-Z0-9-]+\/src\//.test(file);
+}
 
 // src/classifier.ts
 var Classification = {
@@ -1236,6 +1196,7 @@ var Classification = {
   PARSER: "parser-file",
   COHESIVE_MODULE: "cohesive-module",
   UTILITY_MODULE: "utility-module",
+  SPOKE_MODULE: "spoke-module",
   MIXED_CONCERNS: "mixed-concerns",
   UNKNOWN: "unknown"
 };
@@ -1272,6 +1233,9 @@ function classifyFile(node, cohesionScore = 1, domains = []) {
   if (isConfigFile(node)) {
     return Classification.COHESIVE_MODULE;
   }
+  if (isHubAndSpokeFile(node)) {
+    return Classification.SPOKE_MODULE;
+  }
   if (domains.length <= 1 && domains[0] !== "unknown") {
     return Classification.COHESIVE_MODULE;
   }
@@ -1307,6 +1271,8 @@ function adjustCohesionForClassification(baseCohesion, classification, node) {
       return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
     case Classification.PARSER:
       return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
+    case Classification.SPOKE_MODULE:
+      return Math.max(baseCohesion, 0.6);
     case Classification.COHESIVE_MODULE:
       return Math.max(baseCohesion, 0.7);
     case Classification.MIXED_CONCERNS:
@@ -1369,6 +1335,9 @@ function adjustFragmentationForClassification(baseFragmentation, classification)
     case Classification.PARSER:
     case Classification.NEXTJS_PAGE:
       return baseFragmentation * 0.2;
+    case Classification.SPOKE_MODULE:
+      return baseFragmentation * 0.15;
+    // Heavily discount intentional monorepo separation
     case Classification.COHESIVE_MODULE:
       return baseFragmentation * 0.3;
     case Classification.MIXED_CONCERNS:
@@ -1378,6 +1347,88 @@ function adjustFragmentationForClassification(baseFragmentation, classification)
   }
 }
 
+// src/cluster-detector.ts
+function detectModuleClusters(graph, options) {
+  const domainMap = /* @__PURE__ */ new Map();
+  for (const [file, node] of graph.nodes.entries()) {
+    const primaryDomain = node.exports[0]?.inferredDomain || "unknown";
+    if (!domainMap.has(primaryDomain)) {
+      domainMap.set(primaryDomain, []);
+    }
+    domainMap.get(primaryDomain).push(file);
+  }
+  const clusters = [];
+  const generateSuggestedStructure = (files, tokens, fragmentation) => {
+    const targetFiles = Math.max(1, Math.ceil(tokens / 1e4));
+    const plan = [];
+    if (fragmentation > 0.5) {
+      plan.push(
+        `Consolidate ${files.length} files scattered across multiple directories into ${targetFiles} core module(s)`
+      );
+    }
+    if (tokens > 2e4) {
+      plan.push(
+        `Domain logic is very large (${Math.round(tokens / 1e3)}k tokens). Ensure clear sub-domain boundaries.`
+      );
+    }
+    return { targetFiles, consolidationPlan: plan };
+  };
+  for (const [domain, files] of domainMap.entries()) {
+    if (files.length < 2 || domain === "unknown") continue;
+    const totalTokens = files.reduce((sum, file) => {
+      const node = graph.nodes.get(file);
+      return sum + (node?.tokenCost || 0);
+    }, 0);
+    let sharedImportRatio = 0;
+    if (files.length >= 2) {
+      const allImportSets = files.map(
+        (f) => new Set(graph.nodes.get(f)?.imports || [])
+      );
+      let intersection = new Set(allImportSets[0]);
+      const union = new Set(allImportSets[0]);
+      for (let i = 1; i < allImportSets.length; i++) {
+        const nextSet = allImportSets[i];
+        intersection = new Set([...intersection].filter((x) => nextSet.has(x)));
+        for (const x of nextSet) union.add(x);
+      }
+      sharedImportRatio = union.size > 0 ? intersection.size / union.size : 0;
+    }
+    const rawFragmentation = calculateFragmentation(files, domain, {
+      ...options,
+      sharedImportRatio
+    });
+    let totalCohesion = 0;
+    let totalAdjustedFragmentation = 0;
+    files.forEach((f) => {
+      const node = graph.nodes.get(f);
+      if (node) {
+        const cohesion = calculateEnhancedCohesion(node.exports);
+        totalCohesion += cohesion;
+        const classification = classifyFile(node, cohesion);
+        totalAdjustedFragmentation += adjustFragmentationForClassification(
+          rawFragmentation,
+          classification
+        );
+      }
+    });
+    const avgCohesion = totalCohesion / files.length;
+    const fragmentationScore = totalAdjustedFragmentation / files.length;
+    clusters.push({
+      domain,
+      files,
+      totalTokens,
+      fragmentationScore,
+      avgCohesion,
+      suggestedStructure: generateSuggestedStructure(
+        files,
+        totalTokens,
+        fragmentationScore
+      )
+    });
+  }
+  return clusters;
+}
+
 // src/remediation.ts
 function getClassificationRecommendations(classification, file, issues) {
   switch (classification) {
@@ -1426,6 +1477,11 @@ function getClassificationRecommendations(classification, file, issues) {
         "Next.js App Router page detected - metadata/JSON-LD/component pattern is cohesive",
         "Multiple exports (metadata, faqJsonLd, default) serve single page purpose"
       ];
+    case "spoke-module":
+      return [
+        "Spoke module detected - intentional monorepo separation is good for modularity",
+        "Ensure this spoke only exports what is necessary for the hub or other spokes"
+      ];
     case "mixed-concerns":
       return [
         "Consider splitting this file by domain",
@@ -1482,7 +1538,79 @@ function getGeneralRecommendations(metrics, thresholds) {
   return { recommendations, issues, severity };
 }
 
-// src/analyzer.ts
+// src/mapper.ts
+function mapNodeToResult(node, graph, clusters, allCircularDeps, options) {
+  const file = node.file;
+  const tokenCost = node.tokenCost;
+  const importDepth = calculateImportDepth(file, graph);
+  const transitiveDeps = getTransitiveDependencies(file, graph);
+  const contextBudget = calculateContextBudget(file, graph);
+  const circularDeps = allCircularDeps.filter((cycle) => cycle.includes(file));
+  const cluster = clusters.find((c) => c.files.includes(file));
+  const rawFragmentationScore = cluster ? cluster.fragmentationScore : 0;
+  const rawCohesionScore = calculateEnhancedCohesion(
+    node.exports,
+    file,
+    options
+  );
+  const fileClassification = classifyFile(node, rawCohesionScore);
+  const cohesionScore = adjustCohesionForClassification(
+    rawCohesionScore,
+    fileClassification
+  );
+  const fragmentationScore = adjustFragmentationForClassification(
+    rawFragmentationScore,
+    fileClassification
+  );
+  const { severity, issues, recommendations, potentialSavings } = analyzeIssues(
+    {
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore,
+      fragmentationScore,
+      maxDepth: options.maxDepth,
+      maxContextBudget: options.maxContextBudget,
+      minCohesion: options.minCohesion,
+      maxFragmentation: options.maxFragmentation,
+      circularDeps
+    }
+  );
+  const classRecs = getClassificationRecommendations(
+    fileClassification,
+    file,
+    issues
+  );
+  const allRecommendations = Array.from(
+    /* @__PURE__ */ new Set([...recommendations, ...classRecs])
+  );
+  return {
+    file,
+    tokenCost,
+    linesOfCode: node.linesOfCode,
+    importDepth,
+    dependencyCount: transitiveDeps.length,
+    dependencyList: transitiveDeps,
+    circularDeps,
+    cohesionScore,
+    domains: Array.from(
+      new Set(
+        node.exports.flatMap((e) => e.domains?.map((d) => d.domain) || [])
+      )
+    ),
+    exportCount: node.exports.length,
+    contextBudget,
+    fragmentationScore,
+    relatedFiles: cluster ? cluster.files : [],
+    fileClassification,
+    severity,
+    issues,
+    recommendations: allRecommendations,
+    potentialSavings
+  };
+}
+
+// src/orchestrator.ts
 function calculateCohesion(exports2, filePath, options) {
   return calculateEnhancedCohesion(exports2, filePath, options);
 }
@@ -1535,10 +1663,8 @@ async function analyzeContext(options) {
         file: metric.file,
         tokenCost: 0,
         linesOfCode: 0,
-        // Not provided by python context yet
         importDepth: metric.importDepth,
         dependencyCount: 0,
-        // Not provided
         dependencyList: [],
         circularDeps: [],
         cohesionScore: metric.cohesion,
@@ -1558,76 +1684,12 @@ async function analyzeContext(options) {
   const clusters = detectModuleClusters(graph);
   const allCircularDeps = detectCircularDependencies(graph);
   const results = Array.from(graph.nodes.values()).map(
-    (node) => {
-      const file = node.file;
-      const tokenCost = node.tokenCost;
-      const importDepth = calculateImportDepth(file, graph);
-      const transitiveDeps = getTransitiveDependencies(file, graph);
-      const contextBudget = calculateContextBudget(file, graph);
-      const circularDeps = allCircularDeps.filter(
-        (cycle) => cycle.includes(file)
-      );
-      const cluster = clusters.find((c) => c.files.includes(file));
-      const rawFragmentationScore = cluster ? cluster.fragmentationScore : 0;
-      const rawCohesionScore = calculateEnhancedCohesion(
-        node.exports,
-        file,
-        options
-      );
-      const fileClassification = classifyFile(node, rawCohesionScore);
-      const cohesionScore = adjustCohesionForClassification(
-        rawCohesionScore,
-        fileClassification
-      );
-      const fragmentationScore = adjustFragmentationForClassification(
-        rawFragmentationScore,
-        fileClassification
-      );
-      const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
-        file,
-        importDepth,
-        contextBudget,
-        cohesionScore,
-        fragmentationScore,
-        maxDepth,
-        maxContextBudget,
-        minCohesion,
-        maxFragmentation,
-        circularDeps
-      });
-      const classRecs = getClassificationRecommendations(
-        fileClassification,
-        file,
-        issues
-      );
-      const allRecommendations = Array.from(
-        /* @__PURE__ */ new Set([...recommendations, ...classRecs])
-      );
-      return {
-        file,
-        tokenCost,
-        linesOfCode: node.linesOfCode,
-        importDepth,
-        dependencyCount: transitiveDeps.length,
-        dependencyList: transitiveDeps,
-        circularDeps,
-        cohesionScore,
-        domains: Array.from(
-          new Set(
-            node.exports.flatMap((e) => e.domains?.map((d) => d.domain) || [])
-          )
-        ),
-        exportCount: node.exports.length,
-        contextBudget,
-        fragmentationScore,
-        relatedFiles: cluster ? cluster.files : [],
-        fileClassification,
-        severity,
-        issues,
-        recommendations: allRecommendations,
-        potentialSavings
-      };
-    }
+    (node) => mapNodeToResult(node, graph, clusters, allCircularDeps, {
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation
+    })
   );
   return [...results, ...pythonResults];
 }