@aiready/context-analyzer 0.21.1 → 0.21.6

package/dist/cli.js

@@ -30,6 +30,99 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/utils/dependency-graph-utils.ts
+function calculateImportDepthFromEdges(file, edges, visited = /* @__PURE__ */ new Set(), depth = 0) {
+  if (visited.has(file)) return depth;
+  const dependencies = edges.get(file);
+  if (!dependencies || dependencies.size === 0) return depth;
+  const nextVisited = new Set(visited);
+  nextVisited.add(file);
+  let maxDepth = depth;
+  for (const dep of dependencies) {
+    maxDepth = Math.max(
+      maxDepth,
+      calculateImportDepthFromEdges(dep, edges, nextVisited, depth + 1)
+    );
+  }
+  return maxDepth;
+}
+function getTransitiveDependenciesFromEdges(file, edges, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(file)) return [];
+  const nextVisited = new Set(visited);
+  nextVisited.add(file);
+  const dependencies = edges.get(file);
+  if (!dependencies || dependencies.size === 0) return [];
+  const allDeps = [];
+  for (const dep of dependencies) {
+    allDeps.push(dep);
+    allDeps.push(
+      ...getTransitiveDependenciesFromEdges(dep, edges, nextVisited)
+    );
+  }
+  return [...new Set(allDeps)];
+}
+function detectGraphCycles(edges) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(file, path) {
+    if (recursionStack.has(file)) {
+      const cycleStart = path.indexOf(file);
+      if (cycleStart !== -1) {
+        cycles.push([...path.slice(cycleStart), file]);
+      }
+      return;
+    }
+    if (visited.has(file)) return;
+    visited.add(file);
+    recursionStack.add(file);
+    const dependencies = edges.get(file);
+    if (dependencies) {
+      for (const dep of dependencies) {
+        dfs(dep, [...path, file]);
+      }
+    }
+    recursionStack.delete(file);
+  }
+  for (const file of edges.keys()) {
+    if (!visited.has(file)) {
+      dfs(file, []);
+    }
+  }
+  return cycles;
+}
+function detectGraphCyclesFromFile(file, edges) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(current, path) {
+    if (recursionStack.has(current)) {
+      const cycleStart = path.indexOf(current);
+      if (cycleStart !== -1) {
+        cycles.push([...path.slice(cycleStart), current]);
+      }
+      return;
+    }
+    if (visited.has(current)) return;
+    visited.add(current);
+    recursionStack.add(current);
+    const dependencies = edges.get(current);
+    if (dependencies) {
+      for (const dep of dependencies) {
+        dfs(dep, [...path, current]);
+      }
+    }
+    recursionStack.delete(current);
+  }
+  dfs(file, []);
+  return cycles;
+}
+var init_dependency_graph_utils = __esm({
+  "src/utils/dependency-graph-utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/analyzers/python-context.ts
 var python_context_exports = {};
 __export(python_context_exports, {
@@ -64,7 +157,7 @@ async function analyzePythonContext(files, rootDir) {
         type: exp.type
       }));
       const linesOfCode = code.split("\n").length;
-      const importDepth = await calculatePythonImportDepth(
+      const importDepth = calculateImportDepthFromEdges(
         file,
         dependencyGraph,
         /* @__PURE__ */ new Set()
@@ -75,10 +168,10 @@ async function analyzePythonContext(files, rootDir) {
         dependencyGraph
       );
       const cohesion = calculatePythonCohesion(exports2, imports);
-      const circularDependencies = detectCircularDependencies2(
+      const circularDependencies = detectGraphCyclesFromFile(
         file,
         dependencyGraph
-      );
+      ).map((cycle) => cycle.join(" -> "));
       results.push({
         file,
         importDepth,
@@ -158,27 +251,6 @@ function resolvePythonImport(fromFile, importPath, rootDir) {
   }
   return void 0;
 }
-async function calculatePythonImportDepth(file, dependencyGraph, visited, depth = 0) {
-  if (visited.has(file)) {
-    return depth;
-  }
-  visited.add(file);
-  const dependencies = dependencyGraph.get(file) || /* @__PURE__ */ new Set();
-  if (dependencies.size === 0) {
-    return depth;
-  }
-  let maxDepth = depth;
-  for (const dep of dependencies) {
-    const depDepth = await calculatePythonImportDepth(
-      dep,
-      dependencyGraph,
-      new Set(visited),
-      depth + 1
-    );
-    maxDepth = Math.max(maxDepth, depDepth);
-  }
-  return maxDepth;
-}
 function estimateContextBudget(code, imports, dependencyGraph) {
   void dependencyGraph;
   let budget = (0, import_core5.estimateTokens)(code);
@@ -206,31 +278,6 @@ function calculatePythonCohesion(exports2, imports) {
   }
   return Math.min(1, Math.max(0, cohesion));
 }
-function detectCircularDependencies2(file, dependencyGraph) {
-  const circular = [];
-  const visited = /* @__PURE__ */ new Set();
-  const recursionStack = /* @__PURE__ */ new Set();
-  function dfs(current, path) {
-    if (recursionStack.has(current)) {
-      const cycleStart = path.indexOf(current);
-      const cycle = path.slice(cycleStart).concat([current]);
-      circular.push(cycle.join(" \u2192 "));
-      return;
-    }
-    if (visited.has(current)) {
-      return;
-    }
-    visited.add(current);
-    recursionStack.add(current);
-    const dependencies = dependencyGraph.get(current) || /* @__PURE__ */ new Set();
-    for (const dep of dependencies) {
-      dfs(dep, [...path, current]);
-    }
-    recursionStack.delete(current);
-  }
-  dfs(file, []);
-  return [...new Set(circular)];
-}
 var import_core5, import_path2, import_fs;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
@@ -238,16 +285,14 @@ var init_python_context = __esm({
     import_core5 = require("@aiready/core");
     import_path2 = require("path");
     import_fs = __toESM(require("fs"));
+    init_dependency_graph_utils();
   }
 });
 
 // src/cli.ts
 var import_commander = require("commander");
 
-// src/index.ts
-var import_core10 = require("@aiready/core");
-
-// src/provider.ts
+// src/cli-action.ts
 var import_core8 = require("@aiready/core");
 
 // src/analyzer.ts
@@ -259,6 +304,21 @@ var import_core2 = require("@aiready/core");
 // src/ast-utils.ts
 var import_core = require("@aiready/core");
 
+// src/utils/string-utils.ts
+function singularize(word) {
+  const irregulars = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman"
+  };
+  if (irregulars[word]) return irregulars[word];
+  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
+  if (word.endsWith("ses")) return word.slice(0, -2);
+  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+
 // src/semantic-analysis.ts
 function buildCoUsageMatrix(graph) {
   const coUsageMatrix = /* @__PURE__ */ new Map();
@@ -461,19 +521,6 @@ function inferDomain(name, filePath, domainOptions, fileImports) {
   }
   return "unknown";
 }
-function singularize(word) {
-  const irregulars = {
-    people: "person",
-    children: "child",
-    men: "man",
-    women: "woman"
-  };
-  if (irregulars[word]) return irregulars[word];
-  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
-  if (word.endsWith("ses")) return word.slice(0, -2);
-  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
-  return word;
-}
 
 // src/ast-utils.ts
 function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
@@ -589,167 +636,113 @@ function calculatePathEntropy(files) {
   const maxEntropy = Math.log2(counts.length);
   return maxEntropy > 0 ? entropy / maxEntropy : 0;
 }
-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);
-    let i = 0;
-    while (i < minLen && a[i] === b[i]) i++;
-    return i;
-  };
-  let totalNormalized = 0;
-  let comparisons = 0;
-  for (let i = 0; i < files.length; i++) {
-    for (let j = i + 1; j < files.length; j++) {
-      const segA = pathSegments(files[i]);
-      const segB = pathSegments(files[j]);
-      const shared = commonAncestorDepth(segA, segB);
-      const maxDepth = Math.max(segA.length, segB.length);
-      totalNormalized += 1 - (maxDepth > 0 ? shared / maxDepth : 0);
-      comparisons++;
-    }
-  }
-  return comparisons > 0 ? totalNormalized / comparisons : 0;
-}
 
-// src/summary.ts
+// src/issue-analyzer.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
-    };
+function analyzeIssues(params) {
+  const {
+    file,
+    importDepth,
+    contextBudget,
+    cohesionScore,
+    fragmentationScore,
+    maxDepth,
+    maxContextBudget,
+    minCohesion,
+    maxFragmentation,
+    circularDeps
+  } = params;
+  const issues = [];
+  const recommendations = [];
+  let severity = import_core3.Severity.Info;
+  let potentialSavings = 0;
+  if (circularDeps.length > 0) {
+    severity = import_core3.Severity.Critical;
+    issues.push(`Part of ${circularDeps.length} circular dependency chain(s)`);
+    recommendations.push(
+      "Break circular dependencies by extracting interfaces or using dependency injection"
+    );
+    potentialSavings += contextBudget * 0.2;
   }
-  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);
-    }
+  if (importDepth > maxDepth * 1.5) {
+    severity = import_core3.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_core3.Severity.Critical) severity = import_core3.Severity.Major;
+    issues.push(
+      `Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`
+    );
+    recommendations.push("Consider reducing dependency depth");
+    potentialSavings += contextBudget * 0.15;
   }
-  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`
-        ]
-      }
-    });
+  if (contextBudget > maxContextBudget * 1.5) {
+    severity = import_core3.Severity.Critical;
+    issues.push(
+      `Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
+    );
+    recommendations.push(
+      "Split into smaller modules or reduce dependency tree"
+    );
+    potentialSavings += contextBudget * 0.4;
+  } else if (contextBudget > maxContextBudget) {
+    if (severity !== import_core3.Severity.Critical) severity = import_core3.Severity.Major;
+    issues.push(
+      `Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
+    );
+    recommendations.push("Reduce file size or dependencies");
+    potentialSavings += contextBudget * 0.2;
+  }
+  if (cohesionScore < minCohesion * 0.5) {
+    if (severity !== import_core3.Severity.Critical) severity = import_core3.Severity.Major;
+    issues.push(
+      `Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`
+    );
+    recommendations.push(
+      "Split file by domain - separate unrelated functionality"
+    );
+    potentialSavings += contextBudget * 0.25;
+  } else if (cohesionScore < minCohesion) {
+    if (severity === import_core3.Severity.Info) severity = import_core3.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_core3.Severity.Info || severity === import_core3.Severity.Minor)
+      severity = import_core3.Severity.Minor;
+    issues.push(
+      `High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`
+    );
+    recommendations.push("Consolidate with related files in same domain");
+    potentialSavings += contextBudget * 0.3;
+  }
+  if (issues.length === 0) {
+    issues.push("No significant issues detected");
+    recommendations.push("File is well-structured for AI context usage");
+  }
+  if (isBuildArtifact(file)) {
+    issues.push("Detected build artifact (bundled/output file)");
+    recommendations.push("Exclude build outputs from analysis");
+    severity = import_core3.Severity.Info;
+    potentialSavings = 0;
   }
-  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
+    severity,
+    issues,
+    recommendations,
+    potentialSavings: Math.floor(potentialSavings)
   };
 }
-
-// src/graph-builder.ts
+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/graph-builder.ts
 var import_core4 = require("@aiready/core");
+init_dependency_graph_utils();
 var import_path = require("path");
 function resolveImport(source, importingFile, allFiles) {
   if (!source.startsWith(".") && !source.startsWith("/")) {
@@ -797,25 +790,12 @@ function extractDomainKeywordsFromPaths(files) {
     for (const segment of segments) {
       const normalized = segment.toLowerCase();
       if (normalized && !skipFolders.has(normalized) && !normalized.includes(".")) {
-        folderNames.add(singularize2(normalized));
+        folderNames.add(singularize(normalized));
       }
     }
   }
   return Array.from(folderNames);
 }
-function singularize2(word) {
-  const irregulars = {
-    people: "person",
-    children: "child",
-    men: "man",
-    women: "woman"
-  };
-  if (irregulars[word]) return irregulars[word];
-  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
-  if (word.endsWith("ses")) return word.slice(0, -2);
-  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
-  return word;
-}
 function buildDependencyGraph(files, options) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
@@ -866,31 +846,10 @@ function buildDependencyGraph(files, options) {
   return graph;
 }
 function calculateImportDepth(file, graph, visited = /* @__PURE__ */ new Set(), depth = 0) {
-  if (visited.has(file)) return depth;
-  const dependencies = graph.edges.get(file);
-  if (!dependencies || dependencies.size === 0) return depth;
-  visited.add(file);
-  let maxDepth = depth;
-  for (const dep of dependencies) {
-    maxDepth = Math.max(
-      maxDepth,
-      calculateImportDepth(dep, graph, visited, depth + 1)
-    );
-  }
-  visited.delete(file);
-  return maxDepth;
+  return calculateImportDepthFromEdges(file, graph.edges, visited, depth);
 }
 function getTransitiveDependencies(file, graph, visited = /* @__PURE__ */ new Set()) {
-  if (visited.has(file)) return [];
-  visited.add(file);
-  const dependencies = graph.edges.get(file);
-  if (!dependencies || dependencies.size === 0) return [];
-  const allDeps = [];
-  for (const dep of dependencies) {
-    allDeps.push(dep);
-    allDeps.push(...getTransitiveDependencies(dep, graph, visited));
-  }
-  return [...new Set(allDeps)];
+  return getTransitiveDependenciesFromEdges(file, graph.edges, visited);
 }
 function calculateContextBudget(file, graph) {
   const node = graph.nodes.get(file);
@@ -906,35 +865,79 @@ function calculateContextBudget(file, graph) {
   return totalTokens;
 }
 function detectCircularDependencies(graph) {
-  const cycles = [];
-  const visited = /* @__PURE__ */ new Set();
-  const recursionStack = /* @__PURE__ */ new Set();
-  function dfs(file, path) {
-    if (recursionStack.has(file)) {
-      const cycleStart = path.indexOf(file);
-      if (cycleStart !== -1) {
-        cycles.push([...path.slice(cycleStart), file]);
-      }
-      return;
+  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, []);
     }
-    if (visited.has(file)) return;
-    visited.add(file);
-    recursionStack.add(file);
-    path.push(file);
-    const dependencies = graph.edges.get(file);
-    if (dependencies) {
-      for (const dep of dependencies) {
-        dfs(dep, [...path]);
+    domainMap.get(primaryDomain).push(file);
+  }
+  const clusters = [];
+  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;
     }
-    recursionStack.delete(file);
+    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
+      )
+    });
   }
-  for (const file of graph.nodes.keys()) {
-    if (!visited.has(file)) {
-      dfs(file, []);
-    }
+  return clusters;
+}
+function 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)`
+    );
   }
-  return cycles;
+  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 };
 }
 
 // src/classifier.ts
@@ -1249,78 +1252,6 @@ 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 = [];
-  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]);
-      let 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;
-}
-function 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 };
-}
-
 // src/remediation.ts
 function getClassificationRecommendations(classification, file, issues) {
   switch (classification) {
@@ -1381,150 +1312,37 @@ function getClassificationRecommendations(classification, file, issues) {
 }
 
 // src/analyzer.ts
-function calculateCohesion(exports2, filePath, options) {
-  if (exports2.length <= 1) return 1;
-  if (filePath && isTestFile(filePath)) return 1;
-  const domains = exports2.map((e) => e.inferredDomain || "unknown");
-  const uniqueDomains = new Set(domains.filter((d) => d !== "unknown"));
-  const hasImports = exports2.some((e) => !!e.imports);
-  if (!hasImports && !options?.weights) {
-    if (uniqueDomains.size <= 1) return 1;
-    return 0.4;
-  }
-  return calculateEnhancedCohesion(exports2, filePath, options);
-}
-function analyzeIssues(params) {
+async function analyzeContext(options) {
   const {
-    file,
-    importDepth,
-    contextBudget,
-    cohesionScore,
-    fragmentationScore,
-    maxDepth,
-    maxContextBudget,
-    minCohesion,
-    maxFragmentation,
-    circularDeps
-  } = params;
-  const issues = [];
-  const recommendations = [];
-  let severity = import_core6.Severity.Info;
-  let potentialSavings = 0;
-  if (circularDeps.length > 0) {
-    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"
-    );
-    potentialSavings += contextBudget * 0.2;
-  }
-  if (importDepth > maxDepth * 1.5) {
-    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_core6.Severity.Critical) severity = import_core6.Severity.Major;
-    issues.push(
-      `Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`
-    );
-    recommendations.push("Consider reducing dependency depth");
-    potentialSavings += contextBudget * 0.15;
-  }
-  if (contextBudget > maxContextBudget * 1.5) {
-    severity = import_core6.Severity.Critical;
-    issues.push(
-      `Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
-    );
-    recommendations.push(
-      "Split into smaller modules or reduce dependency tree"
-    );
-    potentialSavings += contextBudget * 0.4;
-  } else if (contextBudget > maxContextBudget) {
-    if (severity !== import_core6.Severity.Critical) severity = import_core6.Severity.Major;
-    issues.push(
-      `Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
-    );
-    recommendations.push("Reduce file size or dependencies");
-    potentialSavings += contextBudget * 0.2;
-  }
-  if (cohesionScore < minCohesion * 0.5) {
-    if (severity !== import_core6.Severity.Critical) severity = import_core6.Severity.Major;
-    issues.push(
-      `Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`
-    );
-    recommendations.push(
-      "Split file by domain - separate unrelated functionality"
-    );
-    potentialSavings += contextBudget * 0.25;
-  } else if (cohesionScore < minCohesion) {
-    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_core6.Severity.Info || severity === import_core6.Severity.Minor)
-      severity = import_core6.Severity.Minor;
-    issues.push(
-      `High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`
-    );
-    recommendations.push("Consolidate with related files in same domain");
-    potentialSavings += contextBudget * 0.3;
-  }
-  if (issues.length === 0) {
-    issues.push("No significant issues detected");
-    recommendations.push("File is well-structured for AI context usage");
-  }
-  if (isBuildArtifact(file)) {
-    issues.push("Detected build artifact (bundled/output file)");
-    recommendations.push("Exclude build outputs from analysis");
-    severity = import_core6.Severity.Info;
-    potentialSavings = 0;
-  }
-  return {
-    severity,
-    issues,
-    recommendations,
-    potentialSavings: Math.floor(potentialSavings)
-  };
-}
-function isBuildArtifact(filePath) {
-  const lower = filePath.toLowerCase();
-  return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/.next/");
-}
-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 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 || "."
+    maxDepth = 5,
+    maxContextBudget = 1e4,
+    minCohesion = 0.6,
+    maxFragmentation = 0.5,
+    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 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({
@@ -1537,27 +1355,21 @@ async function analyzeContext(options) {
         maxContextBudget,
         minCohesion,
         maxFragmentation,
-        circularDeps: metric.metrics.circularDependencies.map(
-          (cycle) => cycle.split(" \u2192 ")
-        )
+        circularDeps: []
       });
       return {
         file: metric.file,
-        tokenCost: Math.floor(
-          metric.contextBudget / (1 + metric.imports.length || 1)
-        ),
-        linesOfCode: metric.metrics.linesOfCode,
+        tokenCost: 0,
+        linesOfCode: 0,
+        // Not provided by python context yet
         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 ")
-        ),
+        dependencyCount: 0,
+        // Not provided
+        dependencyList: [],
+        circularDeps: [],
         cohesionScore: metric.cohesion,
-        domains: ["python"],
-        exportCount: metric.exports.length,
+        domains: [],
+        exportCount: 0,
         contextBudget: metric.contextBudget,
         fragmentationScore: 0,
         relatedFiles: [],
@@ -1569,579 +1381,202 @@ async function analyzeContext(options) {
       };
     });
   }
-  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 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
+      };
     }
-    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;
-  });
+  );
+  return [...results, ...pythonResults];
 }
 
-// src/scoring.ts
+// src/summary.ts
 var import_core7 = require("@aiready/core");
-function calculateContextScore(summary, costConfig) {
-  const {
+function generateSummary(results, options = {}) {
+  const config = options ? Object.fromEntries(
+    Object.entries(options).filter(
+      ([key]) => !import_core7.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
+    )
+  ) : {};
+  const totalFiles = results.length;
+  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
+  const avgContextBudget = totalFiles > 0 ? results.reduce((sum, r) => sum + r.contextBudget, 0) / totalFiles : 0;
+  const deepFiles = results.filter((r) => r.importDepth > 5).map((r) => ({ file: r.file, depth: r.importDepth }));
+  const maxImportDepth = Math.max(0, ...results.map((r) => r.importDepth));
+  const moduleMap = /* @__PURE__ */ new Map();
+  results.forEach((r) => {
+    const parts = r.file.split("/");
+    let domain = "root";
+    if (parts.length > 2) {
+      domain = parts.slice(0, 2).join("/");
+    }
+    if (!moduleMap.has(domain)) moduleMap.set(domain, []);
+    moduleMap.get(domain).push(r);
+  });
+  const fragmentedModules = [];
+  moduleMap.forEach((files, domain) => {
+    const clusterTokens = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const filePaths = files.map((f) => f.file);
+    const avgEntropy = calculatePathEntropy(filePaths);
+    const fragmentationScore = Math.min(1, avgEntropy * (files.length / 10));
+    if (fragmentationScore > 0.4) {
+      fragmentedModules.push({
+        domain,
+        files: filePaths,
+        fragmentationScore,
+        totalTokens: clusterTokens,
+        avgCohesion: files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length,
+        suggestedStructure: {
+          targetFiles: Math.ceil(files.length / 2),
+          consolidationPlan: [
+            `Consolidate ${files.length} files in ${domain} into fewer modules`
+          ]
+        }
+      });
+    }
+  });
+  fragmentedModules.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
+  const avgFragmentation = fragmentedModules.length > 0 ? fragmentedModules.reduce((sum, m) => sum + m.fragmentationScore, 0) / fragmentedModules.length : 0;
+  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / (totalFiles || 1);
+  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.4).map((r) => ({ file: r.file, score: r.cohesionScore }));
+  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),
+    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,
+    maxContextBudget: Math.max(0, ...results.map((r) => r.contextBudget)),
+    avgImportDepth: results.reduce((sum, r) => sum + r.importDepth, 0) / (totalFiles || 1),
     maxImportDepth,
+    deepFiles,
     avgFragmentation,
+    fragmentedModules,
+    avgCohesion,
+    lowCohesionFiles,
     criticalIssues,
-    majorIssues
-  } = summary;
-  const budgetScore = avgContextBudget < 5e3 ? 100 : Math.max(0, 100 - (avgContextBudget - 5e3) / 150);
-  const depthScore = avgImportDepth < 5 ? 100 : Math.max(0, 100 - (avgImportDepth - 5) * 10);
-  const fragmentationScore = avgFragmentation < 0.3 ? 100 : Math.max(0, 100 - (avgFragmentation - 0.3) * 200);
-  const criticalPenalty = criticalIssues * 10;
-  const majorPenalty = majorIssues * 3;
-  const maxBudgetPenalty = maxContextBudget > 15e3 ? Math.min(20, (maxContextBudget - 15e3) / 500) : 0;
-  const rawScore = budgetScore * 0.4 + depthScore * 0.3 + fragmentationScore * 0.3;
-  const finalScore = rawScore - criticalPenalty - majorPenalty - maxBudgetPenalty;
-  const score = Math.max(0, Math.min(100, Math.round(finalScore)));
-  const factors = [
-    {
-      name: "Context Budget",
-      impact: Math.round(budgetScore * 0.4 - 40),
-      description: `Avg ${Math.round(avgContextBudget)} tokens per file ${avgContextBudget < 5e3 ? "(excellent)" : avgContextBudget < 1e4 ? "(acceptable)" : "(high)"}`
-    },
-    {
-      name: "Import Depth",
-      impact: Math.round(depthScore * 0.3 - 30),
-      description: `Avg ${avgImportDepth.toFixed(1)} levels ${avgImportDepth < 5 ? "(excellent)" : avgImportDepth < 8 ? "(acceptable)" : "(deep)"}`
-    },
-    {
-      name: "Fragmentation",
-      impact: Math.round(fragmentationScore * 0.3 - 30),
-      description: `${(avgFragmentation * 100).toFixed(0)}% fragmentation ${avgFragmentation < 0.3 ? "(well-organized)" : avgFragmentation < 0.5 ? "(moderate)" : "(high)"}`
-    }
-  ];
-  if (criticalIssues > 0) {
-    factors.push({
-      name: "Critical Issues",
-      impact: -criticalPenalty,
-      description: `${criticalIssues} critical context issue${criticalIssues > 1 ? "s" : ""}`
-    });
-  }
-  if (majorIssues > 0) {
-    factors.push({
-      name: "Major Issues",
-      impact: -majorPenalty,
-      description: `${majorIssues} major context issue${majorIssues > 1 ? "s" : ""}`
-    });
-  }
-  if (maxBudgetPenalty > 0) {
-    factors.push({
-      name: "Extreme File Detected",
-      impact: -Math.round(maxBudgetPenalty),
-      description: `One file requires ${Math.round(maxContextBudget)} tokens (very high)`
-    });
-  }
-  const recommendations = [];
-  if (avgContextBudget > 1e4) {
-    const estimatedImpact = Math.min(
-      15,
-      Math.round((avgContextBudget - 1e4) / 1e3)
-    );
-    recommendations.push({
-      action: "Reduce file dependencies to lower context requirements",
-      estimatedImpact,
-      priority: "high"
-    });
-  }
-  if (avgImportDepth > 8) {
-    const estimatedImpact = Math.min(10, Math.round((avgImportDepth - 8) * 2));
-    recommendations.push({
-      action: "Flatten import chains to reduce depth",
-      estimatedImpact,
-      priority: avgImportDepth > 10 ? "high" : "medium"
-    });
-  }
-  if (avgFragmentation > 0.5) {
-    const estimatedImpact = Math.min(
-      12,
-      Math.round((avgFragmentation - 0.5) * 40)
-    );
-    recommendations.push({
-      action: "Consolidate related code into cohesive modules",
-      estimatedImpact,
-      priority: "medium"
-    });
-  }
-  if (maxContextBudget > 2e4) {
-    recommendations.push({
-      action: `Split large file (${Math.round(maxContextBudget)} tokens) into smaller modules`,
-      estimatedImpact: 8,
-      priority: "high"
-    });
-  }
-  const cfg = { ...import_core7.DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = (0, import_core7.calculateMonthlyCost)(
-    avgContextBudget * (summary.totalFiles || 1),
-    cfg
-  );
-  const issues = [
-    ...Array(criticalIssues).fill({ severity: "critical" }),
-    ...Array(majorIssues).fill({ severity: "major" })
-  ];
-  const productivityImpact = (0, import_core7.calculateProductivityImpact)(issues);
-  return {
-    toolName: import_core7.ToolName.ContextAnalyzer,
-    score,
-    rawMetrics: {
-      avgContextBudget: Math.round(avgContextBudget),
-      maxContextBudget: Math.round(maxContextBudget),
-      avgImportDepth: Math.round(avgImportDepth * 10) / 10,
-      maxImportDepth,
-      avgFragmentation: Math.round(avgFragmentation * 100) / 100,
-      criticalIssues,
-      majorIssues,
-      estimatedMonthlyCost,
-      estimatedDeveloperHours: productivityImpact.totalHours
-    },
-    factors,
-    recommendations
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles,
+    config
   };
 }
 
-// src/provider.ts
-var ContextAnalyzerProvider = {
-  id: import_core8.ToolName.ContextAnalyzer,
-  alias: ["context", "fragmentation", "budget"],
-  async analyze(options) {
-    const results = await analyzeContext(options);
-    const summary = generateSummary(results, options);
-    const normalizedResults = results.map(
-      (r) => ({
-        fileName: r.file,
-        issues: r.issues.map((msg) => ({
-          type: import_core8.IssueType.ContextFragmentation,
-          severity: r.severity,
-          message: msg,
-          location: { file: r.file, line: 1 },
-          suggestion: r.recommendations[0]
-        })),
-        metrics: {
-          tokenCost: r.tokenCost,
-          complexityScore: r.importDepth
-          // Map other context-specific metrics if needed
-        }
-      })
-    );
-    return import_core8.SpokeOutputSchema.parse({
-      results: normalizedResults,
-      summary: {
-        ...summary
-      },
-      metadata: {
-        toolName: import_core8.ToolName.ContextAnalyzer,
-        version: "0.17.5",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-  },
-  score(output, options) {
-    const summary = output.summary;
-    return calculateContextScore(summary, options.costConfig);
-  },
-  defaultWeight: 19
-};
-
-// src/defaults.ts
-var import_core9 = require("@aiready/core");
-
-// src/index.ts
-import_core10.ToolRegistry.register(ContextAnalyzerProvider);
-
-// src/cli.ts
+// src/utils/output-formatter.ts
 var import_chalk = __toESM(require("chalk"));
 var import_fs2 = require("fs");
 var import_path3 = require("path");
-var import_core11 = require("@aiready/core");
 var import_prompts = __toESM(require("prompts"));
-var program = new import_commander.Command();
-program.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
-  "after",
-  "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
-).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
-  "--max-context <number>",
-  "Maximum acceptable context budget (tokens)"
-).option("--min-cohesion <number>", "Minimum acceptable cohesion score (0-1)").option(
-  "--max-fragmentation <number>",
-  "Maximum acceptable fragmentation (0-1)"
-).option(
-  "--focus <type>",
-  "Analysis focus: fragmentation, cohesion, depth, all"
-).option("--include-node-modules", "Include node_modules in analysis").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
-  "--max-results <number>",
-  "Maximum number of results to show in console output"
-).option(
-  "-o, --output <format>",
-  "Output format: console, json, html",
-  "console"
-).option("--output-file <path>", "Output file path (for json/html)").option(
-  "--interactive",
-  "Run interactive setup to suggest excludes and focus areas"
-).action(async (directory, options) => {
-  console.log(import_chalk.default.blue("\u{1F50D} Analyzing context window costs...\n"));
-  const startTime = Date.now();
-  try {
-    const defaults = {
-      maxDepth: 5,
-      maxContextBudget: 1e4,
-      minCohesion: 0.6,
-      maxFragmentation: 0.5,
-      focus: "all",
-      includeNodeModules: false,
-      include: void 0,
-      exclude: void 0,
-      maxResults: 10
-    };
-    let finalOptions = await (0, import_core11.loadMergedConfig)(directory, defaults, {
-      maxDepth: options.maxDepth ? parseInt(options.maxDepth) : void 0,
-      maxContextBudget: options.maxContext ? parseInt(options.maxContext) : void 0,
-      minCohesion: options.minCohesion ? parseFloat(options.minCohesion) : void 0,
-      maxFragmentation: options.maxFragmentation ? parseFloat(options.maxFragmentation) : void 0,
-      focus: options.focus || void 0,
-      includeNodeModules: options.includeNodeModules,
-      include: options.include?.split(","),
-      exclude: options.exclude?.split(","),
-      maxResults: options.maxResults ? parseInt(options.maxResults) : void 0
-    });
-    if (options.interactive) {
-      finalOptions = await runInteractiveSetup(directory, finalOptions);
-    }
-    const results = await analyzeContext(finalOptions);
-    const elapsedTime = (0, import_core11.getElapsedTime)(startTime);
-    const summary = generateSummary(results);
-    if (options.output === "json") {
-      const jsonOutput = {
-        summary,
-        results,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        analysisTime: elapsedTime
-      };
-      const outputPath = (0, import_core11.resolveOutputPath)(
-        options.outputFile,
-        `context-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
-        directory
-      );
-      (0, import_core11.handleJSONOutput)(
-        jsonOutput,
-        outputPath,
-        `
-\u2713 JSON report saved to ${outputPath}`
-      );
-      return;
-    }
-    if (options.output === "html") {
-      const html = generateHTMLReport(summary, results);
-      const outputPath = (0, import_core11.resolveOutputPath)(
-        options.outputFile,
-        `context-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`,
-        directory
-      );
-      const dir = (0, import_path3.dirname)(outputPath);
-      if (!(0, import_fs2.existsSync)(dir)) {
-        (0, import_fs2.mkdirSync)(dir, { recursive: true });
-      }
-      (0, import_fs2.writeFileSync)(outputPath, html);
-      console.log(import_chalk.default.green(`
-\u2713 HTML report saved to ${outputPath}`));
-      return;
-    }
-    displayConsoleReport(
-      summary,
-      results,
-      elapsedTime,
-      finalOptions.maxResults
-    );
-    displayTuningGuidance(results, finalOptions);
-  } catch (error) {
-    (0, import_core11.handleCLIError)(error, "Analysis");
-  }
-});
-program.parse();
-function displayTuningGuidance(results, options) {
-  const issueCount = results.filter((r) => r.severity !== "info").length;
-  if (issueCount === 0) {
-    console.log(
-      import_chalk.default.green(
-        "\n\u2728 No optimization opportunities found! Your code is well-structured for AI context usage.\n"
-      )
-    );
-    return;
-  }
-  console.log(import_chalk.default.cyan("\n\u2501".repeat(60)));
-  console.log(import_chalk.default.bold.white("  TUNING GUIDANCE"));
-  console.log(import_chalk.default.cyan("\u2501".repeat(60) + "\n"));
-  if (issueCount < 5) {
-    console.log(
-      import_chalk.default.yellow(
-        "\u{1F4CA} Showing few optimization opportunities. To find more areas to improve:\n"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Lower --max-depth (currently: " + options.maxDepth + ") to catch shallower import chains"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Lower --max-context (currently: " + options.maxContextBudget.toLocaleString() + ") to catch smaller files"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Raise --min-cohesion (currently: " + (options.minCohesion * 100).toFixed(0) + "%) to be stricter about mixed concerns"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Lower --max-fragmentation (currently: " + (options.maxFragmentation * 100).toFixed(0) + "%) to catch scattered code\n"
-      )
-    );
-  } else if (issueCount > 20) {
-    console.log(
-      import_chalk.default.yellow(
-        "\u{1F4CA} Showing many opportunities. To focus on highest-impact areas:\n"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Raise --max-depth (currently: " + options.maxDepth + ") to only catch very deep chains"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Raise --max-context (currently: " + options.maxContextBudget.toLocaleString() + ") to focus on largest files"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Lower --min-cohesion (currently: " + (options.minCohesion * 100).toFixed(0) + "%) to only flag severe mixed concerns"
-      )
-    );
-    console.log(
-      import_chalk.default.dim(
-        "   \u2022 Raise --max-fragmentation (currently: " + (options.maxFragmentation * 100).toFixed(0) + "%) to only flag highly scattered code\n"
-      )
-    );
-  } else {
-    console.log(
-      import_chalk.default.green(
-        "\u{1F4CA} Good balance of optimization opportunities (showing " + issueCount + " areas)\n"
-      )
-    );
-    console.log(import_chalk.default.dim("   \u{1F4A1} Tip: Adjust thresholds if needed:"));
-    console.log(
-      import_chalk.default.dim(
-        "      aiready-context . --max-depth N --max-context N --min-cohesion 0.X\n"
-      )
-    );
-  }
-  console.log(import_chalk.default.dim("   \u{1F4D6} See README for detailed tuning guide\n"));
-}
-function displayConsoleReport(summary, results, elapsedTime, maxResults = 10) {
-  const terminalWidth = process.stdout.columns || 80;
-  const dividerWidth = Math.min(60, terminalWidth - 2);
-  const divider = "\u2501".repeat(dividerWidth);
-  console.log(import_chalk.default.cyan(divider));
-  console.log(import_chalk.default.bold.white("  CONTEXT ANALYSIS SUMMARY"));
-  console.log(import_chalk.default.cyan(divider) + "\n");
+function displayConsoleReport(summary, results, maxResults = 10) {
+  const divider = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  const totalIssues = summary.criticalIssues + summary.majorIssues + summary.minorIssues;
+  console.log(import_chalk.default.bold("\u{1F4CA} Context Analysis Summary:\n"));
+  console.log(`   \u2022 Total Files:      ${import_chalk.default.cyan(summary.totalFiles)}`);
   console.log(
-    import_chalk.default.white(`\u{1F4C1} Files analyzed: ${import_chalk.default.bold(summary.totalFiles)}`)
+    `   \u2022 Total Tokens:     ${import_chalk.default.cyan(summary.totalTokens.toLocaleString())}`
   );
   console.log(
-    import_chalk.default.white(
-      `\u{1F4CA} Total tokens: ${import_chalk.default.bold(summary.totalTokens.toLocaleString())}`
-    )
+    `   \u2022 Avg Budget:       ${import_chalk.default.cyan(summary.avgContextBudget.toFixed(0))} tokens`
   );
   console.log(
-    import_chalk.default.yellow(
-      `\u{1F4B0} Avg context budget: ${import_chalk.default.bold(summary.avgContextBudget.toFixed(0))} tokens/file`
-    )
+    `   \u2022 Potential Saving: ${import_chalk.default.green(summary.totalPotentialSavings.toLocaleString())} tokens`
   );
-  console.log(
-    import_chalk.default.white(`\u23F1  Analysis time: ${import_chalk.default.bold(elapsedTime + "s")}
-`)
-  );
-  const totalIssues = summary.criticalIssues + summary.majorIssues + summary.minorIssues;
+  console.log();
   if (totalIssues > 0) {
-    console.log(import_chalk.default.bold("\u26A0\uFE0F  Issues Found:\n"));
-    if (summary.criticalIssues > 0) {
-      console.log(
-        import_chalk.default.red(`   \u{1F534} Critical: ${import_chalk.default.bold(summary.criticalIssues)}`)
-      );
-    }
-    if (summary.majorIssues > 0) {
-      console.log(
-        import_chalk.default.yellow(`   \u{1F7E1} Major: ${import_chalk.default.bold(summary.majorIssues)}`)
-      );
-    }
-    if (summary.minorIssues > 0) {
-      console.log(
-        import_chalk.default.blue(`   \u{1F535} Minor: ${import_chalk.default.bold(summary.minorIssues)}`)
-      );
-    }
-    console.log(
-      import_chalk.default.green(
-        `
-   \u{1F4A1} Potential savings: ${import_chalk.default.bold(summary.totalPotentialSavings.toLocaleString())} tokens
-`
-      )
-    );
-  } else {
-    console.log(import_chalk.default.green("\u2705 No significant issues found!\n"));
-  }
-  if (summary.deepFiles.length > 0) {
-    console.log(import_chalk.default.bold("\u{1F4CF} Deep Import Chains:\n"));
-    console.log(
-      import_chalk.default.gray(`   Average depth: ${summary.avgImportDepth.toFixed(1)}`)
-    );
-    console.log(import_chalk.default.gray(`   Maximum depth: ${summary.maxImportDepth}
-`));
-    summary.deepFiles.slice(0, maxResults).forEach((item) => {
-      const fileName = item.file.split("/").slice(-2).join("/");
-      console.log(
-        `   ${import_chalk.default.cyan("\u2192")} ${import_chalk.default.white(fileName)} ${import_chalk.default.dim(`(depth: ${item.depth})`)}`
-      );
-    });
+    console.log(import_chalk.default.bold("\u26A0\uFE0F Issues Detected:\n"));
+    console.log(`   \u2022 ${import_chalk.default.red("\u{1F534} Critical:")} ${summary.criticalIssues}`);
+    console.log(`   \u2022 ${import_chalk.default.yellow("\u{1F7E1} Major:")}    ${summary.majorIssues}`);
+    console.log(`   \u2022 ${import_chalk.default.blue("\u{1F535} Minor:")}    ${summary.minorIssues}`);
     console.log();
+  } else {
+    console.log(import_chalk.default.green("\u2705 No significant context issues detected!\n"));
   }
   if (summary.fragmentedModules.length > 0) {
-    console.log(import_chalk.default.bold("\u{1F9E9} Fragmented Modules:\n"));
-    console.log(
-      import_chalk.default.gray(
-        `   Average fragmentation: ${(summary.avgFragmentation * 100).toFixed(0)}%
-`
-      )
-    );
-    summary.fragmentedModules.slice(0, maxResults).forEach((module2) => {
-      console.log(
-        `   ${import_chalk.default.yellow("\u25CF")} ${import_chalk.default.white(module2.domain)} - ${import_chalk.default.dim(`${module2.files.length} files, ${(module2.fragmentationScore * 100).toFixed(0)}% scattered`)}`
-      );
-      console.log(
-        import_chalk.default.dim(
-          `     Token cost: ${module2.totalTokens.toLocaleString()}, Cohesion: ${(module2.avgCohesion * 100).toFixed(0)}%`
-        )
-      );
-    });
-    console.log();
-  }
-  if (summary.lowCohesionFiles.length > 0) {
-    console.log(import_chalk.default.bold("\u{1F500} Low Cohesion Files:\n"));
-    console.log(
-      import_chalk.default.gray(
-        `   Average cohesion: ${(summary.avgCohesion * 100).toFixed(0)}%
-`
-      )
-    );
-    summary.lowCohesionFiles.slice(0, maxResults).forEach((item) => {
-      const fileName = item.file.split("/").slice(-2).join("/");
-      const scorePercent = (item.score * 100).toFixed(0);
-      const color = item.score < 0.4 ? import_chalk.default.red : import_chalk.default.yellow;
+    console.log(import_chalk.default.bold("\u{1F9E9} Top Fragmented Modules:\n"));
+    summary.fragmentedModules.slice(0, maxResults).forEach((mod) => {
+      const scoreColor = mod.fragmentationScore > 0.7 ? import_chalk.default.red : mod.fragmentationScore > 0.4 ? import_chalk.default.yellow : import_chalk.default.green;
       console.log(
-        `   ${color("\u25CB")} ${import_chalk.default.white(fileName)} ${import_chalk.default.dim(`(${scorePercent}% cohesion)`)}`
+        `   ${scoreColor("\u25A0")} ${import_chalk.default.white(mod.domain)} ${import_chalk.default.dim(`(${mod.files.length} files, ${(mod.fragmentationScore * 100).toFixed(0)}% frag)`)}`
       );
     });
     console.log();
@@ -2427,3 +1862,102 @@ async function runInteractiveSetup(directory, current) {
   console.log(import_chalk.default.green("\u2713 Interactive configuration applied."));
   return nextOptions;
 }
+
+// src/cli-action.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_fs3 = require("fs");
+async function contextActionHandler(directory, options) {
+  console.log(import_chalk2.default.blue("\u{1F50D} Analyzing context window costs...\n"));
+  const startTime = Date.now();
+  try {
+    const defaults = {
+      maxDepth: 5,
+      maxContextBudget: 1e4,
+      minCohesion: 0.6,
+      maxFragmentation: 0.5,
+      focus: "all",
+      includeNodeModules: false,
+      include: void 0,
+      exclude: void 0,
+      maxResults: 10
+    };
+    let finalOptions = await (0, import_core8.loadMergedConfig)(directory, defaults, {
+      maxDepth: options.maxDepth ? parseInt(options.maxDepth) : void 0,
+      maxContextBudget: options.maxContext ? parseInt(options.maxContext) : void 0,
+      minCohesion: options.minCohesion ? parseFloat(options.minCohesion) : void 0,
+      maxFragmentation: options.maxFragmentation ? parseFloat(options.maxFragmentation) : void 0,
+      focus: options.focus || void 0,
+      includeNodeModules: options.includeNodeModules,
+      include: options.include?.split(","),
+      exclude: options.exclude?.split(","),
+      maxResults: options.maxResults ? parseInt(options.maxResults) : void 0
+    });
+    if (options.interactive) {
+      finalOptions = await runInteractiveSetup(directory, finalOptions);
+    }
+    const results = await analyzeContext(finalOptions);
+    const summary = generateSummary(results, finalOptions);
+    const duration = (0, import_core8.getElapsedTime)(startTime);
+    if (options.output === "json") {
+      (0, import_core8.handleJSONOutput)(
+        {
+          summary: {
+            ...summary,
+            executionTime: duration,
+            config: {
+              scan: { tools: ["context"] },
+              tools: { context: finalOptions }
+            },
+            toolConfigs: { context: finalOptions }
+          },
+          context: { results }
+        },
+        options.outputFile
+      );
+    } else if (options.output === "html") {
+      const html = generateHTMLReport(summary, results);
+      const outputPath = (0, import_core8.resolveOutputPath)(
+        directory,
+        options.outputFile,
+        "context-report.html"
+      );
+      (0, import_fs3.writeFileSync)(outputPath, html, "utf-8");
+      console.log(import_chalk2.default.green(`
+\u2705 HTML report saved to: ${outputPath}`));
+    } else {
+      displayConsoleReport(summary, results, finalOptions.maxResults);
+      console.log(import_chalk2.default.dim(`
+\u2728 Analysis completed in ${duration}ms
+`));
+    }
+  } catch (error) {
+    (0, import_core8.handleCLIError)(error, "context-analyzer");
+  }
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText(
+  "after",
+  "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings"
+).argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
+  "--max-context <number>",
+  "Maximum acceptable context budget (tokens)"
+).option("--min-cohesion <number>", "Minimum acceptable cohesion score (0-1)").option(
+  "--max-fragmentation <number>",
+  "Maximum acceptable fragmentation (0-1)"
+).option(
+  "--focus <type>",
+  "Analysis focus: fragmentation, cohesion, depth, all"
+).option("--include-node-modules", "Include node_modules in analysis").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
+  "--max-results <number>",
+  "Maximum number of results to show in console output"
+).option(
+  "-o, --output <format>",
+  "Output format: console, json, html",
+  "console"
+).option("--output-file <path>", "Output file path (for json/html)").option(
+  "--interactive",
+  "Run interactive setup to suggest excludes and focus areas"
+).action(contextActionHandler);
+program.parse(process.argv);