@aiready/context-analyzer 0.21.1 → 0.21.6

package/dist/index.js

@@ -30,6 +30,99 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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,6 +285,7 @@ var init_python_context = __esm({
     import_core5 = require("@aiready/core");
     import_path2 = require("path");
     import_fs = __toESM(require("fs"));
+    init_dependency_graph_utils();
   }
 });
 
@@ -249,7 +297,6 @@ __export(index_exports, {
   adjustCohesionForClassification: () => adjustCohesionForClassification,
   adjustFragmentationForClassification: () => adjustFragmentationForClassification,
   analyzeContext: () => analyzeContext,
-  analyzeIssues: () => analyzeIssues,
   buildCoUsageMatrix: () => buildCoUsageMatrix,
   buildDependencyGraph: () => buildDependencyGraph,
   buildTypeGraph: () => buildTypeGraph,
@@ -266,10 +313,12 @@ __export(index_exports, {
   classifyFile: () => classifyFile,
   detectCircularDependencies: () => detectCircularDependencies,
   detectModuleClusters: () => detectModuleClusters,
+  displayConsoleReport: () => displayConsoleReport,
   extractDomainKeywordsFromPaths: () => extractDomainKeywordsFromPaths,
   extractExports: () => extractExports,
   findConsolidationCandidates: () => findConsolidationCandidates,
   findSemanticClusters: () => findSemanticClusters,
+  generateHTMLReport: () => generateHTMLReport,
   generateSummary: () => generateSummary,
   getClassificationRecommendations: () => getClassificationRecommendations,
   getCoUsageData: () => getCoUsageData,
@@ -288,13 +337,14 @@ __export(index_exports, {
   isSessionFile: () => isSessionFile,
   isTypeDefinition: () => isTypeDefinition,
   isUtilityModule: () => isUtilityModule,
-  mapScoreToRating: () => mapScoreToRating
+  mapScoreToRating: () => mapScoreToRating,
+  runInteractiveSetup: () => runInteractiveSetup
 });
 module.exports = __toCommonJS(index_exports);
-var import_core10 = require("@aiready/core");
+var import_core11 = require("@aiready/core");
 
 // src/provider.ts
-var import_core8 = require("@aiready/core");
+var import_core9 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core6 = require("@aiready/core");
@@ -305,6 +355,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();
@@ -524,19 +589,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;
-}
 function getCoUsageData(file, coUsageMatrix) {
   return {
     file,
@@ -729,143 +781,112 @@ function calculateDirectoryDistance(files) {
   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)
   };
 }
+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("/")) {
@@ -913,25 +934,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();
@@ -982,31 +990,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);
@@ -1022,35 +1009,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
@@ -1365,78 +1396,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) {
@@ -1543,124 +1502,14 @@ function getGeneralRecommendations(metrics, thresholds) {
 
 // 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) {
-  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;
@@ -1698,27 +1547,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: [],
@@ -1730,116 +1573,169 @@ 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 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 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;
-      }
+  );
+  return [...results, ...pythonResults];
+}
+
+// src/summary.ts
+var import_core7 = require("@aiready/core");
+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("/");
     }
-    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;
+    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: 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,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles,
+    config
+  };
 }
 
 // src/scoring.ts
-var import_core7 = require("@aiready/core");
+var import_core8 = require("@aiready/core");
 function calculateContextScore(summary, costConfig) {
   const {
     avgContextBudget,
@@ -1848,34 +1744,46 @@ function calculateContextScore(summary, costConfig) {
     maxImportDepth,
     avgFragmentation,
     criticalIssues,
-    majorIssues
+    majorIssues,
+    totalFiles
   } = 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 budgetScore = avgContextBudget < 8e3 ? 100 : Math.max(0, 100 - (avgContextBudget - 8e3) / 200);
+  const depthScore = avgImportDepth < 8 ? 100 : Math.max(0, 100 - (avgImportDepth - 8) * 5);
+  const fragmentationScore = avgFragmentation < 0.5 ? 100 : Math.max(0, 100 - (avgFragmentation - 0.5) * 100);
+  const criticalPenalty = Math.min(20, criticalIssues * 3);
+  const majorPenalty = Math.min(15, majorIssues * 1);
   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;
+  let bonus = 0;
+  if (criticalIssues === 0 && majorIssues === 0 && avgFragmentation < 0.2) {
+    bonus = 5;
+  }
+  const rawScore = budgetScore * 0.35 + depthScore * 0.25 + fragmentationScore * 0.25 + bonus;
+  const finalScore = rawScore - Math.min(30, 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)"}`
+      impact: Math.round(budgetScore * 0.35 - 35),
+      description: `Avg ${Math.round(avgContextBudget)} tokens per file ${avgContextBudget < 8e3 ? "(excellent)" : avgContextBudget < 12e3 ? "(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)"}`
+      impact: Math.round(depthScore * 0.25 - 25),
+      description: `Avg ${avgImportDepth.toFixed(1)} levels ${avgImportDepth < 8 ? "(excellent)" : avgImportDepth < 12 ? "(acceptable)" : "(deep)"}`
     },
     {
       name: "Fragmentation",
-      impact: Math.round(fragmentationScore * 0.3 - 30),
+      impact: Math.round(fragmentationScore * 0.25 - 25),
       description: `${(avgFragmentation * 100).toFixed(0)}% fragmentation ${avgFragmentation < 0.3 ? "(well-organized)" : avgFragmentation < 0.5 ? "(moderate)" : "(high)"}`
     }
   ];
+  if (bonus > 0) {
+    factors.push({
+      name: "Well-Organized Codebase",
+      impact: bonus,
+      description: "No critical/major issues and low fragmentation"
+    });
+  }
   if (criticalIssues > 0) {
     factors.push({
       name: "Critical Issues",
@@ -1898,10 +1806,10 @@ function calculateContextScore(summary, costConfig) {
     });
   }
   const recommendations = [];
-  if (avgContextBudget > 1e4) {
+  if (avgContextBudget > 12e3) {
     const estimatedImpact = Math.min(
       15,
-      Math.round((avgContextBudget - 1e4) / 1e3)
+      Math.round((avgContextBudget - 12e3) / 1e3)
     );
     recommendations.push({
       action: "Reduce file dependencies to lower context requirements",
@@ -1909,12 +1817,15 @@ function calculateContextScore(summary, costConfig) {
       priority: "high"
     });
   }
-  if (avgImportDepth > 8) {
-    const estimatedImpact = Math.min(10, Math.round((avgImportDepth - 8) * 2));
+  if (avgImportDepth > 10) {
+    const estimatedImpact = Math.min(
+      10,
+      Math.round((avgImportDepth - 10) * 1.5)
+    );
     recommendations.push({
       action: "Flatten import chains to reduce depth",
       estimatedImpact,
-      priority: avgImportDepth > 10 ? "high" : "medium"
+      priority: avgImportDepth > 15 ? "high" : "medium"
     });
   }
   if (avgFragmentation > 0.5) {
@@ -1935,18 +1846,18 @@ function calculateContextScore(summary, costConfig) {
       priority: "high"
     });
   }
-  const cfg = { ...import_core7.DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = (0, import_core7.calculateMonthlyCost)(
-    avgContextBudget * (summary.totalFiles || 1),
+  const cfg = { ...import_core8.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core8.calculateMonthlyCost)(
+    avgContextBudget * (totalFiles || 1),
     cfg
   );
   const issues = [
     ...Array(criticalIssues).fill({ severity: "critical" }),
     ...Array(majorIssues).fill({ severity: "major" })
   ];
-  const productivityImpact = (0, import_core7.calculateProductivityImpact)(issues);
+  const productivityImpact = (0, import_core8.calculateProductivityImpact)(issues);
   return {
-    toolName: import_core7.ToolName.ContextAnalyzer,
+    toolName: import_core8.ToolName.ContextAnalyzer,
     score,
     rawMetrics: {
       avgContextBudget: Math.round(avgContextBudget),
@@ -1973,7 +1884,7 @@ function mapScoreToRating(score) {
 
 // src/provider.ts
 var ContextAnalyzerProvider = {
-  id: import_core8.ToolName.ContextAnalyzer,
+  id: import_core9.ToolName.ContextAnalyzer,
   alias: ["context", "fragmentation", "budget"],
   async analyze(options) {
     const results = await analyzeContext(options);
@@ -1982,7 +1893,7 @@ var ContextAnalyzerProvider = {
       (r) => ({
         fileName: r.file,
         issues: r.issues.map((msg) => ({
-          type: import_core8.IssueType.ContextFragmentation,
+          type: import_core9.IssueType.ContextFragmentation,
           severity: r.severity,
           message: msg,
           location: { file: r.file, line: 1 },
@@ -1995,13 +1906,13 @@ var ContextAnalyzerProvider = {
         }
       })
     );
-    return import_core8.SpokeOutputSchema.parse({
+    return import_core9.SpokeOutputSchema.parse({
       results: normalizedResults,
       summary: {
         ...summary
       },
       metadata: {
-        toolName: import_core8.ToolName.ContextAnalyzer,
+        toolName: import_core9.ToolName.ContextAnalyzer,
         version: "0.17.5",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }
@@ -2015,9 +1926,9 @@ var ContextAnalyzerProvider = {
 };
 
 // src/defaults.ts
-var import_core9 = require("@aiready/core");
+var import_core10 = require("@aiready/core");
 async function getSmartDefaults(directory, userOptions) {
-  const files = await (0, import_core9.scanFiles)({
+  const files = await (0, import_core10.scanFiles)({
     rootDir: directory,
     include: userOptions.include,
     exclude: userOptions.exclude
@@ -2061,8 +1972,329 @@ async function getSmartDefaults(directory, userOptions) {
   };
 }
 
+// src/utils/output-formatter.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+var import_prompts = __toESM(require("prompts"));
+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(
+    `   \u2022 Total Tokens:     ${import_chalk.default.cyan(summary.totalTokens.toLocaleString())}`
+  );
+  console.log(
+    `   \u2022 Avg Budget:       ${import_chalk.default.cyan(summary.avgContextBudget.toFixed(0))} tokens`
+  );
+  console.log(
+    `   \u2022 Potential Saving: ${import_chalk.default.green(summary.totalPotentialSavings.toLocaleString())} tokens`
+  );
+  console.log();
+  if (totalIssues > 0) {
+    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} 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(
+        `   ${scoreColor("\u25A0")} ${import_chalk.default.white(mod.domain)} ${import_chalk.default.dim(`(${mod.files.length} files, ${(mod.fragmentationScore * 100).toFixed(0)}% frag)`)}`
+      );
+    });
+    console.log();
+  }
+  if (summary.topExpensiveFiles.length > 0) {
+    console.log(import_chalk.default.bold("\u{1F4B8} Most Expensive Files (Context Budget):\n"));
+    summary.topExpensiveFiles.slice(0, maxResults).forEach((item) => {
+      const fileName = item.file.split("/").slice(-2).join("/");
+      const severityColor = item.severity === "critical" ? import_chalk.default.red : item.severity === "major" ? import_chalk.default.yellow : import_chalk.default.blue;
+      console.log(
+        `   ${severityColor("\u25CF")} ${import_chalk.default.white(fileName)} ${import_chalk.default.dim(`- ${item.contextBudget.toLocaleString()} tokens`)}`
+      );
+    });
+    console.log();
+  }
+  if (totalIssues > 0) {
+    console.log(import_chalk.default.bold("\u{1F4A1} Top Recommendations:\n"));
+    const topFiles = results.filter((r) => r.severity === "critical" || r.severity === "major").slice(0, 3);
+    topFiles.forEach((result, index) => {
+      const fileName = result.file.split("/").slice(-2).join("/");
+      console.log(import_chalk.default.cyan(`   ${index + 1}. ${fileName}`));
+      result.recommendations.slice(0, 2).forEach((rec) => {
+        console.log(import_chalk.default.dim(`      \u2022 ${rec}`));
+      });
+    });
+    console.log();
+  }
+  console.log(import_chalk.default.cyan(divider));
+  console.log(
+    import_chalk.default.dim(
+      "\n\u2B50 Like aiready? Star us on GitHub: https://github.com/caopengau/aiready-context-analyzer"
+    )
+  );
+  console.log(
+    import_chalk.default.dim(
+      "\u{1F41B} Found a bug? Report it: https://github.com/caopengau/aiready-context-analyzer/issues\n"
+    )
+  );
+}
+function generateHTMLReport(summary, results) {
+  const totalIssues = summary.criticalIssues + summary.majorIssues + summary.minorIssues;
+  void results;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>aiready Context Analysis Report</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 20px;
+      background-color: #f5f5f5;
+    }
+    h1, h2, h3 { color: #2c3e50; }
+    .header {
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      padding: 30px;
+      border-radius: 8px;
+      margin-bottom: 30px;
+    }
+    .summary {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+      gap: 20px;
+      margin-bottom: 30px;
+    }
+    .card {
+      background: white;
+      padding: 20px;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .metric {
+      font-size: 2em;
+      font-weight: bold;
+      color: #667eea;
+    }
+    .label {
+      color: #666;
+      font-size: 0.9em;
+      margin-top: 5px;
+    }
+    .issue-critical { color: #e74c3c; }
+    .issue-major { color: #f39c12; }
+    .issue-minor { color: #3498db; }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      background: white;
+      border-radius: 8px;
+      overflow: hidden;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    th, td {
+      padding: 12px;
+      text-align: left;
+      border-bottom: 1px solid #eee;
+    }
+    th {
+      background-color: #667eea;
+      color: white;
+      font-weight: 600;
+    }
+    tr:hover { background-color: #f8f9fa; }
+    .footer {
+      text-align: center;
+      margin-top: 40px;
+      padding: 20px;
+      color: #666;
+      font-size: 0.9em;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>\u{1F50D} AIReady Context Analysis Report</h1>
+    <p>Generated on ${(/* @__PURE__ */ new Date()).toLocaleString()}</p>
+  </div>
+
+  <div class="summary">
+    <div class="card">
+      <div class="metric">${summary.totalFiles}</div>
+      <div class="label">Files Analyzed</div>
+    </div>
+    <div class="card">
+      <div class="metric">${summary.totalTokens.toLocaleString()}</div>
+      <div class="label">Total Tokens</div>
+    </div>
+    <div class="card">
+      <div class="metric">${summary.avgContextBudget.toFixed(0)}</div>
+      <div class="label">Avg Context Budget</div>
+    </div>
+    <div class="card">
+      <div class="metric ${totalIssues > 0 ? "issue-major" : ""}">${totalIssues}</div>
+      <div class="label">Total Issues</div>
+    </div>
+  </div>
+
+  ${totalIssues > 0 ? `
+  <div class="card" style="margin-bottom: 30px;">
+    <h2>\u26A0\uFE0F Issues Summary</h2>
+    <p>
+      <span class="issue-critical">\u{1F534} Critical: ${summary.criticalIssues}</span> &nbsp;
+      <span class="issue-major">\u{1F7E1} Major: ${summary.majorIssues}</span> &nbsp;
+      <span class="issue-minor">\u{1F535} Minor: ${summary.minorIssues}</span>
+    </p>
+    <p><strong>Potential Savings:</strong> ${summary.totalPotentialSavings.toLocaleString()} tokens</p>
+  </div>
+  ` : ""}
+
+  ${summary.fragmentedModules.length > 0 ? `
+  <div class="card" style="margin-bottom: 30px;">
+    <h2>\u{1F9E9} Fragmented Modules</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>Domain</th>
+          <th>Files</th>
+          <th>Fragmentation</th>
+          <th>Token Cost</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${summary.fragmentedModules.map(
+    (m) => `
+          <tr>
+            <td>${m.domain}</td>
+            <td>${m.files.length}</td>
+            <td>${(m.fragmentationScore * 100).toFixed(0)}%</td>
+            <td>${m.totalTokens.toLocaleString()}</td>
+          </tr>
+        `
+  ).join("")}
+      </tbody>
+    </table>
+  </div>
+  ` : ""}
+
+  ${summary.topExpensiveFiles.length > 0 ? `
+  <div class="card" style="margin-bottom: 30px;">
+    <h2>\u{1F4B8} Most Expensive Files</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>File</th>
+          <th>Context Budget</th>
+          <th>Severity</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${summary.topExpensiveFiles.map(
+    (f) => `
+          <tr>
+            <td>${f.file}</td>
+            <td>${f.contextBudget.toLocaleString()} tokens</td>
+            <td class="issue-${f.severity}">${f.severity.toUpperCase()}</td>
+          </tr>
+        `
+  ).join("")}
+      </tbody>
+    </table>
+  </div>
+  ` : ""}
+
+  <div class="footer">
+    <p>Generated by <strong>@aiready/context-analyzer</strong></p>
+    <p>Like AIReady? <a href="https://github.com/caopengau/aiready-context-analyzer">Star us on GitHub</a></p>
+    <p>Found a bug? <a href="https://github.com/caopengau/aiready-context-analyzer/issues">Report it here</a></p>
+  </div>
+</body>
+</html>`;
+}
+async function runInteractiveSetup(directory, current) {
+  console.log(import_chalk.default.yellow("\u{1F9ED} Interactive mode: let\u2019s tailor the analysis."));
+  const pkgPath = (0, import_path3.join)(directory, "package.json");
+  let deps = {};
+  if ((0, import_fs2.existsSync)(pkgPath)) {
+    try {
+      const pkg = JSON.parse((0, import_fs2.readFileSync)(pkgPath, "utf-8"));
+      deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+    } catch (e) {
+      void e;
+    }
+  }
+  const hasNextJs = (0, import_fs2.existsSync)((0, import_path3.join)(directory, ".next")) || !!deps["next"];
+  const hasCDK = (0, import_fs2.existsSync)((0, import_path3.join)(directory, "cdk.out")) || !!deps["aws-cdk-lib"] || Object.keys(deps).some((d) => d.startsWith("@aws-cdk/"));
+  const recommendedExcludes = new Set(current.exclude || []);
+  if (hasNextJs && !Array.from(recommendedExcludes).some((p) => p.includes(".next"))) {
+    recommendedExcludes.add("**/.next/**");
+  }
+  if (hasCDK && !Array.from(recommendedExcludes).some((p) => p.includes("cdk.out"))) {
+    recommendedExcludes.add("**/cdk.out/**");
+  }
+  const { applyExcludes } = await (0, import_prompts.default)({
+    type: "toggle",
+    name: "applyExcludes",
+    message: `Detected ${hasNextJs ? "Next.js " : ""}${hasCDK ? "AWS CDK " : ""}frameworks. Apply recommended excludes?`,
+    initial: true,
+    active: "yes",
+    inactive: "no"
+  });
+  const nextOptions = { ...current };
+  if (applyExcludes) {
+    nextOptions.exclude = Array.from(recommendedExcludes);
+  }
+  const { focusArea } = await (0, import_prompts.default)({
+    type: "select",
+    name: "focusArea",
+    message: "Which areas to focus?",
+    choices: [
+      { title: "Frontend (web app)", value: "frontend" },
+      { title: "Backend (API/infra)", value: "backend" },
+      { title: "Both", value: "both" }
+    ],
+    initial: 2
+  });
+  if (focusArea === "frontend") {
+    nextOptions.include = ["**/*.{ts,tsx,js,jsx}"];
+    nextOptions.exclude = Array.from(
+      /* @__PURE__ */ new Set([
+        ...nextOptions.exclude || [],
+        "**/cdk.out/**",
+        "**/infra/**",
+        "**/server/**",
+        "**/backend/**"
+      ])
+    );
+  } else if (focusArea === "backend") {
+    nextOptions.include = [
+      "**/api/**",
+      "**/server/**",
+      "**/backend/**",
+      "**/infra/**",
+      "**/*.{ts,js,py,java}"
+    ];
+  }
+  console.log(import_chalk.default.green("\u2713 Interactive configuration applied."));
+  return nextOptions;
+}
+
 // src/index.ts
-import_core10.ToolRegistry.register(ContextAnalyzerProvider);
+import_core11.ToolRegistry.register(ContextAnalyzerProvider);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Classification,
@@ -2070,7 +2302,6 @@ import_core10.ToolRegistry.register(ContextAnalyzerProvider);
   adjustCohesionForClassification,
   adjustFragmentationForClassification,
   analyzeContext,
-  analyzeIssues,
   buildCoUsageMatrix,
   buildDependencyGraph,
   buildTypeGraph,
@@ -2087,10 +2318,12 @@ import_core10.ToolRegistry.register(ContextAnalyzerProvider);
   classifyFile,
   detectCircularDependencies,
   detectModuleClusters,
+  displayConsoleReport,
   extractDomainKeywordsFromPaths,
   extractExports,
   findConsolidationCandidates,
   findSemanticClusters,
+  generateHTMLReport,
   generateSummary,
   getClassificationRecommendations,
   getCoUsageData,
@@ -2109,5 +2342,6 @@ import_core10.ToolRegistry.register(ContextAnalyzerProvider);
   isSessionFile,
   isTypeDefinition,
   isUtilityModule,
-  mapScoreToRating
+  mapScoreToRating,
+  runInteractiveSetup
 });