@aiready/context-analyzer 0.9.41 → 0.9.42

package/dist/chunk-UG7OPVHB.mjs

@@ -0,0 +1,1521 @@
+// src/index.ts
+import { scanFiles as scanFiles2, readFileContent } from "@aiready/core";
+
+// src/graph-builder.ts
+import { estimateTokens } from "@aiready/core";
+
+// src/semantic-analysis.ts
+function buildCoUsageMatrix(graph) {
+  const coUsageMatrix = /* @__PURE__ */ new Map();
+  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());
+      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());
+        const fileBUsage = coUsageMatrix.get(fileB);
+        fileBUsage.set(fileA, (fileBUsage.get(fileA) || 0) + 1);
+      }
+    }
+  }
+  return coUsageMatrix;
+}
+function buildTypeGraph(graph) {
+  const typeGraph = /* @__PURE__ */ new Map();
+  for (const [file, node] of graph.nodes) {
+    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());
+          typeGraph.get(typeRef).add(file);
+        }
+      }
+    }
+  }
+  return typeGraph;
+}
+function findSemanticClusters(coUsageMatrix, minCoUsage = 3) {
+  const clusters = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  for (const [file, coUsages] of coUsageMatrix) {
+    if (visited.has(file)) continue;
+    const cluster = [file];
+    visited.add(file);
+    for (const [relatedFile, count] of coUsages) {
+      if (count >= minCoUsage && !visited.has(relatedFile)) {
+        cluster.push(relatedFile);
+        visited.add(relatedFile);
+      }
+    }
+    if (cluster.length > 1) clusters.set(file, cluster);
+  }
+  return clusters;
+}
+function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGraph, exportTypeRefs) {
+  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);
+  for (const coFile of strongCoUsages) {
+    const coNode = graph.nodes.get(coFile);
+    if (coNode) {
+      for (const exp of coNode.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).coUsage = true;
+        }
+      }
+    }
+  }
+  if (exportTypeRefs) {
+    for (const typeRef of exportTypeRefs) {
+      const filesWithType = typeGraph.get(typeRef);
+      if (filesWithType) {
+        for (const typeFile of filesWithType) {
+          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;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const assignments = [];
+  for (const [domain, signals] of domainSignals) {
+    const confidence = calculateDomainConfidence(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 exports = [];
+  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);
+      exports.push({ name, type, inferredDomain });
+    }
+  });
+  return exports;
+}
+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) {
+  return { file, coImportedWith: coUsageMatrix.get(file) || /* @__PURE__ */ new Map(), sharedImporters: [] };
+}
+function findConsolidationCandidates(graph, coUsageMatrix, typeGraph, minCoUsage = 5, minSharedTypes = 2) {
+  const candidates = [];
+  for (const [fileA, coUsages] of coUsageMatrix) {
+    const nodeA = graph.nodes.get(fileA);
+    if (!nodeA) 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(nodeA.exports.flatMap((e) => e.typeReferences || []));
+      const typesB = new Set(nodeB.exports.flatMap((e) => e.typeReferences || []));
+      const sharedTypes = Array.from(typesA).filter((t) => typesB.has(t));
+      if (sharedTypes.length >= minSharedTypes || count >= minCoUsage * 2) {
+        candidates.push({ files: [fileA, fileB], reason: `High co-usage (${count}x)`, strength: count / 10 });
+      }
+    }
+  }
+  return candidates.sort((a, b) => b.strength - a.strength);
+}
+
+// src/ast-utils.ts
+import { parseFileExports } from "@aiready/core";
+function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
+  try {
+    const { exports: astExports } = 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("/__mocks__/") || lower.includes("/mocks/") || lower.includes("/fixtures/") || lower.includes(".mock.") || lower.includes(".fixture.") || lower.includes("/test-utils/");
+}
+
+// src/graph-builder.ts
+function extractDomainKeywordsFromPaths(files) {
+  const folderNames = /* @__PURE__ */ new Set();
+  for (const { file } of files) {
+    const segments = file.split("/");
+    const skipFolders = /* @__PURE__ */ new Set([
+      "src",
+      "lib",
+      "dist",
+      "build",
+      "node_modules",
+      "test",
+      "tests",
+      "__tests__",
+      "spec",
+      "e2e",
+      "scripts",
+      "components",
+      "utils",
+      "helpers",
+      "util",
+      "helper",
+      "api",
+      "apis"
+    ]);
+    for (const segment of segments) {
+      const normalized = segment.toLowerCase();
+      if (normalized && !skipFolders.has(normalized) && !normalized.includes(".")) {
+        folderNames.add(singularize2(normalized));
+      }
+    }
+  }
+  return Array.from(folderNames);
+}
+function singularize2(word) {
+  const irregulars = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman"
+  };
+  if (irregulars[word]) return irregulars[word];
+  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
+  if (word.endsWith("ses")) return word.slice(0, -2);
+  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+function buildDependencyGraph(files, options) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
+  for (const { file, content } of files) {
+    const imports = extractImportsFromContent(content);
+    const exports = extractExportsWithAST(
+      content,
+      file,
+      { domainKeywords: autoDetectedKeywords },
+      imports
+    );
+    const tokenCost = estimateTokens(content);
+    const linesOfCode = content.split("\n").length;
+    nodes.set(file, { file, imports, exports, tokenCost, linesOfCode });
+    edges.set(file, new Set(imports));
+  }
+  const graph = { nodes, edges };
+  const coUsageMatrix = buildCoUsageMatrix(graph);
+  const typeGraph = buildTypeGraph(graph);
+  graph.coUsageMatrix = coUsageMatrix;
+  graph.typeGraph = typeGraph;
+  for (const [file, node] of nodes) {
+    for (const exp of node.exports) {
+      const semanticAssignments = inferDomainFromSemantics(
+        file,
+        exp.name,
+        graph,
+        coUsageMatrix,
+        typeGraph,
+        exp.typeReferences
+      );
+      exp.domains = semanticAssignments;
+      if (semanticAssignments.length > 0) {
+        exp.inferredDomain = semanticAssignments[0].domain;
+      }
+    }
+  }
+  return graph;
+}
+function extractImportsFromContent(content) {
+  const imports = [];
+  const patterns = [
+    /import\s+.*?\s+from\s+['"](.+?)['"]/g,
+    /import\s+['"](.+?)['"]/g,
+    /require\(['"](.+?)['"]\)/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath && !importPath.startsWith("node:")) {
+        imports.push(importPath);
+      }
+    }
+  }
+  return [...new Set(imports)];
+}
+function calculateImportDepth(file, graph, visited = /* @__PURE__ */ new Set(), depth = 0) {
+  if (visited.has(file)) return depth;
+  const dependencies = graph.edges.get(file);
+  if (!dependencies || dependencies.size === 0) return depth;
+  visited.add(file);
+  let maxDepth = depth;
+  for (const dep of dependencies) {
+    maxDepth = Math.max(
+      maxDepth,
+      calculateImportDepth(dep, graph, visited, depth + 1)
+    );
+  }
+  visited.delete(file);
+  return maxDepth;
+}
+function getTransitiveDependencies(file, graph, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(file)) return [];
+  visited.add(file);
+  const dependencies = graph.edges.get(file);
+  if (!dependencies || dependencies.size === 0) return [];
+  const allDeps = [];
+  for (const dep of dependencies) {
+    allDeps.push(dep);
+    allDeps.push(...getTransitiveDependencies(dep, graph, visited));
+  }
+  return [...new Set(allDeps)];
+}
+function calculateContextBudget(file, graph) {
+  const node = graph.nodes.get(file);
+  if (!node) return 0;
+  let totalTokens = node.tokenCost;
+  const deps = getTransitiveDependencies(file, graph);
+  for (const dep of deps) {
+    const depNode = graph.nodes.get(dep);
+    if (depNode) {
+      totalTokens += depNode.tokenCost;
+    }
+  }
+  return totalTokens;
+}
+function detectCircularDependencies(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(file, path) {
+    if (recursionStack.has(file)) {
+      const cycleStart = path.indexOf(file);
+      if (cycleStart !== -1) {
+        cycles.push([...path.slice(cycleStart), file]);
+      }
+      return;
+    }
+    if (visited.has(file)) return;
+    visited.add(file);
+    recursionStack.add(file);
+    path.push(file);
+    const dependencies = graph.edges.get(file);
+    if (dependencies) {
+      for (const dep of dependencies) {
+        dfs(dep, [...path]);
+      }
+    }
+    recursionStack.delete(file);
+  }
+  for (const file of graph.nodes.keys()) {
+    if (!visited.has(file)) {
+      dfs(file, []);
+    }
+  }
+  return cycles;
+}
+
+// src/metrics.ts
+import { calculateImportSimilarity } from "@aiready/core";
+function calculateEnhancedCohesion(exports, filePath, options) {
+  if (exports.length <= 1) return 1;
+  if (filePath && isTestFile(filePath)) return 1;
+  const weights = {
+    importBased: options?.weights?.importBased ?? 0.4,
+    structural: options?.weights?.structural ?? 0.3,
+    domainBased: options?.weights?.domainBased ?? 0.3
+  };
+  const domains = exports.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") {
+    return 1;
+  }
+  const probs = Array.from(domainCounts.values()).map((c) => c / exports.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 importScore = 0;
+  let pairs = 0;
+  for (let i = 0; i < exports.length; i++) {
+    for (let j = i + 1; j < exports.length; j++) {
+      const exp1 = { ...exports[i], imports: exports[i].imports || [] };
+      const exp2 = { ...exports[j], imports: exports[j].imports || [] };
+      const sim = calculateImportSimilarity(
+        exp1,
+        exp2
+      );
+      importScore += sim;
+      pairs++;
+    }
+  }
+  const avgImportScore = pairs > 0 ? importScore / pairs : 0;
+  let structuralScore = 0;
+  for (const exp of exports) {
+    if (exp.dependencies && exp.dependencies.length > 0) {
+      structuralScore += 1;
+    }
+  }
+  const avgStructuralScore = exports.length > 0 ? structuralScore / exports.length : 0;
+  let score = domainScore * weights.domainBased + avgImportScore * weights.importBased + Math.min(1, avgStructuralScore * 2) * weights.structural;
+  if (!options?.weights) {
+    if (avgImportScore === 0) return domainScore;
+    return score;
+  }
+  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 = Math.min(0.2, (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/classifier.ts
+function classifyFile(node, cohesionScore = 1, domains = []) {
+  if (isBarrelExport(node)) {
+    return "barrel-export";
+  }
+  if (isTypeDefinition(node)) {
+    return "type-definition";
+  }
+  if (isNextJsPage(node)) {
+    return "nextjs-page";
+  }
+  if (isLambdaHandler(node)) {
+    return "lambda-handler";
+  }
+  if (isServiceFile(node)) {
+    return "service-file";
+  }
+  if (isEmailTemplate(node)) {
+    return "email-template";
+  }
+  if (isParserFile(node)) {
+    return "parser-file";
+  }
+  if (isSessionFile(node)) {
+    if (cohesionScore >= 0.25 && domains.length <= 1) return "cohesive-module";
+    return "utility-module";
+  }
+  if (isUtilityModule(node)) {
+    return "utility-module";
+  }
+  if (isConfigFile(node)) {
+    return "cohesive-module";
+  }
+  if (domains.length <= 1 && domains[0] !== "unknown") {
+    return "cohesive-module";
+  }
+  if (domains.length > 1 && cohesionScore < 0.4) {
+    return "mixed-concerns";
+  }
+  if (cohesionScore >= 0.7) {
+    return "cohesive-module";
+  }
+  return "unknown";
+}
+function isBarrelExport(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const isIndexFile = fileName === "index.ts" || fileName === "index.js";
+  const isSmallAndManyExports = node.tokenCost < 1e3 && (exports || []).length >= 10;
+  const isReexportFile = (exports || []).every((e) => e.type === "const" || e.type === "function") && (exports || []).length > 5;
+  return !!isIndexFile || !!isSmallAndManyExports;
+}
+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 isUtilName = fileName?.includes("utils.") || fileName?.includes("helpers.") || fileName?.includes("util.") || fileName?.includes("helper.");
+  return !!isUtilPath || !!isUtilName;
+}
+function isLambdaHandler(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const handlerPatterns = ["handler", ".handler.", "-handler.", "lambda", ".lambda.", "-lambda."];
+  const isHandlerName = handlerPatterns.some((pattern) => fileName?.includes(pattern));
+  const isHandlerPath = file.toLowerCase().includes("/handlers/") || file.toLowerCase().includes("/lambdas/") || file.toLowerCase().includes("/lambda/") || file.toLowerCase().includes("/functions/");
+  const hasHandlerExport = (exports || []).some(
+    (e) => e.name.toLowerCase() === "handler" || e.name.toLowerCase() === "main" || e.name.toLowerCase() === "lambdahandler" || e.name.toLowerCase().endsWith("handler")
+  );
+  return !!isHandlerName || !!isHandlerPath || !!hasHandlerExport;
+}
+function isServiceFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const servicePatterns = ["service", ".service.", "-service.", "_service."];
+  const isServiceName = servicePatterns.some((pattern) => fileName?.includes(pattern));
+  const isServicePath = file.toLowerCase().includes("/services/");
+  const hasServiceNamedExport = (exports || []).some(
+    (e) => e.name.toLowerCase().includes("service") || e.name.toLowerCase().endsWith("service")
+  );
+  const hasClassExport = (exports || []).some((e) => e.type === "class");
+  return !!isServiceName || !!isServicePath || !!hasServiceNamedExport && !!hasClassExport;
+}
+function isEmailTemplate(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const emailTemplatePatterns = ["-email-", ".email.", "_email_", "-template", ".template.", "_template", "-mail.", ".mail."];
+  const isEmailTemplateName = emailTemplatePatterns.some((pattern) => fileName?.includes(pattern));
+  const isEmailPath = file.toLowerCase().includes("/emails/") || file.toLowerCase().includes("/mail/") || file.toLowerCase().includes("/notifications/");
+  const hasTemplateFunction = (exports || []).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"))
+  );
+  return !!isEmailPath || !!isEmailTemplateName || !!hasTemplateFunction;
+}
+function isParserFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const parserPatterns = ["parser", ".parser.", "-parser.", "_parser.", "transform", ".transform.", "converter", "mapper", "serializer"];
+  const isParserName = parserPatterns.some((pattern) => fileName?.includes(pattern));
+  const isParserPath = file.toLowerCase().includes("/parsers/") || file.toLowerCase().includes("/transformers/");
+  const hasParseFunction = (exports || []).some(
+    (e) => e.type === "function" && (e.name.toLowerCase().startsWith("parse") || e.name.toLowerCase().startsWith("transform") || e.name.toLowerCase().startsWith("extract"))
+  );
+  return !!isParserName || !!isParserPath || !!hasParseFunction;
+}
+function isSessionFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const sessionPatterns = ["session", "state", "context", "store"];
+  const isSessionName = sessionPatterns.some((pattern) => fileName?.includes(pattern));
+  const isSessionPath = file.toLowerCase().includes("/sessions/") || file.toLowerCase().includes("/state/");
+  const hasSessionExport = (exports || []).some(
+    (e) => e.name.toLowerCase().includes("session") || e.name.toLowerCase().includes("state") || e.name.toLowerCase().includes("store")
+  );
+  return !!isSessionName || !!isSessionPath || !!hasSessionExport;
+}
+function isConfigFile(node) {
+  const { file, exports } = 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 = (exports || []).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 } = node;
+  const lowerPath = file.toLowerCase();
+  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 hasDefaultExport = (exports || []).some((e) => e.type === "default");
+  const nextJsExports = ["metadata", "generatemetadata", "faqjsonld", "jsonld", "icon"];
+  const hasNextJsExports = (exports || []).some((e) => nextJsExports.includes(e.name.toLowerCase()));
+  return !!hasDefaultExport || !!hasNextJsExports;
+}
+function adjustCohesionForClassification(baseCohesion, classification, node) {
+  switch (classification) {
+    case "barrel-export":
+      return 1;
+    case "type-definition":
+      return 1;
+    case "nextjs-page":
+      return 1;
+    case "utility-module": {
+      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":
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    case "lambda-handler":
+      return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
+    case "email-template":
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    case "parser-file":
+      return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
+    case "cohesive-module":
+      return Math.max(baseCohesion, 0.7);
+    case "mixed-concerns":
+      return baseCohesion;
+    default:
+      return Math.min(1, baseCohesion + 0.1);
+  }
+}
+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) {
+    for (const verb of verbs) {
+      if (name.startsWith(verb) && name.length > verb.length) {
+        stems.add(name.slice(verb.length).toLowerCase());
+      }
+    }
+    for (const domain of domainPatterns) {
+      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);
+    const fragmentation = calculateFragmentation(files, domain, options);
+    let totalCohesion = 0;
+    files.forEach((f) => {
+      const node = graph.nodes.get(f);
+      if (node) totalCohesion += calculateEnhancedCohesion(node.exports);
+    });
+    const avgCohesion = totalCohesion / files.length;
+    clusters.push({
+      domain,
+      files,
+      totalTokens,
+      fragmentationScore: fragmentation,
+      avgCohesion,
+      suggestedStructure: generateSuggestedStructure(
+        files,
+        totalTokens,
+        fragmentation
+      )
+    });
+  }
+  return clusters;
+}
+function generateSuggestedStructure(files, tokens, fragmentation) {
+  const targetFiles = Math.max(1, Math.ceil(tokens / 1e4));
+  const plan = [];
+  if (fragmentation > 0.5) {
+    plan.push(
+      `Consolidate ${files.length} files scattered across multiple directories into ${targetFiles} core module(s)`
+    );
+  }
+  if (tokens > 2e4) {
+    plan.push(
+      `Domain logic is very large (${Math.round(tokens / 1e3)}k tokens). Ensure clear sub-domain boundaries.`
+    );
+  }
+  return { targetFiles, consolidationPlan: plan };
+}
+
+// src/remediation.ts
+function getClassificationRecommendations(classification, file, issues) {
+  switch (classification) {
+    case "barrel-export":
+      return [
+        "Barrel export file detected - multiple domains are expected here",
+        "Consider if this barrel export improves or hinders discoverability"
+      ];
+    case "type-definition":
+      return [
+        "Type definition file - centralized types improve consistency",
+        "Consider splitting if file becomes too large (>500 lines)"
+      ];
+    case "cohesive-module":
+      return [
+        "Module has good cohesion despite its size",
+        "Consider documenting the module boundaries for AI assistants"
+      ];
+    case "utility-module":
+      return [
+        "Utility module detected - multiple domains are acceptable here",
+        "Consider grouping related utilities by prefix or domain for better discoverability"
+      ];
+    case "service-file":
+      return [
+        "Service file detected - orchestration of multiple dependencies is expected",
+        "Consider documenting service boundaries and dependencies"
+      ];
+    case "lambda-handler":
+      return [
+        "Lambda handler detected - coordination of services is expected",
+        "Ensure handler has clear single responsibility"
+      ];
+    case "email-template":
+      return [
+        "Email template detected - references multiple domains for rendering",
+        "Template structure is cohesive by design"
+      ];
+    case "parser-file":
+      return [
+        "Parser/transformer file detected - handles multiple data sources",
+        "Consider documenting input/output schemas"
+      ];
+    case "nextjs-page":
+      return [
+        "Next.js App Router page detected - metadata/JSON-LD/component pattern is cohesive",
+        "Multiple exports (metadata, faqJsonLd, default) serve single page purpose"
+      ];
+    case "mixed-concerns":
+      return [
+        "Consider splitting this file by domain",
+        "Identify independent responsibilities and extract them",
+        "Review import dependencies to understand coupling"
+      ];
+    default:
+      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(exports, filePath, options) {
+  return calculateEnhancedCohesion(exports, 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
+function calculateContextScore(resultsOrSummary, importDepth, fragmentation, cohesion) {
+  if (Array.isArray(resultsOrSummary)) {
+    const results = resultsOrSummary;
+    if (results.length === 0) return 100;
+    const criticalIssues = results.filter((r) => r.severity === "critical").length;
+    const majorIssues = results.filter((r) => r.severity === "major").length;
+    const penalty = criticalIssues * 10 + majorIssues * 5;
+    return Math.max(0, 100 - penalty);
+  }
+  const isSummary = resultsOrSummary && typeof resultsOrSummary === "object" && "avgContextBudget" in resultsOrSummary;
+  const budget = isSummary ? resultsOrSummary.maxContextBudget : typeof resultsOrSummary === "number" ? resultsOrSummary : 0;
+  const depth = isSummary ? resultsOrSummary.maxImportDepth : importDepth || 0;
+  const frag = isSummary ? resultsOrSummary.avgFragmentation : fragmentation || 0;
+  const coh = isSummary ? resultsOrSummary.avgCohesion : cohesion !== void 0 ? cohesion : 1;
+  const budgetScore = Math.max(0, 100 - budget / 500);
+  const depthScore = depth > 5 ? Math.max(0, 100 - (depth - 5) * 10) : 100;
+  const cohesionScore = coh * 100;
+  const fragPenalty = frag > 0.5 ? (frag - 0.5) * 100 : 0;
+  const rawScore = budgetScore * 0.4 + depthScore * 0.3 + cohesionScore * 0.3;
+  const score = Math.round(rawScore - fragPenalty);
+  const factors = [
+    { name: "Context Budget", impact: Math.round(budgetScore - 50), description: `${Math.round(budget)} tokens` },
+    { name: "Import Depth", impact: Math.round(depthScore - 50), description: `${depth} levels` },
+    { name: "Fragmentation", impact: Math.round(-fragPenalty), description: `${(frag * 100).toFixed(0)}% scattered` }
+  ];
+  if (budget > 5e4) {
+    factors.push({ name: "Extreme File Detected", impact: -20, description: "Budget > 50k" });
+  }
+  const criticalCount = isSummary ? resultsOrSummary.criticalIssues || 0 : 0;
+  if (criticalCount > 0) {
+    factors.push({ name: "Critical Issues", impact: -criticalCount * 10, description: `${criticalCount} blockers` });
+  }
+  const recommendations = [];
+  if (score < 70) recommendations.push({ action: "Reduce context budget of expensive files", priority: "high", estimatedImpact: 10 });
+  const finalScore = Math.max(0, Math.min(100, score - criticalCount * 10 - (budget > 5e4 ? 20 : 0)));
+  return {
+    toolName: "context-analyzer",
+    score: finalScore,
+    rawMetrics: { budget, depth, fragmentation: frag, cohesion: coh },
+    factors,
+    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/defaults.ts
+import { scanFiles } from "@aiready/core";
+async function getSmartDefaults(directory, userOptions) {
+  const files = await scanFiles({
+    rootDir: directory,
+    include: userOptions.include,
+    exclude: userOptions.exclude
+  });
+  const estimatedBlocks = files.length;
+  let maxDepth;
+  let maxContextBudget;
+  let minCohesion;
+  let maxFragmentation;
+  if (estimatedBlocks < 100) {
+    maxDepth = 4;
+    maxContextBudget = 8e3;
+    minCohesion = 0.5;
+    maxFragmentation = 0.5;
+  } else if (estimatedBlocks < 500) {
+    maxDepth = 5;
+    maxContextBudget = 15e3;
+    minCohesion = 0.45;
+    maxFragmentation = 0.6;
+  } else if (estimatedBlocks < 2e3) {
+    maxDepth = 7;
+    maxContextBudget = 25e3;
+    minCohesion = 0.4;
+    maxFragmentation = 0.7;
+  } else {
+    maxDepth = 10;
+    maxContextBudget = 4e4;
+    minCohesion = 0.35;
+    maxFragmentation = 0.8;
+  }
+  return {
+    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,
+    avgImportDepth,
+    maxImportDepth,
+    deepFiles,
+    avgFragmentation,
+    fragmentedModules,
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles
+  };
+}
+
+// src/index.ts
+async function analyzeContext(options) {
+  const {
+    maxDepth = 5,
+    maxContextBudget = 1e4,
+    minCohesion = 0.6,
+    maxFragmentation = 0.5,
+    focus = "all",
+    includeNodeModules = false,
+    ...scanOptions
+  } = options;
+  const files = await scanFiles2({
+    ...scanOptions,
+    exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter(
+      (pattern) => pattern !== "**/node_modules/**"
+    ) : scanOptions.exclude
+  });
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await readFileContent(file)
+    }))
+  );
+  const graph = buildDependencyGraph(
+    fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py"))
+  );
+  let pythonResults = [];
+  if (pythonFiles.length > 0) {
+    const { analyzePythonContext } = await import("./python-context-TBI5FVFY.mjs");
+    const pythonMetrics = await analyzePythonContext(
+      pythonFiles,
+      scanOptions.rootDir || options.rootDir || "."
+    );
+    pythonResults = pythonMetrics.map((metric) => {
+      const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
+        file: metric.file,
+        importDepth: metric.importDepth,
+        contextBudget: metric.contextBudget,
+        cohesionScore: metric.cohesion,
+        fragmentationScore: 0,
+        maxDepth,
+        maxContextBudget,
+        minCohesion,
+        maxFragmentation,
+        circularDeps: metric.metrics.circularDependencies.map(
+          (cycle) => cycle.split(" \u2192 ")
+        )
+      });
+      return {
+        file: metric.file,
+        tokenCost: Math.floor(
+          metric.contextBudget / (1 + metric.imports.length || 1)
+        ),
+        linesOfCode: metric.metrics.linesOfCode,
+        importDepth: metric.importDepth,
+        dependencyCount: metric.imports.length,
+        dependencyList: metric.imports.map(
+          (imp) => imp.resolvedPath || imp.source
+        ),
+        circularDeps: metric.metrics.circularDependencies.map(
+          (cycle) => cycle.split(" \u2192 ")
+        ),
+        cohesionScore: metric.cohesion,
+        domains: ["python"],
+        exportCount: metric.exports.length,
+        contextBudget: metric.contextBudget,
+        fragmentationScore: 0,
+        relatedFiles: [],
+        fileClassification: "unknown",
+        severity,
+        issues,
+        recommendations,
+        potentialSavings
+      };
+    });
+  }
+  const circularDeps = detectCircularDependencies(graph);
+  const useLogScale = files.length >= 500;
+  const clusters = detectModuleClusters(graph, { useLogScale });
+  const fragmentationMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const file of cluster.files) {
+      fragmentationMap.set(file, cluster.fragmentationScore);
+    }
+  }
+  const results = [];
+  for (const { file } of fileContents) {
+    const node = graph.nodes.get(file);
+    if (!node) continue;
+    const importDepth = focus === "depth" || focus === "all" ? calculateImportDepth(file, graph) : 0;
+    const dependencyList = focus === "depth" || focus === "all" ? getTransitiveDependencies(file, graph) : [];
+    const contextBudget = focus === "all" ? calculateContextBudget(file, graph) : node.tokenCost;
+    const cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports, file, {
+      coUsageMatrix: graph.coUsageMatrix
+    }) : 1;
+    const fragmentationScore = fragmentationMap.get(file) || 0;
+    const relatedFiles = [];
+    for (const cluster of clusters) {
+      if (cluster.files.includes(file)) {
+        relatedFiles.push(...cluster.files.filter((f) => f !== file));
+        break;
+      }
+    }
+    const { issues } = analyzeIssues({
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore,
+      fragmentationScore,
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation,
+      circularDeps
+    });
+    const domains = [
+      ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
+    ];
+    const fileClassification = classifyFile(node);
+    const adjustedCohesionScore = adjustCohesionForClassification(
+      cohesionScore,
+      fileClassification,
+      node
+    );
+    const adjustedFragmentationScore = adjustFragmentationForClassification(
+      fragmentationScore,
+      fileClassification
+    );
+    const classificationRecommendations = getClassificationRecommendations(
+      fileClassification,
+      file,
+      issues
+    );
+    const {
+      severity: adjustedSeverity,
+      issues: adjustedIssues,
+      recommendations: finalRecommendations,
+      potentialSavings: adjustedSavings
+    } = analyzeIssues({
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore: adjustedCohesionScore,
+      fragmentationScore: adjustedFragmentationScore,
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation,
+      circularDeps
+    });
+    results.push({
+      file,
+      tokenCost: node.tokenCost,
+      linesOfCode: node.linesOfCode,
+      importDepth,
+      dependencyCount: dependencyList.length,
+      dependencyList,
+      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
+      cohesionScore: adjustedCohesionScore,
+      domains,
+      exportCount: node.exports.length,
+      contextBudget,
+      fragmentationScore: adjustedFragmentationScore,
+      relatedFiles,
+      fileClassification,
+      severity: adjustedSeverity,
+      issues: adjustedIssues,
+      recommendations: [
+        ...finalRecommendations,
+        ...classificationRecommendations.slice(0, 1)
+      ],
+      potentialSavings: adjustedSavings
+    });
+  }
+  const allResults = [...results, ...pythonResults];
+  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;
+  });
+}
+
+export {
+  buildCoUsageMatrix,
+  buildTypeGraph,
+  findSemanticClusters,
+  inferDomainFromSemantics,
+  calculateDomainConfidence,
+  extractExports,
+  inferDomain,
+  getCoUsageData,
+  findConsolidationCandidates,
+  extractDomainKeywordsFromPaths,
+  buildDependencyGraph,
+  extractImportsFromContent,
+  calculateImportDepth,
+  getTransitiveDependencies,
+  calculateContextBudget,
+  detectCircularDependencies,
+  calculateEnhancedCohesion,
+  calculateStructuralCohesionFromCoUsage,
+  calculateFragmentation,
+  calculatePathEntropy,
+  calculateDirectoryDistance,
+  classifyFile,
+  isBarrelExport,
+  isTypeDefinition,
+  isUtilityModule,
+  isLambdaHandler,
+  isServiceFile,
+  isEmailTemplate,
+  isParserFile,
+  isSessionFile,
+  isConfigFile,
+  isNextJsPage,
+  adjustCohesionForClassification,
+  adjustFragmentationForClassification,
+  detectModuleClusters,
+  getClassificationRecommendations,
+  getGeneralRecommendations,
+  calculateCohesion,
+  analyzeIssues,
+  calculateContextScore,
+  mapScoreToRating,
+  getSmartDefaults,
+  generateSummary,
+  analyzeContext
+};