@aiready/context-analyzer 0.19.18 → 0.19.21

package/dist/cli.js

@@ -37,7 +37,7 @@ __export(python_context_exports, {
 });
 async function analyzePythonContext(files, rootDir) {
   const results = [];
-  const parser = (0, import_core9.getParser)("dummy.py");
+  const parser = (0, import_core5.getParser)("dummy.py");
   if (!parser) {
     console.warn("Python parser not available");
     return results;
@@ -101,7 +101,7 @@ async function analyzePythonContext(files, rootDir) {
 }
 async function buildPythonDependencyGraph(files, rootDir) {
   const graph = /* @__PURE__ */ new Map();
-  const parser = (0, import_core9.getParser)("dummy.py");
+  const parser = (0, import_core5.getParser)("dummy.py");
   if (!parser) return graph;
   for (const file of files) {
     try {
@@ -181,7 +181,7 @@ async function calculatePythonImportDepth(file, dependencyGraph, visited, depth
 }
 function estimateContextBudget(code, imports, dependencyGraph) {
   void dependencyGraph;
-  let budget = (0, import_core9.estimateTokens)(code);
+  let budget = (0, import_core5.estimateTokens)(code);
   const avgTokensPerDep = 500;
   budget += imports.length * avgTokensPerDep;
   return budget;
@@ -231,11 +231,11 @@ function detectCircularDependencies2(file, dependencyGraph) {
   dfs(file, []);
   return [...new Set(circular)];
 }
-var import_core9, import_path, import_fs;
+var import_core5, import_path, import_fs;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
     "use strict";
-    import_core9 = require("@aiready/core");
+    import_core5 = require("@aiready/core");
     import_path = require("path");
     import_fs = __toESM(require("fs"));
   }
@@ -247,8 +247,11 @@ var import_commander = require("commander");
 // src/index.ts
 var import_core10 = require("@aiready/core");
 
+// src/provider.ts
+var import_core8 = require("@aiready/core");
+
 // src/analyzer.ts
-var import_core4 = require("@aiready/core");
+var import_core6 = require("@aiready/core");
 
 // src/metrics.ts
 var import_core2 = require("@aiready/core");
@@ -610,8 +613,143 @@ function calculateDirectoryDistance(files) {
   return comparisons > 0 ? totalNormalized / comparisons : 0;
 }
 
-// src/graph-builder.ts
+// src/summary.ts
 var import_core3 = require("@aiready/core");
+function generateSummary(results, options) {
+  const config = options ? Object.fromEntries(
+    Object.entries(options).filter(
+      ([key]) => !import_core3.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
+    )
+  ) : void 0;
+  if (results.length === 0) {
+    return {
+      totalFiles: 0,
+      totalTokens: 0,
+      avgContextBudget: 0,
+      maxContextBudget: 0,
+      avgImportDepth: 0,
+      maxImportDepth: 0,
+      deepFiles: [],
+      avgFragmentation: 0,
+      fragmentedModules: [],
+      avgCohesion: 0,
+      lowCohesionFiles: [],
+      criticalIssues: 0,
+      majorIssues: 0,
+      minorIssues: 0,
+      totalPotentialSavings: 0,
+      topExpensiveFiles: [],
+      config
+    };
+  }
+  const totalFiles = results.length;
+  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
+  const totalContextBudget = results.reduce(
+    (sum, r) => sum + r.contextBudget,
+    0
+  );
+  const avgContextBudget = totalContextBudget / totalFiles;
+  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
+  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
+  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
+  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
+  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    for (const domain of result.domains) {
+      if (!moduleMap.has(domain)) moduleMap.set(domain, []);
+      moduleMap.get(domain).push(result);
+    }
+  }
+  const fragmentedModules = [];
+  for (const [domain, files] of moduleMap.entries()) {
+    let jaccard2 = function(a, b) {
+      const s1 = new Set(a || []);
+      const s2 = new Set(b || []);
+      if (s1.size === 0 && s2.size === 0) return 0;
+      const inter = new Set([...s1].filter((x) => s2.has(x)));
+      const uni = /* @__PURE__ */ new Set([...s1, ...s2]);
+      return uni.size === 0 ? 0 : inter.size / uni.size;
+    };
+    var jaccard = jaccard2;
+    if (files.length < 2) continue;
+    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
+    if (fragmentationScore < 0.3) continue;
+    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
+    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
+    const filePaths = files.map((f) => f.file);
+    const pathEntropy = calculatePathEntropy(filePaths);
+    const directoryDistance = calculateDirectoryDistance(filePaths);
+    let importSimTotal = 0;
+    let importPairs = 0;
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        importSimTotal += jaccard2(
+          files[i].dependencyList || [],
+          files[j].dependencyList || []
+        );
+        importPairs++;
+      }
+    }
+    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
+    fragmentedModules.push({
+      domain,
+      files: files.map((f) => f.file),
+      totalTokens: totalTokens2,
+      fragmentationScore,
+      avgCohesion: avgCohesion2,
+      importCohesion,
+      pathEntropy,
+      directoryDistance,
+      suggestedStructure: {
+        targetFiles,
+        consolidationPlan: [
+          `Consolidate ${files.length} files across ${new Set(files.map((f) => f.file.split("/").slice(0, -1).join("/"))).size} directories`,
+          `Target ~${targetFiles} core modules to reduce context switching`
+        ]
+      }
+    });
+  }
+  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
+  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.4).map((r) => ({ file: r.file, score: r.cohesionScore })).sort((a, b) => a.score - b.score).slice(0, 10);
+  const criticalIssues = results.filter(
+    (r) => r.severity === "critical"
+  ).length;
+  const majorIssues = results.filter((r) => r.severity === "major").length;
+  const minorIssues = results.filter((r) => r.severity === "minor").length;
+  const totalPotentialSavings = results.reduce(
+    (sum, r) => sum + r.potentialSavings,
+    0
+  );
+  const topExpensiveFiles = results.sort((a, b) => b.contextBudget - a.contextBudget).slice(0, 10).map((r) => ({
+    file: r.file,
+    contextBudget: r.contextBudget,
+    severity: r.severity
+  }));
+  return {
+    totalFiles,
+    totalTokens,
+    avgContextBudget,
+    maxContextBudget,
+    avgImportDepth,
+    maxImportDepth,
+    deepFiles,
+    avgFragmentation,
+    fragmentedModules,
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles,
+    config
+  };
+}
+
+// src/graph-builder.ts
+var import_core4 = require("@aiready/core");
 function extractDomainKeywordsFromPaths(files) {
   const folderNames = /* @__PURE__ */ new Set();
   for (const { file } of files) {
@@ -663,7 +801,7 @@ function buildDependencyGraph(files, options) {
   const edges = /* @__PURE__ */ new Map();
   const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
   for (const { file, content } of files) {
-    const { imports: astImports } = (0, import_core3.parseFileExports)(content, file);
+    const { imports: astImports } = (0, import_core4.parseFileExports)(content, file);
     const importSources = astImports.map((i) => i.source);
     const exports2 = extractExportsWithAST(
       content,
@@ -671,7 +809,7 @@ function buildDependencyGraph(files, options) {
       { domainKeywords: autoDetectedKeywords },
       importSources
     );
-    const tokenCost = (0, import_core3.estimateTokens)(content);
+    const tokenCost = (0, import_core4.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
     nodes.set(file, {
       file,
@@ -778,48 +916,62 @@ function detectCircularDependencies(graph) {
 }
 
 // src/classifier.ts
+var Classification = {
+  BARREL: "barrel-export",
+  TYPE_DEFINITION: "type-definition",
+  NEXTJS_PAGE: "nextjs-page",
+  LAMBDA_HANDLER: "lambda-handler",
+  SERVICE: "service-file",
+  EMAIL_TEMPLATE: "email-template",
+  PARSER: "parser-file",
+  COHESIVE_MODULE: "cohesive-module",
+  UTILITY_MODULE: "utility-module",
+  MIXED_CONCERNS: "mixed-concerns",
+  UNKNOWN: "unknown"
+};
 function classifyFile(node, cohesionScore = 1, domains = []) {
   if (isBarrelExport(node)) {
-    return "barrel-export";
+    return Classification.BARREL;
   }
   if (isTypeDefinition(node)) {
-    return "type-definition";
+    return Classification.TYPE_DEFINITION;
   }
   if (isNextJsPage(node)) {
-    return "nextjs-page";
+    return Classification.NEXTJS_PAGE;
   }
   if (isLambdaHandler(node)) {
-    return "lambda-handler";
+    return Classification.LAMBDA_HANDLER;
   }
   if (isServiceFile(node)) {
-    return "service-file";
+    return Classification.SERVICE;
   }
   if (isEmailTemplate(node)) {
-    return "email-template";
+    return Classification.EMAIL_TEMPLATE;
   }
   if (isParserFile(node)) {
-    return "parser-file";
+    return Classification.PARSER;
   }
   if (isSessionFile(node)) {
-    if (cohesionScore >= 0.25 && domains.length <= 1) return "cohesive-module";
-    return "utility-module";
+    if (cohesionScore >= 0.25 && domains.length <= 1)
+      return Classification.COHESIVE_MODULE;
+    return Classification.UTILITY_MODULE;
   }
   if (isUtilityModule(node)) {
-    return "utility-module";
+    return Classification.UTILITY_MODULE;
   }
   if (isConfigFile(node)) {
-    return "cohesive-module";
+    return Classification.COHESIVE_MODULE;
   }
   if (domains.length <= 1 && domains[0] !== "unknown") {
-    return "cohesive-module";
+    return Classification.COHESIVE_MODULE;
   }
   if (domains.length > 1 && cohesionScore < 0.4) {
-    return "mixed-concerns";
+    return Classification.MIXED_CONCERNS;
   }
   if (cohesionScore >= 0.7) {
-    return "cohesive-module";
+    return Classification.COHESIVE_MODULE;
   }
-  return "unknown";
+  return Classification.UNKNOWN;
 }
 function isBarrelExport(node) {
   const { file, exports: exports2 } = node;
@@ -982,13 +1134,13 @@ function isNextJsPage(node) {
 }
 function adjustCohesionForClassification(baseCohesion, classification, node) {
   switch (classification) {
-    case "barrel-export":
+    case Classification.BARREL:
       return 1;
-    case "type-definition":
+    case Classification.TYPE_DEFINITION:
       return 1;
-    case "nextjs-page":
+    case Classification.NEXTJS_PAGE:
       return 1;
-    case "utility-module": {
+    case Classification.UTILITY_MODULE: {
       if (node && hasRelatedExportNames(
         (node.exports || []).map((e) => e.name.toLowerCase())
       )) {
@@ -996,17 +1148,17 @@ function adjustCohesionForClassification(baseCohesion, classification, node) {
       }
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
     }
-    case "service-file":
+    case Classification.SERVICE:
       return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
-    case "lambda-handler":
+    case Classification.LAMBDA_HANDLER:
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
-    case "email-template":
+    case Classification.EMAIL_TEMPLATE:
       return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
-    case "parser-file":
+    case Classification.PARSER:
       return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
-    case "cohesive-module":
+    case Classification.COHESIVE_MODULE:
       return Math.max(baseCohesion, 0.7);
-    case "mixed-concerns":
+    case Classification.MIXED_CONCERNS:
       return baseCohesion;
     default:
       return Math.min(1, baseCohesion + 0.1);
@@ -1055,20 +1207,20 @@ function hasRelatedExportNames(exportNames) {
 }
 function adjustFragmentationForClassification(baseFragmentation, classification) {
   switch (classification) {
-    case "barrel-export":
+    case Classification.BARREL:
       return 0;
-    case "type-definition":
+    case Classification.TYPE_DEFINITION:
       return 0;
-    case "utility-module":
-    case "service-file":
-    case "lambda-handler":
-    case "email-template":
-    case "parser-file":
-    case "nextjs-page":
+    case Classification.UTILITY_MODULE:
+    case Classification.SERVICE:
+    case Classification.LAMBDA_HANDLER:
+    case Classification.EMAIL_TEMPLATE:
+    case Classification.PARSER:
+    case Classification.NEXTJS_PAGE:
       return baseFragmentation * 0.2;
-    case "cohesive-module":
+    case Classification.COHESIVE_MODULE:
       return baseFragmentation * 0.3;
-    case "mixed-concerns":
+    case Classification.MIXED_CONCERNS:
       return baseFragmentation;
     default:
       return baseFragmentation * 0.7;
@@ -1234,10 +1386,10 @@ function analyzeIssues(params) {
   } = params;
   const issues = [];
   const recommendations = [];
-  let severity = import_core4.Severity.Info;
+  let severity = import_core6.Severity.Info;
   let potentialSavings = 0;
   if (circularDeps.length > 0) {
-    severity = import_core4.Severity.Critical;
+    severity = import_core6.Severity.Critical;
     issues.push(`Part of ${circularDeps.length} circular dependency chain(s)`);
     recommendations.push(
       "Break circular dependencies by extracting interfaces or using dependency injection"
@@ -1245,12 +1397,12 @@ function analyzeIssues(params) {
     potentialSavings += contextBudget * 0.2;
   }
   if (importDepth > maxDepth * 1.5) {
-    severity = import_core4.Severity.Critical;
+    severity = import_core6.Severity.Critical;
     issues.push(`Import depth ${importDepth} exceeds limit by 50%`);
     recommendations.push("Flatten dependency tree or use facade pattern");
     potentialSavings += contextBudget * 0.3;
   } else if (importDepth > maxDepth) {
-    if (severity !== import_core4.Severity.Critical) severity = import_core4.Severity.Major;
+    if (severity !== import_core6.Severity.Critical) severity = import_core6.Severity.Major;
     issues.push(
       `Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`
     );
@@ -1258,7 +1410,7 @@ function analyzeIssues(params) {
     potentialSavings += contextBudget * 0.15;
   }
   if (contextBudget > maxContextBudget * 1.5) {
-    severity = import_core4.Severity.Critical;
+    severity = import_core6.Severity.Critical;
     issues.push(
       `Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
     );
@@ -1267,7 +1419,7 @@ function analyzeIssues(params) {
     );
     potentialSavings += contextBudget * 0.4;
   } else if (contextBudget > maxContextBudget) {
-    if (severity !== import_core4.Severity.Critical) severity = import_core4.Severity.Major;
+    if (severity !== import_core6.Severity.Critical) severity = import_core6.Severity.Major;
     issues.push(
       `Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
     );
@@ -1275,7 +1427,7 @@ function analyzeIssues(params) {
     potentialSavings += contextBudget * 0.2;
   }
   if (cohesionScore < minCohesion * 0.5) {
-    if (severity !== import_core4.Severity.Critical) severity = import_core4.Severity.Major;
+    if (severity !== import_core6.Severity.Critical) severity = import_core6.Severity.Major;
     issues.push(
       `Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`
     );
@@ -1284,14 +1436,14 @@ function analyzeIssues(params) {
     );
     potentialSavings += contextBudget * 0.25;
   } else if (cohesionScore < minCohesion) {
-    if (severity === import_core4.Severity.Info) severity = import_core4.Severity.Minor;
+    if (severity === import_core6.Severity.Info) severity = import_core6.Severity.Minor;
     issues.push(`Low cohesion (${(cohesionScore * 100).toFixed(0)}%)`);
     recommendations.push("Consider grouping related exports together");
     potentialSavings += contextBudget * 0.1;
   }
   if (fragmentationScore > maxFragmentation) {
-    if (severity === import_core4.Severity.Info || severity === import_core4.Severity.Minor)
-      severity = import_core4.Severity.Minor;
+    if (severity === import_core6.Severity.Info || severity === import_core6.Severity.Minor)
+      severity = import_core6.Severity.Minor;
     issues.push(
       `High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`
     );
@@ -1305,7 +1457,7 @@ function analyzeIssues(params) {
   if (isBuildArtifact(file)) {
     issues.push("Detected build artifact (bundled/output file)");
     recommendations.push("Exclude build outputs from analysis");
-    severity = import_core4.Severity.Info;
+    severity = import_core6.Severity.Info;
     potentialSavings = 0;
   }
   return {
@@ -1319,147 +1471,192 @@ function isBuildArtifact(filePath) {
   const lower = filePath.toLowerCase();
   return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/.next/");
 }
-
-// src/summary.ts
-var import_core5 = require("@aiready/core");
-function generateSummary(results, options) {
-  const config = options ? Object.fromEntries(
-    Object.entries(options).filter(
-      ([key]) => !import_core5.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
-    )
-  ) : void 0;
-  if (results.length === 0) {
-    return {
-      totalFiles: 0,
-      totalTokens: 0,
-      avgContextBudget: 0,
-      maxContextBudget: 0,
-      avgImportDepth: 0,
-      maxImportDepth: 0,
-      deepFiles: [],
-      avgFragmentation: 0,
-      fragmentedModules: [],
-      avgCohesion: 0,
-      lowCohesionFiles: [],
-      criticalIssues: 0,
-      majorIssues: 0,
-      minorIssues: 0,
-      totalPotentialSavings: 0,
-      topExpensiveFiles: [],
-      config
-    };
-  }
-  const totalFiles = results.length;
-  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
-  const totalContextBudget = results.reduce(
-    (sum, r) => sum + r.contextBudget,
-    0
+async function analyzeContext(options) {
+  const {
+    maxDepth = 5,
+    maxContextBudget = 1e4,
+    minCohesion = 0.6,
+    maxFragmentation = 0.5,
+    focus = "all",
+    includeNodeModules = false,
+    ...scanOptions
+  } = options;
+  const files = await (0, import_core6.scanFiles)({
+    ...scanOptions,
+    exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter(
+      (pattern) => pattern !== "**/node_modules/**"
+    ) : scanOptions.exclude
+  });
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await (0, import_core6.readFileContent)(file)
+    }))
   );
-  const avgContextBudget = totalContextBudget / totalFiles;
-  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
-  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
-  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
-  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
-  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
-  const moduleMap = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    for (const domain of result.domains) {
-      if (!moduleMap.has(domain)) moduleMap.set(domain, []);
-      moduleMap.get(domain).push(result);
-    }
-  }
-  const fragmentedModules = [];
-  for (const [domain, files] of moduleMap.entries()) {
-    let jaccard2 = function(a, b) {
-      const s1 = new Set(a || []);
-      const s2 = new Set(b || []);
-      if (s1.size === 0 && s2.size === 0) return 0;
-      const inter = new Set([...s1].filter((x) => s2.has(x)));
-      const uni = /* @__PURE__ */ new Set([...s1, ...s2]);
-      return uni.size === 0 ? 0 : inter.size / uni.size;
-    };
-    var jaccard = jaccard2;
-    if (files.length < 2) continue;
-    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
-    if (fragmentationScore < 0.3) continue;
-    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
-    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
-    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
-    const filePaths = files.map((f) => f.file);
-    const pathEntropy = calculatePathEntropy(filePaths);
-    const directoryDistance = calculateDirectoryDistance(filePaths);
-    let importSimTotal = 0;
-    let importPairs = 0;
-    for (let i = 0; i < files.length; i++) {
-      for (let j = i + 1; j < files.length; j++) {
-        importSimTotal += jaccard2(
-          files[i].dependencyList || [],
-          files[j].dependencyList || []
-        );
-        importPairs++;
+  const graph = buildDependencyGraph(
+    fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py"))
+  );
+  let pythonResults = [];
+  if (pythonFiles.length > 0) {
+    const { analyzePythonContext: analyzePythonContext2 } = await Promise.resolve().then(() => (init_python_context(), python_context_exports));
+    const pythonMetrics = await analyzePythonContext2(
+      pythonFiles,
+      scanOptions.rootDir || options.rootDir || "."
+    );
+    pythonResults = pythonMetrics.map((metric) => {
+      const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
+        file: metric.file,
+        importDepth: metric.importDepth,
+        contextBudget: metric.contextBudget,
+        cohesionScore: metric.cohesion,
+        fragmentationScore: 0,
+        maxDepth,
+        maxContextBudget,
+        minCohesion,
+        maxFragmentation,
+        circularDeps: metric.metrics.circularDependencies.map(
+          (cycle) => cycle.split(" \u2192 ")
+        )
+      });
+      return {
+        file: metric.file,
+        tokenCost: Math.floor(
+          metric.contextBudget / (1 + metric.imports.length || 1)
+        ),
+        linesOfCode: metric.metrics.linesOfCode,
+        importDepth: metric.importDepth,
+        dependencyCount: metric.imports.length,
+        dependencyList: metric.imports.map(
+          (imp) => imp.resolvedPath || imp.source
+        ),
+        circularDeps: metric.metrics.circularDependencies.map(
+          (cycle) => cycle.split(" \u2192 ")
+        ),
+        cohesionScore: metric.cohesion,
+        domains: ["python"],
+        exportCount: metric.exports.length,
+        contextBudget: metric.contextBudget,
+        fragmentationScore: 0,
+        relatedFiles: [],
+        fileClassification: "unknown",
+        severity,
+        issues,
+        recommendations,
+        potentialSavings
+      };
+    });
+  }
+  const circularDeps = detectCircularDependencies(graph);
+  const useLogScale = files.length >= 500;
+  const clusters = detectModuleClusters(graph, { useLogScale });
+  const fragmentationMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const file of cluster.files) {
+      fragmentationMap.set(file, cluster.fragmentationScore);
+    }
+  }
+  const results = [];
+  for (const { file } of fileContents) {
+    const node = graph.nodes.get(file);
+    if (!node) continue;
+    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, {
+      coUsageMatrix: graph.coUsageMatrix
+    }) : 1;
+    const fragmentationScore = fragmentationMap.get(file) || 0;
+    const relatedFiles = [];
+    for (const cluster of clusters) {
+      if (cluster.files.includes(file)) {
+        relatedFiles.push(...cluster.files.filter((f) => f !== file));
+        break;
       }
     }
-    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
-    fragmentedModules.push({
-      domain,
-      files: files.map((f) => f.file),
-      totalTokens: totalTokens2,
+    const { issues } = analyzeIssues({
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore,
       fragmentationScore,
-      avgCohesion: avgCohesion2,
-      importCohesion,
-      pathEntropy,
-      directoryDistance,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan: [
-          `Consolidate ${files.length} files across ${new Set(files.map((f) => f.file.split("/").slice(0, -1).join("/"))).size} directories`,
-          `Target ~${targetFiles} core modules to reduce context switching`
-        ]
-      }
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation,
+      circularDeps
+    });
+    const domains = [
+      ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
+    ];
+    const fileClassification = classifyFile(node);
+    const adjustedCohesionScore = adjustCohesionForClassification(
+      cohesionScore,
+      fileClassification,
+      node
+    );
+    const adjustedFragmentationScore = adjustFragmentationForClassification(
+      fragmentationScore,
+      fileClassification
+    );
+    const classificationRecommendations = getClassificationRecommendations(
+      fileClassification,
+      file,
+      issues
+    );
+    const {
+      severity: adjustedSeverity,
+      issues: adjustedIssues,
+      recommendations: finalRecommendations,
+      potentialSavings: adjustedSavings
+    } = analyzeIssues({
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore: adjustedCohesionScore,
+      fragmentationScore: adjustedFragmentationScore,
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation,
+      circularDeps
+    });
+    results.push({
+      file,
+      tokenCost: node.tokenCost,
+      linesOfCode: node.linesOfCode,
+      importDepth,
+      dependencyCount: dependencyList.length,
+      dependencyList,
+      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
+      cohesionScore: adjustedCohesionScore,
+      domains,
+      exportCount: node.exports.length,
+      contextBudget,
+      fragmentationScore: adjustedFragmentationScore,
+      relatedFiles,
+      fileClassification,
+      severity: adjustedSeverity,
+      issues: adjustedIssues,
+      recommendations: [
+        ...finalRecommendations,
+        ...classificationRecommendations.slice(0, 1)
+      ],
+      potentialSavings: adjustedSavings
     });
   }
-  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
-  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.4).map((r) => ({ file: r.file, score: r.cohesionScore })).sort((a, b) => a.score - b.score).slice(0, 10);
-  const criticalIssues = results.filter(
-    (r) => r.severity === "critical"
-  ).length;
-  const majorIssues = results.filter((r) => r.severity === "major").length;
-  const minorIssues = results.filter((r) => r.severity === "minor").length;
-  const totalPotentialSavings = results.reduce(
-    (sum, r) => sum + r.potentialSavings,
-    0
-  );
-  const topExpensiveFiles = results.sort((a, b) => b.contextBudget - a.contextBudget).slice(0, 10).map((r) => ({
-    file: r.file,
-    contextBudget: r.contextBudget,
-    severity: r.severity
-  }));
-  return {
-    totalFiles,
-    totalTokens,
-    avgContextBudget,
-    maxContextBudget,
-    avgImportDepth,
-    maxImportDepth,
-    deepFiles,
-    avgFragmentation,
-    fragmentedModules,
-    avgCohesion,
-    lowCohesionFiles,
-    criticalIssues,
-    majorIssues,
-    minorIssues,
-    totalPotentialSavings,
-    topExpensiveFiles,
-    config
-  };
+  const allResults = [...results, ...pythonResults];
+  const finalSummary = generateSummary(allResults, options);
+  return allResults.sort((a, b) => {
+    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
+    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
+    if (severityDiff !== 0) return severityDiff;
+    return b.contextBudget - a.contextBudget;
+  });
 }
 
-// src/provider.ts
-var import_core7 = require("@aiready/core");
-
 // src/scoring.ts
-var import_core6 = require("@aiready/core");
+var import_core7 = require("@aiready/core");
 function calculateContextScore(summary, costConfig) {
   const {
     avgContextBudget,
@@ -1555,8 +1752,8 @@ function calculateContextScore(summary, costConfig) {
       priority: "high"
     });
   }
-  const cfg = { ...import_core6.DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = (0, import_core6.calculateMonthlyCost)(
+  const cfg = { ...import_core7.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core7.calculateMonthlyCost)(
     avgContextBudget * (summary.totalFiles || 1),
     cfg
   );
@@ -1564,9 +1761,9 @@ function calculateContextScore(summary, costConfig) {
     ...Array(criticalIssues).fill({ severity: "critical" }),
     ...Array(majorIssues).fill({ severity: "major" })
   ];
-  const productivityImpact = (0, import_core6.calculateProductivityImpact)(issues);
+  const productivityImpact = (0, import_core7.calculateProductivityImpact)(issues);
   return {
-    toolName: import_core6.ToolName.ContextAnalyzer,
+    toolName: import_core7.ToolName.ContextAnalyzer,
     score,
     rawMetrics: {
       avgContextBudget: Math.round(avgContextBudget),
@@ -1586,7 +1783,7 @@ function calculateContextScore(summary, costConfig) {
 
 // src/provider.ts
 var ContextAnalyzerProvider = {
-  id: import_core7.ToolName.ContextAnalyzer,
+  id: import_core8.ToolName.ContextAnalyzer,
   alias: ["context", "fragmentation", "budget"],
   async analyze(options) {
     const results = await analyzeContext(options);
@@ -1595,7 +1792,7 @@ var ContextAnalyzerProvider = {
       (r) => ({
         fileName: r.file,
         issues: r.issues.map((msg) => ({
-          type: import_core7.IssueType.ContextFragmentation,
+          type: import_core8.IssueType.ContextFragmentation,
           severity: r.severity,
           message: msg,
           location: { file: r.file, line: 1 },
@@ -1608,13 +1805,13 @@ var ContextAnalyzerProvider = {
         }
       })
     );
-    return import_core7.SpokeOutputSchema.parse({
+    return import_core8.SpokeOutputSchema.parse({
       results: normalizedResults,
       summary: {
         ...summary
       },
       metadata: {
-        toolName: import_core7.ToolName.ContextAnalyzer,
+        toolName: import_core8.ToolName.ContextAnalyzer,
         version: "0.17.5",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }
@@ -1628,193 +1825,10 @@ var ContextAnalyzerProvider = {
 };
 
 // src/defaults.ts
-var import_core8 = require("@aiready/core");
+var import_core9 = require("@aiready/core");
 
 // src/index.ts
 import_core10.ToolRegistry.register(ContextAnalyzerProvider);
-async function analyzeContext(options) {
-  const {
-    maxDepth = 5,
-    maxContextBudget = 1e4,
-    minCohesion = 0.6,
-    maxFragmentation = 0.5,
-    focus = "all",
-    includeNodeModules = false,
-    ...scanOptions
-  } = options;
-  const files = await (0, import_core10.scanFiles)({
-    ...scanOptions,
-    exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter(
-      (pattern) => pattern !== "**/node_modules/**"
-    ) : scanOptions.exclude
-  });
-  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
-  const fileContents = await Promise.all(
-    files.map(async (file) => ({
-      file,
-      content: await (0, import_core10.readFileContent)(file)
-    }))
-  );
-  const graph = buildDependencyGraph(
-    fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py"))
-  );
-  let pythonResults = [];
-  if (pythonFiles.length > 0) {
-    const { analyzePythonContext: analyzePythonContext2 } = await Promise.resolve().then(() => (init_python_context(), python_context_exports));
-    const pythonMetrics = await analyzePythonContext2(
-      pythonFiles,
-      scanOptions.rootDir || options.rootDir || "."
-    );
-    pythonResults = pythonMetrics.map((metric) => {
-      const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
-        file: metric.file,
-        importDepth: metric.importDepth,
-        contextBudget: metric.contextBudget,
-        cohesionScore: metric.cohesion,
-        fragmentationScore: 0,
-        maxDepth,
-        maxContextBudget,
-        minCohesion,
-        maxFragmentation,
-        circularDeps: metric.metrics.circularDependencies.map(
-          (cycle) => cycle.split(" \u2192 ")
-        )
-      });
-      return {
-        file: metric.file,
-        tokenCost: Math.floor(
-          metric.contextBudget / (1 + metric.imports.length || 1)
-        ),
-        linesOfCode: metric.metrics.linesOfCode,
-        importDepth: metric.importDepth,
-        dependencyCount: metric.imports.length,
-        dependencyList: metric.imports.map(
-          (imp) => imp.resolvedPath || imp.source
-        ),
-        circularDeps: metric.metrics.circularDependencies.map(
-          (cycle) => cycle.split(" \u2192 ")
-        ),
-        cohesionScore: metric.cohesion,
-        domains: ["python"],
-        exportCount: metric.exports.length,
-        contextBudget: metric.contextBudget,
-        fragmentationScore: 0,
-        relatedFiles: [],
-        fileClassification: "unknown",
-        severity,
-        issues,
-        recommendations,
-        potentialSavings
-      };
-    });
-  }
-  const circularDeps = detectCircularDependencies(graph);
-  const useLogScale = files.length >= 500;
-  const clusters = detectModuleClusters(graph, { useLogScale });
-  const fragmentationMap = /* @__PURE__ */ new Map();
-  for (const cluster of clusters) {
-    for (const file of cluster.files) {
-      fragmentationMap.set(file, cluster.fragmentationScore);
-    }
-  }
-  const results = [];
-  for (const { file } of fileContents) {
-    const node = graph.nodes.get(file);
-    if (!node) continue;
-    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, {
-      coUsageMatrix: graph.coUsageMatrix
-    }) : 1;
-    const fragmentationScore = fragmentationMap.get(file) || 0;
-    const relatedFiles = [];
-    for (const cluster of clusters) {
-      if (cluster.files.includes(file)) {
-        relatedFiles.push(...cluster.files.filter((f) => f !== file));
-        break;
-      }
-    }
-    const { issues } = analyzeIssues({
-      file,
-      importDepth,
-      contextBudget,
-      cohesionScore,
-      fragmentationScore,
-      maxDepth,
-      maxContextBudget,
-      minCohesion,
-      maxFragmentation,
-      circularDeps
-    });
-    const domains = [
-      ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
-    ];
-    const fileClassification = classifyFile(node);
-    const adjustedCohesionScore = adjustCohesionForClassification(
-      cohesionScore,
-      fileClassification,
-      node
-    );
-    const adjustedFragmentationScore = adjustFragmentationForClassification(
-      fragmentationScore,
-      fileClassification
-    );
-    const classificationRecommendations = getClassificationRecommendations(
-      fileClassification,
-      file,
-      issues
-    );
-    const {
-      severity: adjustedSeverity,
-      issues: adjustedIssues,
-      recommendations: finalRecommendations,
-      potentialSavings: adjustedSavings
-    } = analyzeIssues({
-      file,
-      importDepth,
-      contextBudget,
-      cohesionScore: adjustedCohesionScore,
-      fragmentationScore: adjustedFragmentationScore,
-      maxDepth,
-      maxContextBudget,
-      minCohesion,
-      maxFragmentation,
-      circularDeps
-    });
-    results.push({
-      file,
-      tokenCost: node.tokenCost,
-      linesOfCode: node.linesOfCode,
-      importDepth,
-      dependencyCount: dependencyList.length,
-      dependencyList,
-      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
-      cohesionScore: adjustedCohesionScore,
-      domains,
-      exportCount: node.exports.length,
-      contextBudget,
-      fragmentationScore: adjustedFragmentationScore,
-      relatedFiles,
-      fileClassification,
-      severity: adjustedSeverity,
-      issues: adjustedIssues,
-      recommendations: [
-        ...finalRecommendations,
-        ...classificationRecommendations.slice(0, 1)
-      ],
-      potentialSavings: adjustedSavings
-    });
-  }
-  const allResults = [...results, ...pythonResults];
-  const finalSummary = generateSummary(allResults, options);
-  return allResults.sort((a, b) => {
-    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
-    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
-    if (severityDiff !== 0) return severityDiff;
-    return b.contextBudget - a.contextBudget;
-  });
-}
 
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));