@aiready/context-analyzer 0.9.40 → 0.9.42

package/dist/index.js

@@ -37,7 +37,7 @@ __export(python_context_exports, {
 });
 async function analyzePythonContext(files, rootDir) {
   const results = [];
-  const parser = (0, import_core3.getParser)("dummy.py");
+  const parser = (0, import_core6.getParser)("dummy.py");
   if (!parser) {
     console.warn("Python parser not available");
     return results;
@@ -101,7 +101,7 @@ async function analyzePythonContext(files, rootDir) {
 }
 async function buildPythonDependencyGraph(files, rootDir) {
   const graph = /* @__PURE__ */ new Map();
-  const parser = (0, import_core3.getParser)("dummy.py");
+  const parser = (0, import_core6.getParser)("dummy.py");
   if (!parser) return graph;
   for (const file of files) {
     try {
@@ -181,7 +181,7 @@ async function calculatePythonImportDepth(file, dependencyGraph, visited, depth
 }
 function estimateContextBudget(code, imports, dependencyGraph) {
   void dependencyGraph;
-  let budget = (0, import_core3.estimateTokens)(code);
+  let budget = (0, import_core6.estimateTokens)(code);
   const avgTokensPerDep = 500;
   budget += imports.length * avgTokensPerDep;
   return budget;
@@ -231,11 +231,11 @@ function detectCircularDependencies2(file, dependencyGraph) {
   dfs(file, []);
   return [...new Set(circular)];
 }
-var import_core3, import_path, import_fs;
+var import_core6, import_path, import_fs;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
     "use strict";
-    import_core3 = require("@aiready/core");
+    import_core6 = require("@aiready/core");
     import_path = require("path");
     import_fs = __toESM(require("fs"));
   }
@@ -244,44 +244,73 @@ var init_python_context = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  adjustCohesionForClassification: () => adjustCohesionForClassification,
   adjustFragmentationForClassification: () => adjustFragmentationForClassification,
   analyzeContext: () => analyzeContext,
+  analyzeIssues: () => analyzeIssues,
   buildCoUsageMatrix: () => buildCoUsageMatrix,
+  buildDependencyGraph: () => buildDependencyGraph,
   buildTypeGraph: () => buildTypeGraph,
+  calculateCohesion: () => calculateCohesion,
+  calculateContextBudget: () => calculateContextBudget,
   calculateContextScore: () => calculateContextScore,
+  calculateDirectoryDistance: () => calculateDirectoryDistance,
   calculateDomainConfidence: () => calculateDomainConfidence,
+  calculateEnhancedCohesion: () => calculateEnhancedCohesion,
+  calculateFragmentation: () => calculateFragmentation,
+  calculateImportDepth: () => calculateImportDepth,
+  calculatePathEntropy: () => calculatePathEntropy,
+  calculateStructuralCohesionFromCoUsage: () => calculateStructuralCohesionFromCoUsage,
   classifyFile: () => classifyFile,
+  detectCircularDependencies: () => detectCircularDependencies,
+  detectModuleClusters: () => detectModuleClusters,
+  extractDomainKeywordsFromPaths: () => extractDomainKeywordsFromPaths,
+  extractExports: () => extractExports,
+  extractImportsFromContent: () => extractImportsFromContent,
   findConsolidationCandidates: () => findConsolidationCandidates,
   findSemanticClusters: () => findSemanticClusters,
   generateSummary: () => generateSummary,
+  getClassificationRecommendations: () => getClassificationRecommendations,
   getCoUsageData: () => getCoUsageData,
+  getGeneralRecommendations: () => getGeneralRecommendations,
   getSmartDefaults: () => getSmartDefaults,
-  inferDomainFromSemantics: () => inferDomainFromSemantics
+  getTransitiveDependencies: () => getTransitiveDependencies,
+  inferDomain: () => inferDomain,
+  inferDomainFromSemantics: () => inferDomainFromSemantics,
+  isBarrelExport: () => isBarrelExport,
+  isConfigFile: () => isConfigFile,
+  isEmailTemplate: () => isEmailTemplate,
+  isLambdaHandler: () => isLambdaHandler,
+  isNextJsPage: () => isNextJsPage,
+  isParserFile: () => isParserFile,
+  isServiceFile: () => isServiceFile,
+  isSessionFile: () => isSessionFile,
+  isTypeDefinition: () => isTypeDefinition,
+  isUtilityModule: () => isUtilityModule,
+  mapScoreToRating: () => mapScoreToRating
 });
 module.exports = __toCommonJS(index_exports);
-var import_core4 = require("@aiready/core");
+var import_core7 = require("@aiready/core");
 
-// src/analyzer.ts
+// src/metrics.ts
+var import_core2 = require("@aiready/core");
+
+// src/ast-utils.ts
 var import_core = require("@aiready/core");
 
 // src/semantic-analysis.ts
 function buildCoUsageMatrix(graph) {
   const coUsageMatrix = /* @__PURE__ */ new Map();
-  for (const [sourceFile, node] of graph.nodes) {
-    void sourceFile;
+  for (const [, node] of graph.nodes) {
     const imports = node.imports;
     for (let i = 0; i < imports.length; i++) {
       const fileA = imports[i];
-      if (!coUsageMatrix.has(fileA)) {
-        coUsageMatrix.set(fileA, /* @__PURE__ */ new Map());
-      }
+      if (!coUsageMatrix.has(fileA)) coUsageMatrix.set(fileA, /* @__PURE__ */ new Map());
       for (let j = i + 1; j < imports.length; j++) {
         const fileB = imports[j];
         const fileAUsage = coUsageMatrix.get(fileA);
         fileAUsage.set(fileB, (fileAUsage.get(fileB) || 0) + 1);
-        if (!coUsageMatrix.has(fileB)) {
-          coUsageMatrix.set(fileB, /* @__PURE__ */ new Map());
-        }
+        if (!coUsageMatrix.has(fileB)) coUsageMatrix.set(fileB, /* @__PURE__ */ new Map());
         const fileBUsage = coUsageMatrix.get(fileB);
         fileBUsage.set(fileA, (fileBUsage.get(fileA) || 0) + 1);
       }
@@ -295,9 +324,7 @@ function buildTypeGraph(graph) {
     for (const exp of node.exports) {
       if (exp.typeReferences) {
         for (const typeRef of exp.typeReferences) {
-          if (!typeGraph.has(typeRef)) {
-            typeGraph.set(typeRef, /* @__PURE__ */ new Set());
-          }
+          if (!typeGraph.has(typeRef)) typeGraph.set(typeRef, /* @__PURE__ */ new Set());
           typeGraph.get(typeRef).add(file);
         }
       }
@@ -318,35 +345,11 @@ function findSemanticClusters(coUsageMatrix, minCoUsage = 3) {
         visited.add(relatedFile);
       }
     }
-    if (cluster.length > 1) {
-      clusters.set(file, cluster);
-    }
+    if (cluster.length > 1) clusters.set(file, cluster);
   }
   return clusters;
 }
-function calculateDomainConfidence(signals) {
-  const weights = {
-    coUsage: 0.35,
-    // Strongest signal: actual usage patterns
-    typeReference: 0.3,
-    // Strong signal: shared types
-    exportName: 0.15,
-    // Medium signal: identifier semantics
-    importPath: 0.1,
-    // Weaker signal: path structure
-    folderStructure: 0.1
-    // Weakest signal: organization convention
-  };
-  let confidence = 0;
-  if (signals.coUsage) confidence += weights.coUsage;
-  if (signals.typeReference) confidence += weights.typeReference;
-  if (signals.exportName) confidence += weights.exportName;
-  if (signals.importPath) confidence += weights.importPath;
-  if (signals.folderStructure) confidence += weights.folderStructure;
-  return confidence;
-}
 function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGraph, exportTypeRefs) {
-  const assignments = [];
   const domainSignals = /* @__PURE__ */ new Map();
   const coUsages = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
   const strongCoUsages = Array.from(coUsages.entries()).filter(([, count]) => count >= 3).map(([coFile]) => coFile);
@@ -375,23 +378,22 @@ function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGr
       const filesWithType = typeGraph.get(typeRef);
       if (filesWithType) {
         for (const typeFile of filesWithType) {
-          if (typeFile !== file) {
-            const typeNode = graph.nodes.get(typeFile);
-            if (typeNode) {
-              for (const exp of typeNode.exports) {
-                if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
-                  const domain = exp.inferredDomain;
-                  if (!domainSignals.has(domain)) {
-                    domainSignals.set(domain, {
-                      coUsage: false,
-                      typeReference: false,
-                      exportName: false,
-                      importPath: false,
-                      folderStructure: false
-                    });
-                  }
-                  domainSignals.get(domain).typeReference = true;
+          if (typeFile === file) continue;
+          const typeNode = graph.nodes.get(typeFile);
+          if (typeNode) {
+            for (const exp of typeNode.exports) {
+              if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
+                const domain = exp.inferredDomain;
+                if (!domainSignals.has(domain)) {
+                  domainSignals.set(domain, {
+                    coUsage: false,
+                    typeReference: false,
+                    exportName: false,
+                    importPath: false,
+                    folderStructure: false
+                  });
                 }
+                domainSignals.get(domain).typeReference = true;
               }
             }
           }
@@ -399,22 +401,140 @@ function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGr
       }
     }
   }
+  const assignments = [];
   for (const [domain, signals] of domainSignals) {
     const confidence = calculateDomainConfidence(signals);
-    if (confidence >= 0.3) {
-      assignments.push({ domain, confidence, signals });
-    }
+    if (confidence >= 0.3) assignments.push({ domain, confidence, signals });
   }
   assignments.sort((a, b) => b.confidence - a.confidence);
   return assignments;
 }
+function calculateDomainConfidence(signals) {
+  const weights = {
+    coUsage: 0.35,
+    typeReference: 0.3,
+    exportName: 0.15,
+    importPath: 0.1,
+    folderStructure: 0.1
+  };
+  let confidence = 0;
+  if (signals.coUsage) confidence += weights.coUsage;
+  if (signals.typeReference) confidence += weights.typeReference;
+  if (signals.exportName) confidence += weights.exportName;
+  if (signals.importPath) confidence += weights.importPath;
+  if (signals.folderStructure) confidence += weights.folderStructure;
+  return confidence;
+}
+function extractExports(content, filePath, domainOptions, fileImports) {
+  const exports2 = [];
+  const patterns = [
+    /export\s+function\s+(\w+)/g,
+    /export\s+class\s+(\w+)/g,
+    /export\s+const\s+(\w+)/g,
+    /export\s+type\s+(\w+)/g,
+    /export\s+interface\s+(\w+)/g,
+    /export\s+default/g
+  ];
+  const types = [
+    "function",
+    "class",
+    "const",
+    "type",
+    "interface",
+    "default"
+  ];
+  patterns.forEach((pattern, index) => {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1] || "default";
+      const type = types[index];
+      const inferredDomain = inferDomain(
+        name,
+        filePath,
+        domainOptions,
+        fileImports
+      );
+      exports2.push({ name, type, inferredDomain });
+    }
+  });
+  return exports2;
+}
+function inferDomain(name, filePath, domainOptions, fileImports) {
+  const lower = name.toLowerCase();
+  const tokens = Array.from(
+    new Set(
+      lower.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^a-z0-9]+/gi, " ").split(" ").filter(Boolean)
+    )
+  );
+  const defaultKeywords = [
+    "authentication",
+    "authorization",
+    "payment",
+    "invoice",
+    "customer",
+    "product",
+    "order",
+    "cart",
+    "user",
+    "admin",
+    "repository",
+    "controller",
+    "service",
+    "config",
+    "model",
+    "view",
+    "auth"
+  ];
+  const domainKeywords = domainOptions?.domainKeywords?.length ? [...domainOptions.domainKeywords, ...defaultKeywords] : defaultKeywords;
+  for (const keyword of domainKeywords) {
+    if (tokens.includes(keyword)) return keyword;
+  }
+  for (const keyword of domainKeywords) {
+    if (lower.includes(keyword)) return keyword;
+  }
+  if (fileImports) {
+    for (const importPath of fileImports) {
+      const segments = importPath.split("/");
+      for (const segment of segments) {
+        const segLower = segment.toLowerCase();
+        const singularSegment = singularize(segLower);
+        for (const keyword of domainKeywords) {
+          if (singularSegment === keyword || segLower === keyword || segLower.includes(keyword))
+            return keyword;
+        }
+      }
+    }
+  }
+  if (filePath) {
+    const segments = filePath.split("/");
+    for (const segment of segments) {
+      const segLower = segment.toLowerCase();
+      const singularSegment = singularize(segLower);
+      for (const keyword of domainKeywords) {
+        if (singularSegment === keyword || segLower === keyword) return keyword;
+      }
+    }
+  }
+  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) {
-  const coImportedWith = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
-  const sharedImporters = [];
   return {
     file,
-    coImportedWith,
-    sharedImporters
+    coImportedWith: coUsageMatrix.get(file) || /* @__PURE__ */ new Map(),
+    sharedImporters: []
   };
 }
 function findConsolidationCandidates(graph, coUsageMatrix, typeGraph, minCoUsage = 5, minSharedTypes = 2) {
@@ -422,9 +542,8 @@ function findConsolidationCandidates(graph, coUsageMatrix, typeGraph, minCoUsage
   for (const [fileA, coUsages] of coUsageMatrix) {
     const nodeA = graph.nodes.get(fileA);
     if (!nodeA) continue;
-    for (const [fileB, coUsageCount] of coUsages) {
-      if (fileB <= fileA) continue;
-      if (coUsageCount < minCoUsage) continue;
+    for (const [fileB, count] of coUsages) {
+      if (fileB <= fileA || count < minCoUsage) continue;
       const nodeB = graph.nodes.get(fileB);
       if (!nodeB) continue;
       const typesA = new Set(
@@ -434,28 +553,190 @@ function findConsolidationCandidates(graph, coUsageMatrix, typeGraph, minCoUsage
         nodeB.exports.flatMap((e) => e.typeReferences || [])
       );
       const sharedTypes = Array.from(typesA).filter((t) => typesB.has(t));
-      if (sharedTypes.length >= minSharedTypes) {
-        const strength = coUsageCount / 10 + sharedTypes.length / 5;
-        candidates.push({
-          files: [fileA, fileB],
-          reason: `High co-usage (${coUsageCount}x) and ${sharedTypes.length} shared types`,
-          strength
-        });
-      } else if (coUsageCount >= minCoUsage * 2) {
-        const strength = coUsageCount / 10;
+      if (sharedTypes.length >= minSharedTypes || count >= minCoUsage * 2) {
         candidates.push({
           files: [fileA, fileB],
-          reason: `Very high co-usage (${coUsageCount}x)`,
-          strength
+          reason: `High co-usage (${count}x)`,
+          strength: count / 10
         });
       }
     }
   }
-  candidates.sort((a, b) => b.strength - a.strength);
-  return candidates;
+  return candidates.sort((a, b) => b.strength - a.strength);
 }
 
-// src/analyzer.ts
+// src/ast-utils.ts
+function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
+  try {
+    const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
+    return astExports.map((exp) => ({
+      name: exp.name,
+      type: exp.type,
+      inferredDomain: inferDomain(
+        exp.name,
+        filePath,
+        domainOptions,
+        fileImports
+      ),
+      imports: exp.imports,
+      dependencies: exp.dependencies,
+      typeReferences: exp.typeReferences
+    }));
+  } catch (error) {
+    void error;
+    return extractExports(content, filePath, domainOptions, fileImports);
+  }
+}
+function isTestFile(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.includes(".test.") || lower.includes(".spec.") || lower.includes("/__tests__/") || lower.includes("/tests/") || lower.includes("/test/") || lower.includes("test-") || lower.includes("-test") || lower.includes("/__mocks__/") || lower.includes("/mocks/") || lower.includes("/fixtures/") || lower.includes(".mock.") || lower.includes(".fixture.") || lower.includes("/test-utils/");
+}
+
+// src/metrics.ts
+function calculateEnhancedCohesion(exports2, filePath, options) {
+  if (exports2.length <= 1) return 1;
+  if (filePath && isTestFile(filePath)) return 1;
+  const domains = exports2.map((e) => e.inferredDomain || "unknown");
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const d of domains) domainCounts.set(d, (domainCounts.get(d) || 0) + 1);
+  if (domainCounts.size === 1 && domains[0] !== "unknown") {
+    if (!options?.weights) return 1;
+  }
+  const probs = Array.from(domainCounts.values()).map(
+    (c) => c / exports2.length
+  );
+  let domainEntropy = 0;
+  for (const p of probs) {
+    if (p > 0) domainEntropy -= p * Math.log2(p);
+  }
+  const maxEntropy = Math.log2(Math.max(2, domainCounts.size));
+  const domainScore = 1 - domainEntropy / maxEntropy;
+  let importScoreTotal = 0;
+  let pairsWithData = 0;
+  let anyImportData = false;
+  for (let i = 0; i < exports2.length; i++) {
+    for (let j = i + 1; j < exports2.length; j++) {
+      const exp1Imports = exports2[i].imports;
+      const exp2Imports = exports2[j].imports;
+      if (exp1Imports || exp2Imports) {
+        anyImportData = true;
+        const sim = (0, import_core2.calculateImportSimilarity)(
+          { ...exports2[i], imports: exp1Imports || [] },
+          { ...exports2[j], imports: exp2Imports || [] }
+        );
+        importScoreTotal += sim;
+        pairsWithData++;
+      }
+    }
+  }
+  const avgImportScore = pairsWithData > 0 ? importScoreTotal / pairsWithData : 0;
+  let score = 0;
+  if (anyImportData) {
+    score = domainScore * 0.4 + avgImportScore * 0.6;
+    if (score === 0 && domainScore === 0) score = 0.1;
+  } else {
+    score = domainScore;
+  }
+  let structuralScore = 0;
+  for (const exp of exports2) {
+    if (exp.dependencies && exp.dependencies.length > 0) {
+      structuralScore += 1;
+    }
+  }
+  if (structuralScore > 0) {
+    score = Math.min(1, score + 0.1);
+  }
+  if (!options?.weights && !anyImportData && domainCounts.size === 1) return 1;
+  return score;
+}
+function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
+  if (!coUsageMatrix) return 1;
+  const coUsages = coUsageMatrix.get(file);
+  if (!coUsages || coUsages.size === 0) return 1;
+  let total = 0;
+  for (const count of coUsages.values()) total += count;
+  if (total === 0) return 1;
+  const probs = [];
+  for (const count of coUsages.values()) {
+    if (count > 0) probs.push(count / total);
+  }
+  if (probs.length <= 1) return 1;
+  let entropy = 0;
+  for (const prob of probs) {
+    entropy -= prob * Math.log2(prob);
+  }
+  const maxEntropy = Math.log2(probs.length);
+  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
+}
+function calculateFragmentation(files, domain, options) {
+  if (files.length <= 1) return 0;
+  const directories = new Set(
+    files.map((f) => f.split("/").slice(0, -1).join("/"))
+  );
+  const uniqueDirs = directories.size;
+  let score = 0;
+  if (options?.useLogScale) {
+    if (uniqueDirs <= 1) score = 0;
+    else {
+      const total = files.length;
+      const base = options.logBase || Math.E;
+      const num = Math.log(uniqueDirs) / Math.log(base);
+      const den = Math.log(total) / Math.log(base);
+      score = den > 0 ? num / den : 0;
+    }
+  } else {
+    score = (uniqueDirs - 1) / (files.length - 1);
+  }
+  if (options?.sharedImportRatio && options.sharedImportRatio > 0.5) {
+    const discount = (options.sharedImportRatio - 0.5) * 0.4;
+    score = score * (1 - discount);
+  }
+  return score;
+}
+function calculatePathEntropy(files) {
+  if (!files || files.length === 0) return 0;
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = f.split("/").slice(0, -1).join("/") || ".";
+    dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
+  }
+  const counts = Array.from(dirCounts.values());
+  if (counts.length <= 1) return 0;
+  const total = counts.reduce((s, v) => s + v, 0);
+  let entropy = 0;
+  for (const count of counts) {
+    const prob = count / total;
+    entropy -= prob * Math.log2(prob);
+  }
+  const maxEntropy = Math.log2(counts.length);
+  return maxEntropy > 0 ? entropy / maxEntropy : 0;
+}
+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/graph-builder.ts
+var import_core3 = require("@aiready/core");
 function extractDomainKeywordsFromPaths(files) {
   const folderNames = /* @__PURE__ */ new Set();
   for (const { file } of files) {
@@ -483,39 +764,29 @@ function extractDomainKeywordsFromPaths(files) {
     for (const segment of segments) {
       const normalized = segment.toLowerCase();
       if (normalized && !skipFolders.has(normalized) && !normalized.includes(".")) {
-        const singular = singularize(normalized);
-        folderNames.add(singular);
+        folderNames.add(singularize2(normalized));
       }
     }
   }
   return Array.from(folderNames);
 }
-function singularize(word) {
+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);
-  }
+  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();
   const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
-  void import_core.calculateImportSimilarity;
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
     const exports2 = extractExportsWithAST(
@@ -524,15 +795,9 @@ function buildDependencyGraph(files, options) {
       { domainKeywords: autoDetectedKeywords },
       imports
     );
-    const tokenCost = (0, import_core.estimateTokens)(content);
+    const tokenCost = (0, import_core3.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
-    nodes.set(file, {
-      file,
-      imports,
-      exports: exports2,
-      tokenCost,
-      linesOfCode
-    });
+    nodes.set(file, { file, imports, exports: exports2, tokenCost, linesOfCode });
     edges.set(file, new Set(imports));
   }
   const graph = { nodes, edges };
@@ -562,11 +827,8 @@ function extractImportsFromContent(content) {
   const imports = [];
   const patterns = [
     /import\s+.*?\s+from\s+['"](.+?)['"]/g,
-    // import ... from '...'
     /import\s+['"](.+?)['"]/g,
-    // import '...'
     /require\(['"](.+?)['"]\)/g
-    // require('...')
   ];
   for (const pattern of patterns) {
     let match;
@@ -580,31 +842,25 @@ function extractImportsFromContent(content) {
   return [...new Set(imports)];
 }
 function calculateImportDepth(file, graph, visited = /* @__PURE__ */ new Set(), depth = 0) {
-  if (visited.has(file)) {
-    return depth;
-  }
+  if (visited.has(file)) return depth;
   const dependencies = graph.edges.get(file);
-  if (!dependencies || dependencies.size === 0) {
-    return depth;
-  }
+  if (!dependencies || dependencies.size === 0) return depth;
   visited.add(file);
   let maxDepth = depth;
   for (const dep of dependencies) {
-    const depDepth = calculateImportDepth(dep, graph, visited, depth + 1);
-    maxDepth = Math.max(maxDepth, depDepth);
+    maxDepth = Math.max(
+      maxDepth,
+      calculateImportDepth(dep, graph, visited, depth + 1)
+    );
   }
   visited.delete(file);
   return maxDepth;
 }
 function getTransitiveDependencies(file, graph, visited = /* @__PURE__ */ new Set()) {
-  if (visited.has(file)) {
-    return [];
-  }
+  if (visited.has(file)) return [];
   visited.add(file);
   const dependencies = graph.edges.get(file);
-  if (!dependencies || dependencies.size === 0) {
-    return [];
-  }
+  if (!dependencies || dependencies.size === 0) return [];
   const allDeps = [];
   for (const dep of dependencies) {
     allDeps.push(dep);
@@ -637,9 +893,7 @@ function detectCircularDependencies(graph) {
       }
       return;
     }
-    if (visited.has(file)) {
-      return;
-    }
+    if (visited.has(file)) return;
     visited.add(file);
     recursionStack.add(file);
     path.push(file);
@@ -658,404 +912,23 @@ function detectCircularDependencies(graph) {
   }
   return cycles;
 }
-function calculateCohesion(exports2, filePath, options) {
-  return calculateEnhancedCohesion(exports2, filePath, options);
-}
-function isTestFile(filePath) {
-  const lower = filePath.toLowerCase();
-  return lower.includes("test") || lower.includes("spec") || lower.includes("mock") || lower.includes("fixture") || lower.includes("__tests__") || lower.includes(".test.") || lower.includes(".spec.");
-}
-function calculateFragmentation(files, domain, options) {
-  if (files.length <= 1) return 0;
-  const directories = new Set(
-    files.map((f) => f.split("/").slice(0, -1).join("/"))
-  );
-  const uniqueDirs = directories.size;
-  if (options?.useLogScale) {
-    if (uniqueDirs <= 1) return 0;
-    const total = files.length;
-    const base = options.logBase || Math.E;
-    const num = Math.log(uniqueDirs) / Math.log(base);
-    const den = Math.log(total) / Math.log(base);
-    return den > 0 ? num / den : 0;
-  }
-  return (uniqueDirs - 1) / (files.length - 1);
-}
-function calculatePathEntropy(files) {
-  if (!files || files.length === 0) return 0;
-  const dirCounts = /* @__PURE__ */ new Map();
-  for (const f of files) {
-    const dir = f.split("/").slice(0, -1).join("/") || ".";
-    dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
-  }
-  const counts = Array.from(dirCounts.values());
-  if (counts.length <= 1) return 0;
-  const total = counts.reduce((s, v) => s + v, 0);
-  let entropy = 0;
-  for (const count of counts) {
-    const prob = count / total;
-    entropy -= prob * Math.log2(prob);
-  }
-  const maxEntropy = Math.log2(counts.length);
-  return maxEntropy > 0 ? entropy / maxEntropy : 0;
-}
-function calculateDirectoryDistance(files) {
-  if (!files || files.length <= 1) return 0;
-  function pathSegments(p) {
-    return p.split("/").filter(Boolean);
-  }
-  function 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);
-      const normalizedShared = maxDepth > 0 ? shared / maxDepth : 0;
-      totalNormalized += 1 - normalizedShared;
-      comparisons++;
-    }
-  }
-  return comparisons > 0 ? totalNormalized / comparisons : 0;
-}
-function detectModuleClusters(graph, options) {
-  const domainMap = /* @__PURE__ */ new Map();
-  for (const [file, node] of graph.nodes.entries()) {
-    const domains = node.exports.map((e) => e.inferredDomain || "unknown");
-    const primaryDomain = domains[0] || "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) continue;
-    const totalTokens = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node?.tokenCost || 0);
-    }, 0);
-    const baseFragmentation = calculateFragmentation(files, domain, {
-      useLogScale: !!options?.useLogScale
-    });
-    let importSimilarityTotal = 0;
-    let importComparisons = 0;
-    for (let i = 0; i < files.length; i++) {
-      for (let j = i + 1; j < files.length; j++) {
-        const f1 = files[i];
-        const f2 = files[j];
-        const n1 = graph.nodes.get(f1)?.imports || [];
-        const n2 = graph.nodes.get(f2)?.imports || [];
-        const similarity = n1.length === 0 && n2.length === 0 ? 0 : calculateJaccardSimilarity(n1, n2);
-        importSimilarityTotal += similarity;
-        importComparisons++;
-      }
-    }
-    const importCohesion = importComparisons > 0 ? importSimilarityTotal / importComparisons : 0;
-    const couplingDiscountFactor = 1 - 0.2 * importCohesion;
-    const fragmentationScore = baseFragmentation * couplingDiscountFactor;
-    const pathEntropy = calculatePathEntropy(files);
-    const directoryDistance = calculateDirectoryDistance(files);
-    const avgCohesion = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node ? calculateCohesion(node.exports, file, {
-        coUsageMatrix: graph.coUsageMatrix
-      }) : 0);
-    }, 0) / files.length;
-    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
-    const consolidationPlan = generateConsolidationPlan(
-      domain,
-      files,
-      targetFiles
-    );
-    clusters.push({
-      domain,
-      files,
-      totalTokens,
-      fragmentationScore,
-      pathEntropy,
-      directoryDistance,
-      importCohesion,
-      avgCohesion,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan
-      }
-    });
-  }
-  return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
-}
-function extractExports(content, filePath, domainOptions, fileImports) {
-  const exports2 = [];
-  const patterns = [
-    /export\s+function\s+(\w+)/g,
-    /export\s+class\s+(\w+)/g,
-    /export\s+const\s+(\w+)/g,
-    /export\s+type\s+(\w+)/g,
-    /export\s+interface\s+(\w+)/g,
-    /export\s+default/g
-  ];
-  const types = [
-    "function",
-    "class",
-    "const",
-    "type",
-    "interface",
-    "default"
-  ];
-  patterns.forEach((pattern, index) => {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const name = match[1] || "default";
-      const type = types[index];
-      const inferredDomain = inferDomain(
-        name,
-        filePath,
-        domainOptions,
-        fileImports
-      );
-      exports2.push({ name, type, inferredDomain });
-    }
-  });
-  return exports2;
-}
-function inferDomain(name, filePath, domainOptions, fileImports) {
-  const lower = name.toLowerCase();
-  const tokens = Array.from(
-    new Set(
-      lower.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^a-z0-9]+/gi, " ").split(" ").filter(Boolean)
-    )
-  );
-  const defaultKeywords = [
-    "authentication",
-    "authorization",
-    "payment",
-    "invoice",
-    "customer",
-    "product",
-    "order",
-    "cart",
-    "user",
-    "admin",
-    "repository",
-    "controller",
-    "service",
-    "config",
-    "model",
-    "view",
-    "auth"
-  ];
-  const domainKeywords = domainOptions?.domainKeywords && domainOptions.domainKeywords.length ? [...domainOptions.domainKeywords, ...defaultKeywords] : defaultKeywords;
-  for (const keyword of domainKeywords) {
-    if (tokens.includes(keyword)) {
-      return keyword;
-    }
-  }
-  for (const keyword of domainKeywords) {
-    if (lower.includes(keyword)) {
-      return keyword;
-    }
-  }
-  if (fileImports && fileImports.length > 0) {
-    for (const importPath of fileImports) {
-      const allSegments = importPath.split("/");
-      const relevantSegments = allSegments.filter((s) => {
-        if (!s) return false;
-        if (s === "." || s === "..") return false;
-        if (s.startsWith("@") && s.length === 1) return false;
-        return true;
-      }).map((s) => s.startsWith("@") ? s.slice(1) : s);
-      for (const segment of relevantSegments) {
-        const segLower = segment.toLowerCase();
-        const singularSegment = singularize(segLower);
-        for (const keyword of domainKeywords) {
-          if (singularSegment === keyword || segLower === keyword || segLower.includes(keyword)) {
-            return keyword;
-          }
-        }
-      }
-    }
-  }
-  if (filePath) {
-    const pathSegments = filePath.toLowerCase().split("/");
-    for (const segment of pathSegments) {
-      const singularSegment = singularize(segment);
-      for (const keyword of domainKeywords) {
-        if (singularSegment === keyword || segment === keyword || segment.includes(keyword)) {
-          return keyword;
-        }
-      }
-    }
-  }
-  return "unknown";
-}
-function generateConsolidationPlan(domain, files, targetFiles) {
-  const plan = [];
-  if (files.length <= targetFiles) {
-    return [`No consolidation needed for ${domain}`];
-  }
-  plan.push(
-    `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s):`
-  );
-  const dirGroups = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const dir = file.split("/").slice(0, -1).join("/");
-    if (!dirGroups.has(dir)) {
-      dirGroups.set(dir, []);
-    }
-    dirGroups.get(dir).push(file);
-  }
-  plan.push(`1. Create unified ${domain} module file`);
-  plan.push(
-    `2. Move related functionality from ${files.length} scattered files`
-  );
-  plan.push(`3. Update imports in dependent files`);
-  plan.push(
-    `4. Remove old files after consolidation (verify with tests first)`
-  );
-  return plan;
-}
-function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
-  try {
-    const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
-    return astExports.map((exp) => ({
-      name: exp.name,
-      type: exp.type,
-      inferredDomain: inferDomain(
-        exp.name,
-        filePath,
-        domainOptions,
-        fileImports
-      ),
-      imports: exp.imports,
-      dependencies: exp.dependencies
-    }));
-  } catch (error) {
-    void error;
-    return extractExports(content, filePath, domainOptions, fileImports);
-  }
-}
-function calculateEnhancedCohesion(exports2, filePath, options) {
-  if (exports2.length === 0) return 1;
-  if (exports2.length === 1) return 1;
-  if (filePath && isTestFile(filePath)) {
-    return 1;
-  }
-  const domainCohesion = calculateDomainCohesion(exports2);
-  const hasImportData = exports2.some((e) => e.imports && e.imports.length > 0);
-  const importCohesion = hasImportData ? calculateImportBasedCohesion(exports2) : void 0;
-  const coUsageMatrix = options?.coUsageMatrix;
-  const structuralCohesion = filePath && coUsageMatrix ? calculateStructuralCohesionFromCoUsage(filePath, coUsageMatrix) : void 0;
-  const defaultWeights = {
-    importBased: 0.5,
-    structural: 0.3,
-    domainBased: 0.2
-  };
-  const weights = { ...defaultWeights, ...options?.weights || {} };
-  const signals = [];
-  if (importCohesion !== void 0)
-    signals.push({ score: importCohesion, weight: weights.importBased });
-  if (structuralCohesion !== void 0)
-    signals.push({ score: structuralCohesion, weight: weights.structural });
-  signals.push({ score: domainCohesion, weight: weights.domainBased });
-  const totalWeight = signals.reduce((s, el) => s + el.weight, 0);
-  if (totalWeight === 0) return domainCohesion;
-  const combined = signals.reduce(
-    (sum, el) => sum + el.score * (el.weight / totalWeight),
-    0
-  );
-  return combined;
-}
-function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
-  if (!coUsageMatrix) return 1;
-  const coUsages = coUsageMatrix.get(file);
-  if (!coUsages || coUsages.size === 0) return 1;
-  let total = 0;
-  for (const count of coUsages.values()) total += count;
-  if (total === 0) return 1;
-  const probs = [];
-  for (const count of coUsages.values()) {
-    if (count > 0) probs.push(count / total);
-  }
-  if (probs.length <= 1) return 1;
-  let entropy = 0;
-  for (const prob of probs) {
-    entropy -= prob * Math.log2(prob);
-  }
-  const maxEntropy = Math.log2(probs.length);
-  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
-}
-function calculateImportBasedCohesion(exports2) {
-  const exportsWithImports = exports2.filter(
-    (e) => e.imports && e.imports.length > 0
-  );
-  if (exportsWithImports.length < 2) {
-    return 1;
-  }
-  let totalSimilarity = 0;
-  let comparisons = 0;
-  for (let i = 0; i < exportsWithImports.length; i++) {
-    for (let j = i + 1; j < exportsWithImports.length; j++) {
-      const exp1 = exportsWithImports[i];
-      const exp2 = exportsWithImports[j];
-      const similarity = calculateJaccardSimilarity(exp1.imports, exp2.imports);
-      totalSimilarity += similarity;
-      comparisons++;
-    }
-  }
-  return comparisons > 0 ? totalSimilarity / comparisons : 1;
-}
-function calculateJaccardSimilarity(arr1, arr2) {
-  if (arr1.length === 0 && arr2.length === 0) return 1;
-  if (arr1.length === 0 || arr2.length === 0) return 0;
-  const set1 = new Set(arr1);
-  const set2 = new Set(arr2);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
-function calculateDomainCohesion(exports2) {
-  const domains = exports2.map((e) => e.inferredDomain || "unknown");
-  const domainCounts = /* @__PURE__ */ new Map();
-  for (const domain of domains) {
-    domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
-  }
-  const total = domains.length;
-  let entropy = 0;
-  for (const domainCount of domainCounts.values()) {
-    const prob = domainCount / total;
-    if (prob > 0) {
-      entropy -= prob * Math.log2(prob);
-    }
-  }
-  const maxEntropy = Math.log2(total);
-  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
-}
-function classifyFile(node, cohesionScore, domains) {
-  const { exports: exports2, imports, linesOfCode, file } = node;
-  void imports;
-  void linesOfCode;
+
+// src/classifier.ts
+function classifyFile(node, cohesionScore = 1, domains = []) {
   if (isBarrelExport(node)) {
     return "barrel-export";
   }
-  if (isTypeDefinitionFile(node)) {
+  if (isTypeDefinition(node)) {
     return "type-definition";
   }
-  if (isConfigOrSchemaFile(node)) {
-    return "cohesive-module";
+  if (isNextJsPage(node)) {
+    return "nextjs-page";
   }
   if (isLambdaHandler(node)) {
     return "lambda-handler";
   }
-  if (isDataAccessFile(node)) {
-    return "cohesive-module";
+  if (isServiceFile(node)) {
+    return "service-file";
   }
   if (isEmailTemplate(node)) {
     return "email-template";
@@ -1063,224 +936,53 @@ function classifyFile(node, cohesionScore, domains) {
   if (isParserFile(node)) {
     return "parser-file";
   }
-  if (isServiceFile(node)) {
-    return "service-file";
-  }
   if (isSessionFile(node)) {
-    return "cohesive-module";
-  }
-  if (isNextJsPage(node)) {
-    return "nextjs-page";
-  }
-  if (isUtilityFile(node)) {
+    if (cohesionScore >= 0.25 && domains.length <= 1) return "cohesive-module";
     return "utility-module";
   }
-  if (file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/")) {
+  if (isUtilityModule(node)) {
     return "utility-module";
   }
-  const uniqueDomains = domains.filter((d) => d !== "unknown");
-  const hasSingleDomain = uniqueDomains.length <= 1;
-  if (hasSingleDomain) {
+  if (isConfigFile(node)) {
     return "cohesive-module";
   }
-  if (allExportsShareEntityNoun(exports2)) {
+  if (domains.length <= 1 && domains[0] !== "unknown") {
     return "cohesive-module";
   }
-  const hasMultipleDomains = uniqueDomains.length > 1;
-  const hasLowCohesion = cohesionScore < 0.4;
-  if (hasMultipleDomains && hasLowCohesion) {
+  if (domains.length > 1 && cohesionScore < 0.4) {
     return "mixed-concerns";
   }
-  if (cohesionScore >= 0.5) {
+  if (cohesionScore >= 0.7) {
     return "cohesive-module";
   }
   return "unknown";
 }
 function isBarrelExport(node) {
-  const { file, exports: exports2, imports, linesOfCode } = node;
-  const fileName = file.split("/").pop()?.toLowerCase();
-  const isIndexFile = fileName === "index.ts" || fileName === "index.js" || fileName === "index.tsx" || fileName === "index.jsx";
-  const hasReExports = exports2.length > 0 && imports.length > 0;
-  const highExportToLinesRatio = exports2.length > 3 && linesOfCode < exports2.length * 5;
-  const sparseCode = linesOfCode > 0 && linesOfCode < 50 && exports2.length >= 2;
-  if (isIndexFile && hasReExports) {
-    return true;
-  }
-  if (highExportToLinesRatio && imports.length >= exports2.length * 0.5) {
-    return true;
-  }
-  if (sparseCode && imports.length > 0) {
-    return true;
-  }
-  return false;
-}
-function isTypeDefinitionFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase();
-  const isTypesFile = fileName?.includes("types") || fileName?.includes(".d.ts") || fileName === "types.ts" || fileName === "interfaces.ts";
-  const lowerPath = file.toLowerCase();
-  const isTypesPath = lowerPath.includes("/types/") || lowerPath.includes("/typings/") || lowerPath.includes("/@types/") || lowerPath.startsWith("types/") || lowerPath.startsWith("typings/");
-  const typeExports = exports2.filter(
-    (e) => e.type === "type" || e.type === "interface"
+  const isIndexFile = fileName === "index.ts" || fileName === "index.js";
+  const isSmallAndManyExports = node.tokenCost < 1e3 && (exports2 || []).length > 5;
+  const isReexportPattern = (exports2 || []).length >= 5 && (exports2 || []).every(
+    (e) => e.type === "const" || e.type === "function" || e.type === "type" || e.type === "interface"
   );
-  const runtimeExports = exports2.filter(
-    (e) => e.type === "function" || e.type === "class" || e.type === "const"
-  );
-  const mostlyTypes = exports2.length > 0 && typeExports.length > runtimeExports.length && typeExports.length / exports2.length > 0.7;
-  const pureTypeFile = exports2.length > 0 && typeExports.length === exports2.length;
-  const emptyOrReExportInTypesDir = isTypesPath && exports2.length === 0;
-  return isTypesFile || isTypesPath || mostlyTypes || pureTypeFile || emptyOrReExportInTypesDir;
-}
-function isConfigOrSchemaFile(node) {
-  const { file, exports: exports2 } = node;
+  return !!isIndexFile || !!isSmallAndManyExports || !!isReexportPattern;
+}
+function isTypeDefinition(node) {
+  const { file } = node;
+  if (file.endsWith(".d.ts")) return true;
+  const nodeExports = node.exports || [];
+  const hasExports = nodeExports.length > 0;
+  const areAllTypes = hasExports && nodeExports.every((e) => e.type === "type" || e.type === "interface");
+  const allTypes = !!areAllTypes;
+  const isTypePath = file.toLowerCase().includes("/types/") || file.toLowerCase().includes("/interfaces/") || file.toLowerCase().includes("/models/");
+  return allTypes || isTypePath && hasExports;
+}
+function isUtilityModule(node) {
+  const { file } = node;
+  const isUtilPath = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/") || file.toLowerCase().includes("/util/") || file.toLowerCase().includes("/helper/");
   const fileName = file.split("/").pop()?.toLowerCase();
-  const configPatterns = [
-    "config",
-    "schema",
-    "settings",
-    "options",
-    "constants",
-    "env",
-    "environment",
-    ".config.",
-    "-config.",
-    "_config."
-  ];
-  const isConfigName = configPatterns.some(
-    (pattern) => fileName?.includes(pattern) || fileName?.startsWith(pattern) || fileName?.endsWith(`${pattern}.ts`)
-  );
-  const isConfigPath = file.toLowerCase().includes("/config/") || file.toLowerCase().includes("/schemas/") || file.toLowerCase().includes("/settings/");
-  const hasSchemaExports = exports2.some(
-    (e) => e.name.toLowerCase().includes("table") || e.name.toLowerCase().includes("schema") || e.name.toLowerCase().includes("config") || e.name.toLowerCase().includes("setting")
-  );
-  return isConfigName || isConfigPath || hasSchemaExports;
-}
-function isUtilityFile(node) {
-  const { file, exports: exports2 } = node;
-  const fileName = file.split("/").pop()?.toLowerCase();
-  const utilityPatterns = [
-    "util",
-    "utility",
-    "utilities",
-    "helper",
-    "helpers",
-    "common",
-    "shared",
-    "toolbox",
-    "toolkit",
-    ".util.",
-    "-util.",
-    "_util.",
-    "-utils.",
-    ".utils."
-  ];
-  const isUtilityName = utilityPatterns.some(
-    (pattern) => fileName?.includes(pattern)
-  );
-  const isUtilityPath = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/") || file.toLowerCase().includes("/common/") || file.toLowerCase().endsWith("-utils.ts") || file.toLowerCase().endsWith("-util.ts") || file.toLowerCase().endsWith("-helper.ts") || file.toLowerCase().endsWith("-helpers.ts");
-  const hasManySmallExportsInUtilityContext = exports2.length >= 3 && exports2.every((e) => e.type === "function" || e.type === "const") && (isUtilityName || isUtilityPath);
-  return isUtilityName || isUtilityPath || hasManySmallExportsInUtilityContext;
-}
-function splitCamelCase(name) {
-  return name.replace(/([A-Z])/g, " $1").trim().toLowerCase().split(/[\s_-]+/).filter(Boolean);
-}
-var SKIP_WORDS = /* @__PURE__ */ new Set([
-  "get",
-  "set",
-  "create",
-  "update",
-  "delete",
-  "fetch",
-  "save",
-  "load",
-  "parse",
-  "format",
-  "validate",
-  "convert",
-  "transform",
-  "build",
-  "generate",
-  "render",
-  "send",
-  "receive",
-  "find",
-  "list",
-  "add",
-  "remove",
-  "insert",
-  "upsert",
-  "put",
-  "read",
-  "write",
-  "check",
-  "handle",
-  "process",
-  "compute",
-  "calculate",
-  "init",
-  "reset",
-  "clear",
-  "pending",
-  "active",
-  "current",
-  "new",
-  "old",
-  "all",
-  "by",
-  "with",
-  "from",
-  "to",
-  "and",
-  "or",
-  "is",
-  "has",
-  "in",
-  "on",
-  "of",
-  "the"
-]);
-function simpleSingularize(word) {
-  if (word.endsWith("ies") && word.length > 3) return word.slice(0, -3) + "y";
-  if (word.endsWith("ses") && word.length > 4) return word.slice(0, -2);
-  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
-  return word;
-}
-function extractEntityNouns(name) {
-  return splitCamelCase(name).filter((token) => !SKIP_WORDS.has(token) && token.length > 2).map(simpleSingularize);
-}
-function allExportsShareEntityNoun(exports2) {
-  if (exports2.length < 2 || exports2.length > 30) return false;
-  const nounSets = exports2.map((e) => new Set(extractEntityNouns(e.name)));
-  if (nounSets.some((s) => s.size === 0)) return false;
-  const [first, ...rest] = nounSets;
-  const commonNouns = Array.from(first).filter(
-    (noun) => rest.every((s) => s.has(noun))
-  );
-  return commonNouns.length > 0;
-}
-function isDataAccessFile(node) {
-  const { file, exports: exports2 } = node;
-  const fileName = file.split("/").pop()?.toLowerCase();
-  const dalPatterns = [
-    "dynamo",
-    "database",
-    "repository",
-    "repo",
-    "dao",
-    "firestore",
-    "postgres",
-    "mysql",
-    "mongo",
-    "redis",
-    "sqlite",
-    "supabase",
-    "prisma"
-  ];
-  const isDalName = dalPatterns.some((p) => fileName?.includes(p));
-  const isDalPath = file.toLowerCase().includes("/repositories/") || file.toLowerCase().includes("/dao/") || file.toLowerCase().includes("/data/");
-  const hasDalExportPattern = exports2.length >= 1 && exports2.length <= 10 && allExportsShareEntityNoun(exports2);
-  const isUtilityPathLocal = file.toLowerCase().includes("/utils/") || file.toLowerCase().includes("/helpers/");
-  return isDalPath || isDalName && hasDalExportPattern && !isUtilityPathLocal;
+  const isUtilName = fileName?.includes("utils.") || fileName?.includes("helpers.") || fileName?.includes("util.") || fileName?.includes("helper.");
+  return !!isUtilPath || !!isUtilName;
 }
 function isLambdaHandler(node) {
   const { file, exports: exports2 } = node;
@@ -1297,11 +999,10 @@ function isLambdaHandler(node) {
     (pattern) => fileName?.includes(pattern)
   );
   const isHandlerPath = file.toLowerCase().includes("/handlers/") || file.toLowerCase().includes("/lambdas/") || file.toLowerCase().includes("/lambda/") || file.toLowerCase().includes("/functions/");
-  const hasHandlerExport = exports2.some(
+  const hasHandlerExport = (exports2 || []).some(
     (e) => e.name.toLowerCase() === "handler" || e.name.toLowerCase() === "main" || e.name.toLowerCase() === "lambdahandler" || e.name.toLowerCase().endsWith("handler")
   );
-  const hasSingleEntryInHandlerContext = exports2.length === 1 && (exports2[0].type === "function" || exports2[0].name === "default") && (isHandlerPath || isHandlerName);
-  return isHandlerName || isHandlerPath || hasHandlerExport || hasSingleEntryInHandlerContext;
+  return !!isHandlerName || !!isHandlerPath || !!hasHandlerExport;
 }
 function isServiceFile(node) {
   const { file, exports: exports2 } = node;
@@ -1311,11 +1012,11 @@ function isServiceFile(node) {
     (pattern) => fileName?.includes(pattern)
   );
   const isServicePath = file.toLowerCase().includes("/services/");
-  const hasServiceNamedExport = exports2.some(
+  const hasServiceNamedExport = (exports2 || []).some(
     (e) => e.name.toLowerCase().includes("service") || e.name.toLowerCase().endsWith("service")
   );
-  const hasClassExport = exports2.some((e) => e.type === "class");
-  return isServiceName || isServicePath || hasServiceNamedExport && hasClassExport;
+  const hasClassExport = (exports2 || []).some((e) => e.type === "class");
+  return !!isServiceName || !!isServicePath || !!hasServiceNamedExport && !!hasClassExport;
 }
 function isEmailTemplate(node) {
   const { file, exports: exports2 } = node;
@@ -1333,15 +1034,11 @@ function isEmailTemplate(node) {
   const isEmailTemplateName = emailTemplatePatterns.some(
     (pattern) => fileName?.includes(pattern)
   );
-  const isSpecificTemplateName = fileName?.includes("receipt") || fileName?.includes("invoice-email") || fileName?.includes("welcome-email") || fileName?.includes("notification-email") || fileName?.includes("writer") && fileName.includes("receipt");
   const isEmailPath = file.toLowerCase().includes("/emails/") || file.toLowerCase().includes("/mail/") || file.toLowerCase().includes("/notifications/");
-  const hasTemplateFunction = exports2.some(
+  const hasTemplateFunction = (exports2 || []).some(
     (e) => e.type === "function" && (e.name.toLowerCase().startsWith("render") || e.name.toLowerCase().startsWith("generate") || e.name.toLowerCase().includes("template") && e.name.toLowerCase().includes("email"))
   );
-  const hasEmailExport = exports2.some(
-    (e) => e.name.toLowerCase().includes("template") && e.type === "function" || e.name.toLowerCase().includes("render") && e.type === "function" || e.name.toLowerCase().includes("email") && e.type !== "class"
-  );
-  return isEmailPath || isEmailTemplateName || isSpecificTemplateName || hasTemplateFunction && hasEmailExport;
+  return !!isEmailPath || !!isEmailTemplateName || !!hasTemplateFunction;
 }
 function isParserFile(node) {
   const { file, exports: exports2 } = node;
@@ -1353,55 +1050,51 @@ function isParserFile(node) {
     "_parser.",
     "transform",
     ".transform.",
-    "-transform.",
     "converter",
-    ".converter.",
-    "-converter.",
     "mapper",
-    ".mapper.",
-    "-mapper.",
-    "serializer",
-    ".serializer.",
-    "deterministic"
-    // For base-parser-deterministic.ts pattern
+    "serializer"
   ];
   const isParserName = parserPatterns.some(
     (pattern) => fileName?.includes(pattern)
   );
-  const isParserPath = file.toLowerCase().includes("/parsers/") || file.toLowerCase().includes("/transformers/") || file.toLowerCase().includes("/converters/") || file.toLowerCase().includes("/mappers/");
-  const hasParserExport = exports2.some(
-    (e) => e.name.toLowerCase().includes("parse") || e.name.toLowerCase().includes("transform") || e.name.toLowerCase().includes("convert") || e.name.toLowerCase().includes("map") || e.name.toLowerCase().includes("serialize") || e.name.toLowerCase().includes("deserialize")
+  const isParserPath = file.toLowerCase().includes("/parsers/") || file.toLowerCase().includes("/transformers/");
+  const hasParseFunction = (exports2 || []).some(
+    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("extract"))
   );
-  const hasParseFunction = exports2.some(
-    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("convert") || e.name.toLowerCase().startsWith("map") || e.name.toLowerCase().startsWith("extract"))
-  );
-  return isParserName || isParserPath || hasParserExport || hasParseFunction;
+  return !!isParserName || !!isParserPath || !!hasParseFunction;
 }
 function isSessionFile(node) {
   const { file, exports: exports2 } = node;
   const fileName = file.split("/").pop()?.toLowerCase();
-  const sessionPatterns = [
-    "session",
-    ".session.",
-    "-session.",
-    "state",
-    ".state.",
-    "-state.",
-    "context",
-    ".context.",
-    "-context.",
-    "store",
-    ".store.",
-    "-store."
-  ];
+  const sessionPatterns = ["session", "state", "context", "store"];
   const isSessionName = sessionPatterns.some(
     (pattern) => fileName?.includes(pattern)
   );
-  const isSessionPath = file.toLowerCase().includes("/sessions/") || file.toLowerCase().includes("/state/") || file.toLowerCase().includes("/context/") || file.toLowerCase().includes("/store/");
-  const hasSessionExport = exports2.some(
-    (e) => e.name.toLowerCase().includes("session") || e.name.toLowerCase().includes("state") || e.name.toLowerCase().includes("context") || e.name.toLowerCase().includes("manager") || e.name.toLowerCase().includes("store")
+  const isSessionPath = file.toLowerCase().includes("/sessions/") || file.toLowerCase().includes("/state/");
+  const hasSessionExport = (exports2 || []).some(
+    (e) => e.name.toLowerCase().includes("session") || e.name.toLowerCase().includes("state") || e.name.toLowerCase().includes("store")
   );
-  return isSessionName || isSessionPath || hasSessionExport;
+  return !!isSessionName || !!isSessionPath || !!hasSessionExport;
+}
+function isConfigFile(node) {
+  const { file, exports: exports2 } = node;
+  const lowerPath = file.toLowerCase();
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const configPatterns = [
+    ".config.",
+    "tsconfig",
+    "jest.config",
+    "package.json",
+    "aiready.json",
+    "next.config",
+    "sst.config"
+  ];
+  const isConfigName = configPatterns.some((p) => fileName?.includes(p));
+  const isConfigPath = lowerPath.includes("/config/") || lowerPath.includes("/settings/") || lowerPath.includes("/schemas/");
+  const hasSchemaExports = (exports2 || []).some(
+    (e) => e.name.toLowerCase().includes("schema") || e.name.toLowerCase().includes("config") || e.name.toLowerCase().includes("setting")
+  );
+  return !!isConfigName || !!isConfigPath || !!hasSchemaExports;
 }
 function isNextJsPage(node) {
   const { file, exports: exports2 } = node;
@@ -1409,24 +1102,19 @@ function isNextJsPage(node) {
   const fileName = file.split("/").pop()?.toLowerCase();
   const isInAppDir = lowerPath.includes("/app/") || lowerPath.startsWith("app/");
   const isPageFile = fileName === "page.tsx" || fileName === "page.ts";
-  if (!isInAppDir || !isPageFile) {
-    return false;
-  }
-  const exportNames = exports2.map((e) => e.name.toLowerCase());
-  const hasDefaultExport = exports2.some((e) => e.type === "default");
+  if (!isInAppDir || !isPageFile) return false;
+  const hasDefaultExport = (exports2 || []).some((e) => e.type === "default");
   const nextJsExports = [
     "metadata",
     "generatemetadata",
     "faqjsonld",
     "jsonld",
-    "icon",
-    "viewport",
-    "dynamic"
+    "icon"
   ];
-  const hasNextJsExports = exportNames.some(
-    (name) => nextJsExports.includes(name) || name.includes("jsonld")
+  const hasNextJsExports = (exports2 || []).some(
+    (e) => nextJsExports.includes(e.name.toLowerCase())
   );
-  return hasDefaultExport || hasNextJsExports;
+  return !!hasDefaultExport || !!hasNextJsExports;
 }
 function adjustCohesionForClassification(baseCohesion, classification, node) {
   switch (classification) {
@@ -1434,55 +1122,24 @@ function adjustCohesionForClassification(baseCohesion, classification, node) {
       return 1;
     case "type-definition":
       return 1;
+    case "nextjs-page":
+      return 1;
     case "utility-module": {
-      if (node) {
-        const exportNames = node.exports.map((e) => e.name.toLowerCase());
-        const hasRelatedNames = hasRelatedExportNames(exportNames);
-        if (hasRelatedNames) {
-          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
-        }
+      if (node && hasRelatedExportNames(
+        (node.exports || []).map((e) => e.name.toLowerCase())
+      )) {
+        return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
       }
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
     }
-    case "service-file": {
-      if (node?.exports.some((e) => e.type === "class")) {
-        return Math.max(0.78, Math.min(1, baseCohesion + 0.4));
-      }
+    case "service-file":
       return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
-    }
-    case "lambda-handler": {
-      if (node) {
-        const hasSingleEntry = node.exports.length === 1 || node.exports.some((e) => e.name.toLowerCase() === "handler");
-        if (hasSingleEntry) {
-          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
-        }
-      }
+    case "lambda-handler":
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
-    }
-    case "email-template": {
-      if (node) {
-        const hasTemplateFunc = node.exports.some(
-          (e) => e.name.toLowerCase().includes("render") || e.name.toLowerCase().includes("generate") || e.name.toLowerCase().includes("template")
-        );
-        if (hasTemplateFunc) {
-          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
-        }
-      }
+    case "email-template":
       return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
-    }
-    case "parser-file": {
-      if (node) {
-        const hasParseFunc = node.exports.some(
-          (e) => e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("convert")
-        );
-        if (hasParseFunc) {
-          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
-        }
-      }
+    case "parser-file":
       return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
-    }
-    case "nextjs-page":
-      return 1;
     case "cohesive-module":
       return Math.max(baseCohesion, 0.7);
     case "mixed-concerns":
@@ -1495,136 +1152,138 @@ function hasRelatedExportNames(exportNames) {
   if (exportNames.length < 2) return true;
   const stems = /* @__PURE__ */ new Set();
   const domains = /* @__PURE__ */ new Set();
+  const verbs = [
+    "get",
+    "set",
+    "create",
+    "update",
+    "delete",
+    "fetch",
+    "save",
+    "load",
+    "parse",
+    "format",
+    "validate"
+  ];
+  const domainPatterns = [
+    "user",
+    "order",
+    "product",
+    "session",
+    "email",
+    "file",
+    "db",
+    "api",
+    "config"
+  ];
   for (const name of exportNames) {
-    const verbs = [
-      "get",
-      "set",
-      "create",
-      "update",
-      "delete",
-      "fetch",
-      "save",
-      "load",
-      "parse",
-      "format",
-      "validate",
-      "convert",
-      "transform",
-      "build",
-      "generate",
-      "render",
-      "send",
-      "receive"
-    ];
     for (const verb of verbs) {
       if (name.startsWith(verb) && name.length > verb.length) {
         stems.add(name.slice(verb.length).toLowerCase());
       }
     }
-    const domainPatterns = [
-      "user",
-      "order",
-      "product",
-      "session",
-      "email",
-      "file",
-      "db",
-      "s3",
-      "dynamo",
-      "api",
-      "config"
-    ];
     for (const domain of domainPatterns) {
-      if (name.includes(domain)) {
-        domains.add(domain);
+      if (name.includes(domain)) domains.add(domain);
+    }
+  }
+  if (stems.size === 1 || domains.size === 1) return true;
+  return false;
+}
+function adjustFragmentationForClassification(baseFragmentation, classification) {
+  switch (classification) {
+    case "barrel-export":
+      return 0;
+    case "type-definition":
+      return 0;
+    case "utility-module":
+    case "service-file":
+    case "lambda-handler":
+    case "email-template":
+    case "parser-file":
+    case "nextjs-page":
+      return baseFragmentation * 0.2;
+    case "cohesive-module":
+      return baseFragmentation * 0.3;
+    case "mixed-concerns":
+      return baseFragmentation;
+    default:
+      return baseFragmentation * 0.7;
+  }
+}
+
+// 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
+      )
+    });
   }
-  if (stems.size === 1 && exportNames.length >= 2) return true;
-  if (domains.size === 1 && exportNames.length >= 2) return true;
-  const prefixes = exportNames.map((name) => {
-    const match = name.match(/^([a-z]+)/);
-    return match ? match[1] : "";
-  }).filter((p) => p.length >= 3);
-  if (prefixes.length >= 2) {
-    const uniquePrefixes = new Set(prefixes);
-    if (uniquePrefixes.size === 1) return true;
-  }
-  const nounSets = exportNames.map((name) => {
-    const tokens = name.replace(/([A-Z])/g, " $1").trim().toLowerCase().split(/[\s_-]+/).filter(Boolean);
-    const skip = /* @__PURE__ */ new Set([
-      "get",
-      "set",
-      "create",
-      "update",
-      "delete",
-      "fetch",
-      "save",
-      "load",
-      "parse",
-      "format",
-      "validate",
-      "convert",
-      "transform",
-      "build",
-      "generate",
-      "render",
-      "send",
-      "receive",
-      "find",
-      "list",
-      "add",
-      "remove",
-      "insert",
-      "upsert",
-      "put",
-      "read",
-      "write",
-      "check",
-      "handle",
-      "process",
-      "pending",
-      "active",
-      "current",
-      "new",
-      "old",
-      "all"
-    ]);
-    const singularize2 = (w) => w.endsWith("s") && w.length > 3 ? w.slice(0, -1) : w;
-    return new Set(
-      tokens.filter((t) => !skip.has(t) && t.length > 2).map(singularize2)
-    );
-  });
-  if (nounSets.length >= 2 && nounSets.every((s) => s.size > 0)) {
-    const [first, ...rest] = nounSets;
-    const commonNouns = Array.from(first).filter(
-      (n) => rest.every((s) => s.has(n))
+  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 (commonNouns.length > 0) return true;
   }
-  return false;
-}
-function adjustFragmentationForClassification(baseFragmentation, classification) {
-  switch (classification) {
-    case "barrel-export":
-      return 0;
-    case "type-definition":
-      return 0;
-    case "utility-module":
-    case "service-file":
-    case "lambda-handler":
-    case "email-template":
-    case "parser-file":
-    case "nextjs-page":
-      return baseFragmentation * 0.2;
-    case "cohesive-module":
-      return baseFragmentation * 0.3;
-    case "mixed-concerns":
-      return baseFragmentation;
-    default:
-      return baseFragmentation * 0.7;
+  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) {
     case "barrel-export":
@@ -1682,9 +1341,167 @@ function getClassificationRecommendations(classification, file, issues) {
       return issues;
   }
 }
+function getGeneralRecommendations(metrics, thresholds) {
+  const recommendations = [];
+  const issues = [];
+  let severity = "info";
+  if (metrics.contextBudget > thresholds.maxContextBudget) {
+    issues.push(
+      `High context budget: ${Math.round(metrics.contextBudget / 1e3)}k tokens`
+    );
+    recommendations.push(
+      "Reduce dependencies or split the file to lower context window requirements"
+    );
+    severity = "major";
+  }
+  if (metrics.importDepth > thresholds.maxDepth) {
+    issues.push(`Deep import chain: ${metrics.importDepth} levels`);
+    recommendations.push("Flatten the dependency graph by reducing nesting");
+    if (severity !== "critical") severity = "major";
+  }
+  if (metrics.circularDeps.length > 0) {
+    issues.push(
+      `Circular dependencies detected: ${metrics.circularDeps.length}`
+    );
+    recommendations.push(
+      "Refactor to remove circular imports (use dependency injection or interfaces)"
+    );
+    severity = "critical";
+  }
+  if (metrics.cohesionScore < thresholds.minCohesion) {
+    issues.push(`Low cohesion score: ${metrics.cohesionScore.toFixed(2)}`);
+    recommendations.push(
+      "Extract unrelated exports into separate domain-specific modules"
+    );
+    if (severity === "info") severity = "minor";
+  }
+  if (metrics.fragmentationScore > thresholds.maxFragmentation) {
+    issues.push(
+      `High domain fragmentation: ${metrics.fragmentationScore.toFixed(2)}`
+    );
+    recommendations.push(
+      "Consolidate domain-related files into fewer directories"
+    );
+    if (severity === "info") severity = "minor";
+  }
+  return { recommendations, issues, severity };
+}
+
+// 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 = "info";
+  let potentialSavings = 0;
+  if (circularDeps.length > 0) {
+    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 = "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 !== "critical") 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 = "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 !== "critical") 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 !== "critical") 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 === "info") 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 === "info" || severity === "minor") 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 = "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/");
+}
 
 // src/scoring.ts
-var import_core2 = require("@aiready/core");
+var import_core4 = require("@aiready/core");
 function calculateContextScore(summary, costConfig) {
   const {
     avgContextBudget,
@@ -1780,14 +1597,16 @@ function calculateContextScore(summary, costConfig) {
       priority: "high"
     });
   }
-  const cfg = { ...import_core2.DEFAULT_COST_CONFIG, ...costConfig };
-  const totalContextBudget = avgContextBudget * summary.totalFiles;
-  const estimatedMonthlyCost = (0, import_core2.calculateMonthlyCost)(totalContextBudget, cfg);
+  const cfg = { ...import_core4.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core4.calculateMonthlyCost)(
+    avgContextBudget * (summary.totalFiles || 1),
+    cfg
+  );
   const issues = [
     ...Array(criticalIssues).fill({ severity: "critical" }),
     ...Array(majorIssues).fill({ severity: "major" })
   ];
-  const productivityImpact = (0, import_core2.calculateProductivityImpact)(issues);
+  const productivityImpact = (0, import_core4.calculateProductivityImpact)(issues);
   return {
     toolName: "context-analyzer",
     score,
@@ -1799,7 +1618,6 @@ function calculateContextScore(summary, costConfig) {
       avgFragmentation: Math.round(avgFragmentation * 100) / 100,
       criticalIssues,
       majorIssues,
-      // Business value metrics
       estimatedMonthlyCost,
       estimatedDeveloperHours: productivityImpact.totalHours
     },
@@ -1807,10 +1625,18 @@ function calculateContextScore(summary, costConfig) {
     recommendations
   };
 }
+function mapScoreToRating(score) {
+  if (score >= 90) return "excellent";
+  if (score >= 75) return "good";
+  if (score >= 60) return "fair";
+  if (score >= 40) return "needs work";
+  return "critical";
+}
 
-// src/index.ts
+// src/defaults.ts
+var import_core5 = require("@aiready/core");
 async function getSmartDefaults(directory, userOptions) {
-  const files = await (0, import_core4.scanFiles)({
+  const files = await (0, import_core5.scanFiles)({
     rootDir: directory,
     include: userOptions.include,
     exclude: userOptions.exclude
@@ -1842,17 +1668,146 @@ async function getSmartDefaults(directory, userOptions) {
     maxFragmentation = 0.8;
   }
   return {
-    maxDepth,
+    maxDepth,
+    maxContextBudget,
+    minCohesion,
+    maxFragmentation,
+    focus: "all",
+    includeNodeModules: false,
+    rootDir: userOptions.rootDir || directory,
+    include: userOptions.include,
+    exclude: userOptions.exclude
+  };
+}
+
+// src/summary.ts
+function generateSummary(results) {
+  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: []
+    };
+  }
+  const totalFiles = results.length;
+  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
+  const totalContextBudget = results.reduce(
+    (sum, r) => sum + r.contextBudget,
+    0
+  );
+  const avgContextBudget = totalContextBudget / totalFiles;
+  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
+  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
+  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
+  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
+  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    for (const domain of result.domains) {
+      if (!moduleMap.has(domain)) moduleMap.set(domain, []);
+      moduleMap.get(domain).push(result);
+    }
+  }
+  const fragmentedModules = [];
+  for (const [domain, files] of moduleMap.entries()) {
+    let jaccard2 = function(a, b) {
+      const s1 = new Set(a || []);
+      const s2 = new Set(b || []);
+      if (s1.size === 0 && s2.size === 0) return 0;
+      const inter = new Set([...s1].filter((x) => s2.has(x)));
+      const uni = /* @__PURE__ */ new Set([...s1, ...s2]);
+      return uni.size === 0 ? 0 : inter.size / uni.size;
+    };
+    var jaccard = jaccard2;
+    if (files.length < 2) continue;
+    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
+    if (fragmentationScore < 0.3) continue;
+    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
+    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
+    const filePaths = files.map((f) => f.file);
+    const pathEntropy = calculatePathEntropy(filePaths);
+    const directoryDistance = calculateDirectoryDistance(filePaths);
+    let importSimTotal = 0;
+    let importPairs = 0;
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        importSimTotal += jaccard2(
+          files[i].dependencyList || [],
+          files[j].dependencyList || []
+        );
+        importPairs++;
+      }
+    }
+    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
+    fragmentedModules.push({
+      domain,
+      files: files.map((f) => f.file),
+      totalTokens: totalTokens2,
+      fragmentationScore,
+      avgCohesion: avgCohesion2,
+      importCohesion,
+      pathEntropy,
+      directoryDistance,
+      suggestedStructure: {
+        targetFiles,
+        consolidationPlan: [
+          `Consolidate ${files.length} files across ${new Set(files.map((f) => f.file.split("/").slice(0, -1).join("/"))).size} directories`,
+          `Target ~${targetFiles} core modules to reduce context switching`
+        ]
+      }
+    });
+  }
+  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
+  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.4).map((r) => ({ file: r.file, score: r.cohesionScore })).sort((a, b) => a.score - b.score).slice(0, 10);
+  const criticalIssues = results.filter(
+    (r) => r.severity === "critical"
+  ).length;
+  const majorIssues = results.filter((r) => r.severity === "major").length;
+  const minorIssues = results.filter((r) => r.severity === "minor").length;
+  const totalPotentialSavings = results.reduce(
+    (sum, r) => sum + r.potentialSavings,
+    0
+  );
+  const topExpensiveFiles = results.sort((a, b) => b.contextBudget - a.contextBudget).slice(0, 10).map((r) => ({
+    file: r.file,
+    contextBudget: r.contextBudget,
+    severity: r.severity
+  }));
+  return {
+    totalFiles,
+    totalTokens,
+    avgContextBudget,
     maxContextBudget,
-    minCohesion,
-    maxFragmentation,
-    focus: "all",
-    includeNodeModules: false,
-    rootDir: userOptions.rootDir || directory,
-    include: userOptions.include,
-    exclude: userOptions.exclude
+    avgImportDepth,
+    maxImportDepth,
+    deepFiles,
+    avgFragmentation,
+    fragmentedModules,
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles
   };
 }
+
+// src/index.ts
 async function analyzeContext(options) {
   const {
     maxDepth = 5,
@@ -1863,22 +1818,17 @@ async function analyzeContext(options) {
     includeNodeModules = false,
     ...scanOptions
   } = options;
-  const files = await (0, import_core4.scanFiles)({
+  const files = await (0, import_core7.scanFiles)({
     ...scanOptions,
-    // Only add node_modules to exclude if includeNodeModules is false
-    // The DEFAULT_EXCLUDE already includes node_modules, so this is only needed
-    // if user overrides the default exclude list
     exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter(
       (pattern) => pattern !== "**/node_modules/**"
     ) : scanOptions.exclude
   });
   const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
-  const tsJsFiles = files.filter((f) => !f.toLowerCase().endsWith(".py"));
-  void tsJsFiles;
   const fileContents = await Promise.all(
     files.map(async (file) => ({
       file,
-      content: await (0, import_core4.readFileContent)(file)
+      content: await (0, import_core7.readFileContent)(file)
     }))
   );
   const graph = buildDependencyGraph(
@@ -1898,7 +1848,6 @@ async function analyzeContext(options) {
         contextBudget: metric.contextBudget,
         cohesionScore: metric.cohesion,
         fragmentationScore: 0,
-        // Python analyzer doesn't calculate fragmentation yet
         maxDepth,
         maxContextBudget,
         minCohesion,
@@ -1912,7 +1861,6 @@ async function analyzeContext(options) {
         tokenCost: Math.floor(
           metric.contextBudget / (1 + metric.imports.length || 1)
         ),
-        // Estimate
         linesOfCode: metric.metrics.linesOfCode,
         importDepth: metric.importDepth,
         dependencyCount: metric.imports.length,
@@ -1924,13 +1872,11 @@ async function analyzeContext(options) {
         ),
         cohesionScore: metric.cohesion,
         domains: ["python"],
-        // Generic for now
         exportCount: metric.exports.length,
         contextBudget: metric.contextBudget,
         fragmentationScore: 0,
         relatedFiles: [],
         fileClassification: "unknown",
-        // Python files not yet classified
         severity,
         issues,
         recommendations,
@@ -1965,7 +1911,7 @@ async function analyzeContext(options) {
         break;
       }
     }
-    const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
+    const { issues } = analyzeIssues({
       file,
       importDepth,
       contextBudget,
@@ -1977,14 +1923,10 @@ async function analyzeContext(options) {
       maxFragmentation,
       circularDeps
     });
-    void severity;
-    void issues;
-    void recommendations;
-    void potentialSavings;
     const domains = [
       ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
     ];
-    const fileClassification = classifyFile(node, cohesionScore, domains);
+    const fileClassification = classifyFile(node);
     const adjustedCohesionScore = adjustCohesionForClassification(
       cohesionScore,
       fileClassification,
@@ -2009,7 +1951,6 @@ async function analyzeContext(options) {
       importDepth,
       contextBudget,
       cohesionScore: adjustedCohesionScore,
-      // Use adjusted cohesion
       fragmentationScore: adjustedFragmentationScore,
       maxDepth,
       maxContextBudget,
@@ -2026,7 +1967,6 @@ async function analyzeContext(options) {
       dependencyList,
       circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
       cohesionScore: adjustedCohesionScore,
-      // Report adjusted cohesion
       domains,
       exportCount: node.exports.length,
       contextBudget,
@@ -2043,269 +1983,57 @@ async function analyzeContext(options) {
     });
   }
   const allResults = [...results, ...pythonResults];
-  const sorted = allResults.sort((a, b) => {
+  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 sorted;
-}
-function generateSummary(results) {
-  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: []
-    };
-  }
-  const totalFiles = results.length;
-  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
-  const totalContextBudget = results.reduce(
-    (sum, r) => sum + r.contextBudget,
-    0
-  );
-  const avgContextBudget = totalContextBudget / totalFiles;
-  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
-  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
-  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
-  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
-  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
-  const moduleMap = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    for (const domain of result.domains) {
-      if (!moduleMap.has(domain)) {
-        moduleMap.set(domain, []);
-      }
-      moduleMap.get(domain).push(result);
-    }
-  }
-  const fragmentedModules = [];
-  for (const [domain, files] of moduleMap.entries()) {
-    let jaccard2 = function(a, b) {
-      const s1 = new Set(a || []);
-      const s2 = new Set(b || []);
-      if (s1.size === 0 && s2.size === 0) return 0;
-      const inter = new Set([...s1].filter((x) => s2.has(x)));
-      const uni = /* @__PURE__ */ new Set([...s1, ...s2]);
-      return uni.size === 0 ? 0 : inter.size / uni.size;
-    };
-    var jaccard = jaccard2;
-    if (files.length < 2) continue;
-    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
-    if (fragmentationScore < 0.3) continue;
-    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
-    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
-    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
-    const filePaths = files.map((f) => f.file);
-    const pathEntropy = calculatePathEntropy(filePaths);
-    const directoryDistance = calculateDirectoryDistance(filePaths);
-    let importSimTotal = 0;
-    let importPairs = 0;
-    for (let i = 0; i < files.length; i++) {
-      for (let j = i + 1; j < files.length; j++) {
-        importSimTotal += jaccard2(
-          files[i].dependencyList || [],
-          files[j].dependencyList || []
-        );
-        importPairs++;
-      }
-    }
-    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
-    fragmentedModules.push({
-      domain,
-      files: files.map((f) => f.file),
-      totalTokens: totalTokens2,
-      fragmentationScore,
-      pathEntropy,
-      directoryDistance,
-      importCohesion,
-      avgCohesion: avgCohesion2,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan: [
-          `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s)`,
-          `Current token cost: ${totalTokens2.toLocaleString()}`,
-          `Estimated savings: ${Math.floor(totalTokens2 * 0.3).toLocaleString()} tokens (30%)`
-        ]
-      }
-    });
-  }
-  fragmentedModules.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
-  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
-  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.6).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: fragmentedModules.slice(0, 10),
-    avgCohesion,
-    lowCohesionFiles,
-    criticalIssues,
-    majorIssues,
-    minorIssues,
-    totalPotentialSavings,
-    topExpensiveFiles
-  };
-}
-function analyzeIssues(params) {
-  const {
-    file,
-    importDepth,
-    contextBudget,
-    cohesionScore,
-    fragmentationScore,
-    maxDepth,
-    maxContextBudget,
-    minCohesion,
-    maxFragmentation,
-    circularDeps
-  } = params;
-  const issues = [];
-  const recommendations = [];
-  let severity = "info";
-  let potentialSavings = 0;
-  if (circularDeps.length > 0) {
-    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 = severity === "critical" ? "critical" : "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) {
-    severity = severity === "critical" ? "critical" : "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 = severity === "critical" ? "critical" : "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) {
-    severity = severity === "critical" || severity === "major" ? 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) {
-    severity = severity === "critical" ? "critical" : "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) {
-    severity = severity === "critical" || severity === "major" ? severity : "minor";
-    issues.push(`Low cohesion (${(cohesionScore * 100).toFixed(0)}%)`);
-    recommendations.push("Consider grouping related exports together");
-    potentialSavings += contextBudget * 0.1;
-  }
-  if (fragmentationScore > maxFragmentation) {
-    severity = severity === "critical" || severity === "major" ? 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 (e.g., cdk.out, dist, build, .next) from analysis"
-    );
-    severity = downgradeSeverity(severity);
-    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("/output/") || lower.includes("/cdk.out/") || lower.includes("/.next/") || /\/asset\.[^/]+\//.test(lower);
-}
-function downgradeSeverity(s) {
-  switch (s) {
-    case "critical":
-      return "minor";
-    case "major":
-      return "minor";
-    case "minor":
-      return "info";
-    default:
-      return "info";
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  adjustCohesionForClassification,
   adjustFragmentationForClassification,
   analyzeContext,
+  analyzeIssues,
   buildCoUsageMatrix,
+  buildDependencyGraph,
   buildTypeGraph,
+  calculateCohesion,
+  calculateContextBudget,
   calculateContextScore,
+  calculateDirectoryDistance,
   calculateDomainConfidence,
+  calculateEnhancedCohesion,
+  calculateFragmentation,
+  calculateImportDepth,
+  calculatePathEntropy,
+  calculateStructuralCohesionFromCoUsage,
   classifyFile,
+  detectCircularDependencies,
+  detectModuleClusters,
+  extractDomainKeywordsFromPaths,
+  extractExports,
+  extractImportsFromContent,
   findConsolidationCandidates,
   findSemanticClusters,
   generateSummary,
+  getClassificationRecommendations,
   getCoUsageData,
+  getGeneralRecommendations,
   getSmartDefaults,
-  inferDomainFromSemantics
+  getTransitiveDependencies,
+  inferDomain,
+  inferDomainFromSemantics,
+  isBarrelExport,
+  isConfigFile,
+  isEmailTemplate,
+  isLambdaHandler,
+  isNextJsPage,
+  isParserFile,
+  isServiceFile,
+  isSessionFile,
+  isTypeDefinition,
+  isUtilityModule,
+  mapScoreToRating
 });