@aiready/context-analyzer 0.22.4 → 0.22.6

package/dist/chunk-M2EGQ36M.mjs

@@ -0,0 +1,1304 @@
+import {
+  calculateImportDepthFromEdges,
+  detectGraphCycles,
+  getTransitiveDependenciesFromEdges
+} from "./chunk-64U3PNO3.mjs";
+import {
+  calculateEnhancedCohesion,
+  calculateFragmentation
+} from "./chunk-EMYD7NS6.mjs";
+
+// src/orchestrator.ts
+import { scanFiles, readFileContent } from "@aiready/core";
+
+// src/issue-analyzer.ts
+import { Severity, isBuildArtifact } from "@aiready/core";
+function analyzeIssues(params) {
+  const {
+    file,
+    importDepth,
+    contextBudget,
+    cohesionScore,
+    fragmentationScore,
+    maxDepth,
+    maxContextBudget,
+    minCohesion,
+    maxFragmentation,
+    circularDeps
+  } = params;
+  const issues = [];
+  const recommendations = [];
+  let severity = Severity.Info;
+  let potentialSavings = 0;
+  if (circularDeps.length > 0) {
+    severity = 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;
+    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 !== Severity.Critical) severity = 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 = 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 !== Severity.Critical) severity = 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 !== Severity.Critical) severity = 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 === Severity.Info) severity = 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 === Severity.Info || severity === Severity.Minor)
+      severity = 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 (isBuildArtifact(file)) {
+    issues.push("Detected build artifact (bundled/output file)");
+    recommendations.push("Exclude build outputs from analysis");
+    severity = Severity.Info;
+    potentialSavings = 0;
+  }
+  return {
+    severity,
+    issues,
+    recommendations,
+    potentialSavings: Math.floor(potentialSavings)
+  };
+}
+
+// src/graph-builder.ts
+import { estimateTokens, parseFileExports as parseFileExports2 } from "@aiready/core";
+
+// src/utils/string-utils.ts
+function singularize(word) {
+  const irregulars = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman"
+  };
+  if (irregulars[word]) return irregulars[word];
+  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
+  if (word.endsWith("ses")) return word.slice(0, -2);
+  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+
+// src/semantic/co-usage.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 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 getCoUsageData(file, coUsageMatrix) {
+  return {
+    file,
+    coImportedWith: coUsageMatrix.get(file) || /* @__PURE__ */ new Map(),
+    sharedImporters: []
+  };
+}
+
+// src/semantic/type-graph.ts
+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;
+}
+
+// src/semantic/domain-inference.ts
+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 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) {
+        const expAny = exp;
+        if (expAny.inferredDomain && expAny.inferredDomain !== "unknown") {
+          const domain = expAny.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) {
+              const expAny = exp;
+              if (expAny.inferredDomain && expAny.inferredDomain !== "unknown") {
+                const domain = expAny.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 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";
+}
+
+// src/ast-utils.ts
+import { parseFileExports, isTestFile } from "@aiready/core";
+async function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
+  try {
+    const { exports: astExports } = await parseFileExports(content, filePath);
+    if (astExports.length === 0 && !isTestFile(filePath)) {
+      return extractExports(content, filePath, domainOptions, fileImports);
+    }
+    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 {
+    return extractExports(content, filePath, domainOptions, fileImports);
+  }
+}
+
+// src/graph-builder.ts
+import { join, dirname, normalize } from "path";
+function resolveImport(source, importingFile, allFiles) {
+  if (!source.startsWith(".") && !source.startsWith("/")) {
+    if (source.startsWith("@aiready/")) {
+      const pkgName = source.split("/")[1];
+      const possiblePaths = [
+        // Standard src/index.ts entry point for our packages
+        join("packages", pkgName, "src", "index.ts"),
+        join("packages", pkgName, "src", "index.tsx"),
+        // Support for sub-exports if needed (e.g. @aiready/core/client)
+        join(
+          "packages",
+          pkgName,
+          "src",
+          `${source.split("/").slice(2).join("/") || "index"}.ts`
+        )
+      ];
+      for (const p of possiblePaths) {
+        const absolutePkgPath = Array.from(allFiles).find(
+          (f) => f.endsWith(normalize(p))
+        );
+        if (absolutePkgPath) return absolutePkgPath;
+      }
+    }
+    if (allFiles.has(source)) return source;
+    return null;
+  }
+  const dir = dirname(importingFile);
+  const absolutePath = normalize(join(dir, source));
+  if (allFiles.has(absolutePath)) return absolutePath;
+  const extensions = [".ts", ".tsx", ".js", ".jsx"];
+  for (const ext of extensions) {
+    const withExt = absolutePath + ext;
+    if (allFiles.has(withExt)) return withExt;
+  }
+  for (const ext of extensions) {
+    const indexFile = normalize(join(absolutePath, `index${ext}`));
+    if (allFiles.has(indexFile)) return indexFile;
+  }
+  return null;
+}
+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(singularize(normalized));
+      }
+    }
+  }
+  return Array.from(folderNames);
+}
+async function buildDependencyGraph(files, options) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
+  const allFilePaths = new Set(files.map((f) => f.file));
+  for (const { file, content } of files) {
+    const { imports: astImports } = await parseFileExports2(content, file);
+    const resolvedImports = astImports.map((i) => resolveImport(i.source, file, allFilePaths)).filter((path) => path !== null);
+    const importSources = astImports.map((i) => i.source);
+    const exports = await extractExportsWithAST(
+      content,
+      file,
+      { domainKeywords: autoDetectedKeywords },
+      importSources
+    );
+    const tokenCost = estimateTokens(content);
+    const linesOfCode = content.split("\n").length;
+    nodes.set(file, {
+      file,
+      imports: importSources,
+      exports,
+      tokenCost,
+      linesOfCode
+    });
+    edges.set(file, new Set(resolvedImports));
+  }
+  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
+      );
+      const expAny = exp;
+      expAny.domains = semanticAssignments;
+      if (semanticAssignments.length > 0) {
+        expAny.inferredDomain = semanticAssignments[0].domain;
+      }
+    }
+  }
+  return graph;
+}
+function calculateImportDepth(file, graph, visited = /* @__PURE__ */ new Set(), depth = 0) {
+  return calculateImportDepthFromEdges(file, graph.edges, visited, depth);
+}
+function getTransitiveDependencies(file, graph, visited = /* @__PURE__ */ new Set()) {
+  return getTransitiveDependenciesFromEdges(file, graph.edges, visited);
+}
+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) {
+  return detectGraphCycles(graph.edges);
+}
+
+// src/classify/classification-patterns.ts
+var BARREL_EXPORT_MIN_EXPORTS = 5;
+var BARREL_EXPORT_TOKEN_LIMIT = 1e3;
+var HANDLER_NAME_PATTERNS = [
+  "handler",
+  ".handler.",
+  "-handler.",
+  "lambda",
+  ".lambda.",
+  "-lambda."
+];
+var SERVICE_NAME_PATTERNS = [
+  "service",
+  ".service.",
+  "-service.",
+  "_service."
+];
+var EMAIL_NAME_PATTERNS = [
+  "-email-",
+  ".email.",
+  "_email_",
+  "-template",
+  ".template.",
+  "_template",
+  "-mail.",
+  ".mail."
+];
+var PARSER_NAME_PATTERNS = [
+  "parser",
+  ".parser.",
+  "-parser.",
+  "_parser.",
+  "transform",
+  "converter",
+  "mapper",
+  "serializer"
+];
+var SESSION_NAME_PATTERNS = ["session", "state", "context", "store"];
+var NEXTJS_METADATA_EXPORTS = [
+  "metadata",
+  "generatemetadata",
+  "faqjsonld",
+  "jsonld",
+  "icon"
+];
+var CONFIG_NAME_PATTERNS = [
+  ".config.",
+  "tsconfig",
+  "jest.config",
+  "package.json",
+  "aiready.json",
+  "next.config",
+  "sst.config"
+];
+
+// src/classify/file-classifiers.ts
+function isBoilerplateBarrel(node) {
+  const { exports, tokenCost } = node;
+  if (!exports || exports.length === 0) return false;
+  const isPurelyReexports = exports.every((exp) => !!exp.source);
+  if (!isPurelyReexports) return false;
+  if (tokenCost > 500) return false;
+  const sources = new Set(exports.map((exp) => exp.source));
+  const isSingleSourcePassThrough = sources.size === 1;
+  const isMeaninglessAggregation = sources.size > 0 && sources.size < 3;
+  return isSingleSourcePassThrough || isMeaninglessAggregation;
+}
+function isBarrelExport(node) {
+  if (isBoilerplateBarrel(node)) return false;
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase();
+  const isIndexFile = fileName === "index.ts" || fileName === "index.js";
+  const isSmallAndManyExports = node.tokenCost < BARREL_EXPORT_TOKEN_LIMIT && (exports || []).length > BARREL_EXPORT_MIN_EXPORTS;
+  const isReexportPattern = (exports || []).length >= BARREL_EXPORT_MIN_EXPORTS && (exports || []).every(
+    (exp) => ["const", "function", "type", "interface"].includes(exp.type)
+  );
+  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(
+    (exp) => exp.type === "type" || exp.type === "interface"
+  );
+  const isTypePath = /\/(types|interfaces|models)\//i.test(file);
+  return !!areAllTypes || isTypePath && hasExports;
+}
+function isUtilityModule(node) {
+  const { file } = node;
+  const isUtilPath = /\/(utils|helpers|util|helper)\//i.test(file);
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isUtilName = /(utils\.|helpers\.|util\.|helper\.)/i.test(fileName);
+  return isUtilPath || isUtilName;
+}
+function isLambdaHandler(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isHandlerName = HANDLER_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isHandlerPath = /\/(handlers|lambdas|lambda|functions)\//i.test(file);
+  const hasHandlerExport = (exports || []).some(
+    (exp) => ["handler", "main", "lambdahandler"].includes(exp.name.toLowerCase()) || exp.name.toLowerCase().endsWith("handler")
+  );
+  return isHandlerName || isHandlerPath || hasHandlerExport;
+}
+function isServiceFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isServiceName = SERVICE_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isServicePath = file.toLowerCase().includes("/services/");
+  const hasServiceNamedExport = (exports || []).some(
+    (exp) => exp.name.toLowerCase().includes("service")
+  );
+  const hasClassExport = (exports || []).some(
+    (exp) => exp.type === "class"
+  );
+  return isServiceName || isServicePath || hasServiceNamedExport && hasClassExport;
+}
+function isEmailTemplate(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isEmailName = EMAIL_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isEmailPath = /\/(emails|mail|notifications)\//i.test(file);
+  const hasTemplateFunction = (exports || []).some(
+    (exp) => exp.type === "function" && (exp.name.toLowerCase().startsWith("render") || exp.name.toLowerCase().startsWith("generate"))
+  );
+  return isEmailPath || isEmailName || hasTemplateFunction;
+}
+function isParserFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isParserName = PARSER_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isParserPath = /\/(parsers|transformers)\//i.test(file);
+  const hasParseFunction = (exports || []).some(
+    (exp) => exp.type === "function" && (exp.name.toLowerCase().startsWith("parse") || exp.name.toLowerCase().startsWith("transform"))
+  );
+  return isParserName || isParserPath || hasParseFunction;
+}
+function isSessionFile(node) {
+  const { file, exports } = node;
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isSessionName = SESSION_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isSessionPath = /\/(sessions|state)\//i.test(file);
+  const hasSessionExport = (exports || []).some(
+    (exp) => ["session", "state", "store"].some(
+      (pattern) => exp.name.toLowerCase().includes(pattern)
+    )
+  );
+  return isSessionName || isSessionPath || hasSessionExport;
+}
+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/");
+  if (!isInAppDir || fileName !== "page.tsx" && fileName !== "page.ts")
+    return false;
+  const hasDefaultExport = (exports || []).some(
+    (exp) => exp.type === "default"
+  );
+  const hasNextJsExport = (exports || []).some(
+    (exp) => NEXTJS_METADATA_EXPORTS.includes(exp.name.toLowerCase())
+  );
+  return hasDefaultExport || hasNextJsExport;
+}
+function isConfigFile(node) {
+  const { file, exports } = node;
+  const lowerPath = file.toLowerCase();
+  const fileName = file.split("/").pop()?.toLowerCase() || "";
+  const isConfigName = CONFIG_NAME_PATTERNS.some(
+    (pattern) => fileName.includes(pattern)
+  );
+  const isConfigPath = /\/(config|settings|schemas)\//i.test(lowerPath);
+  const hasSchemaExport = (exports || []).some(
+    (exp) => ["schema", "config", "setting"].some(
+      (pattern) => exp.name.toLowerCase().includes(pattern)
+    )
+  );
+  return isConfigName || isConfigPath || hasSchemaExport;
+}
+function isHubAndSpokeFile(node) {
+  const { file } = node;
+  return /\/packages\/[a-zA-Z0-9-]+\/src\//.test(file);
+}
+
+// src/classifier.ts
+var Classification = {
+  BARREL: "barrel-export",
+  BOILERPLATE: "boilerplate-barrel",
+  TYPE_DEFINITION: "type-definition",
+  NEXTJS_PAGE: "nextjs-page",
+  LAMBDA_HANDLER: "lambda-handler",
+  SERVICE: "service-file",
+  EMAIL_TEMPLATE: "email-template",
+  PARSER: "parser-file",
+  COHESIVE_MODULE: "cohesive-module",
+  UTILITY_MODULE: "utility-module",
+  SPOKE_MODULE: "spoke-module",
+  MIXED_CONCERNS: "mixed-concerns",
+  UNKNOWN: "unknown"
+};
+function classifyFile(node, cohesionScore = 1, domains = []) {
+  if (isBoilerplateBarrel(node)) {
+    return Classification.BOILERPLATE;
+  }
+  if (isBarrelExport(node)) {
+    return Classification.BARREL;
+  }
+  if (isTypeDefinition(node)) {
+    return Classification.TYPE_DEFINITION;
+  }
+  if (isNextJsPage(node)) {
+    return Classification.NEXTJS_PAGE;
+  }
+  if (isLambdaHandler(node)) {
+    return Classification.LAMBDA_HANDLER;
+  }
+  if (isServiceFile(node)) {
+    return Classification.SERVICE;
+  }
+  if (isEmailTemplate(node)) {
+    return Classification.EMAIL_TEMPLATE;
+  }
+  if (isParserFile(node)) {
+    return Classification.PARSER;
+  }
+  if (isSessionFile(node)) {
+    if (cohesionScore >= 0.25 && domains.length <= 1)
+      return Classification.COHESIVE_MODULE;
+    return Classification.UTILITY_MODULE;
+  }
+  if (isUtilityModule(node)) {
+    return Classification.UTILITY_MODULE;
+  }
+  if (isConfigFile(node)) {
+    return Classification.COHESIVE_MODULE;
+  }
+  if (isHubAndSpokeFile(node)) {
+    return Classification.SPOKE_MODULE;
+  }
+  if (domains.length <= 1 && domains[0] !== "unknown") {
+    return Classification.COHESIVE_MODULE;
+  }
+  if (domains.length > 1 && cohesionScore < 0.4) {
+    return Classification.MIXED_CONCERNS;
+  }
+  if (cohesionScore >= 0.7) {
+    return Classification.COHESIVE_MODULE;
+  }
+  return Classification.UNKNOWN;
+}
+function adjustCohesionForClassification(baseCohesion, classification, node) {
+  switch (classification) {
+    case Classification.BOILERPLATE:
+      return 0.2;
+    // Redundant indirection is low cohesion (architectural theater)
+    case Classification.BARREL:
+      return 1;
+    case Classification.TYPE_DEFINITION:
+      return 1;
+    case Classification.NEXTJS_PAGE:
+      return 1;
+    case Classification.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 Classification.SERVICE:
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    case Classification.LAMBDA_HANDLER:
+      return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
+    case Classification.EMAIL_TEMPLATE:
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
+    case Classification.PARSER:
+      return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
+    case Classification.SPOKE_MODULE:
+      return Math.max(baseCohesion, 0.6);
+    case Classification.COHESIVE_MODULE:
+      return Math.max(baseCohesion, 0.7);
+    case Classification.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 Classification.BOILERPLATE:
+      return baseFragmentation * 1.5;
+    // Redundant barrels increase fragmentation
+    case Classification.BARREL:
+      return 0;
+    case Classification.TYPE_DEFINITION:
+      return 0;
+    case Classification.UTILITY_MODULE:
+    case Classification.SERVICE:
+    case Classification.LAMBDA_HANDLER:
+    case Classification.EMAIL_TEMPLATE:
+    case Classification.PARSER:
+    case Classification.NEXTJS_PAGE:
+      return baseFragmentation * 0.2;
+    case Classification.SPOKE_MODULE:
+      return baseFragmentation * 0.15;
+    // Heavily discount intentional monorepo separation
+    case Classification.COHESIVE_MODULE:
+      return baseFragmentation * 0.3;
+    case Classification.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 = [];
+  const 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 };
+  };
+  for (const [domain, files] of domainMap.entries()) {
+    if (files.length < 2 || domain === "unknown") continue;
+    const totalTokens = files.reduce((sum, file) => {
+      const node = graph.nodes.get(file);
+      return sum + (node?.tokenCost || 0);
+    }, 0);
+    let sharedImportRatio = 0;
+    if (files.length >= 2) {
+      const allImportSets = files.map(
+        (f) => new Set(graph.nodes.get(f)?.imports || [])
+      );
+      let intersection = new Set(allImportSets[0]);
+      const union = new Set(allImportSets[0]);
+      for (let i = 1; i < allImportSets.length; i++) {
+        const nextSet = allImportSets[i];
+        intersection = new Set([...intersection].filter((x) => nextSet.has(x)));
+        for (const x of nextSet) union.add(x);
+      }
+      sharedImportRatio = union.size > 0 ? intersection.size / union.size : 0;
+    }
+    const rawFragmentation = calculateFragmentation(files, domain, {
+      ...options,
+      sharedImportRatio
+    });
+    let totalCohesion = 0;
+    let totalAdjustedFragmentation = 0;
+    files.forEach((f) => {
+      const node = graph.nodes.get(f);
+      if (node) {
+        const cohesion = calculateEnhancedCohesion(node.exports);
+        totalCohesion += cohesion;
+        const classification = classifyFile(node, cohesion);
+        totalAdjustedFragmentation += adjustFragmentationForClassification(
+          rawFragmentation,
+          classification
+        );
+      }
+    });
+    const avgCohesion = totalCohesion / files.length;
+    const fragmentationScore = totalAdjustedFragmentation / files.length;
+    clusters.push({
+      domain,
+      files,
+      totalTokens,
+      fragmentationScore,
+      avgCohesion,
+      suggestedStructure: generateSuggestedStructure(
+        files,
+        totalTokens,
+        fragmentationScore
+      )
+    });
+  }
+  return clusters;
+}
+
+// src/remediation.ts
+function getClassificationRecommendations(classification, file, issues) {
+  switch (classification) {
+    case "boilerplate-barrel":
+      return [
+        "Redundant indirection detected (architectural theater)",
+        "Remove this pass-through barrel export to reduce cognitive load",
+        "Consider combining into meaningful domain exports if necessary"
+      ];
+    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 "spoke-module":
+      return [
+        "Spoke module detected - intentional monorepo separation is good for modularity",
+        "Ensure this spoke only exports what is necessary for the hub or other spokes"
+      ];
+    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/orchestrator.ts
+function mapNodeToResult(node, graph, clusters, allCircularDeps, options) {
+  const file = node.file;
+  const tokenCost = node.tokenCost;
+  const importDepth = calculateImportDepth(file, graph);
+  const transitiveDeps = getTransitiveDependencies(file, graph);
+  const contextBudget = calculateContextBudget(file, graph);
+  const circularDeps = allCircularDeps.filter((cycle) => cycle.includes(file));
+  const cluster = clusters.find((c) => c.files.includes(file));
+  const rawFragmentationScore = cluster ? cluster.fragmentationScore : 0;
+  const rawCohesionScore = calculateEnhancedCohesion(
+    node.exports,
+    file,
+    options
+  );
+  const fileClassification = classifyFile(node, rawCohesionScore);
+  const cohesionScore = adjustCohesionForClassification(
+    rawCohesionScore,
+    fileClassification
+  );
+  const fragmentationScore = adjustFragmentationForClassification(
+    rawFragmentationScore,
+    fileClassification
+  );
+  const { severity, issues, recommendations, potentialSavings } = analyzeIssues(
+    {
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore,
+      fragmentationScore,
+      maxDepth: options.maxDepth,
+      maxContextBudget: options.maxContextBudget,
+      minCohesion: options.minCohesion,
+      maxFragmentation: options.maxFragmentation,
+      circularDeps
+    }
+  );
+  const classRecs = getClassificationRecommendations(
+    fileClassification,
+    file,
+    issues
+  );
+  const allRecommendations = Array.from(
+    /* @__PURE__ */ new Set([...recommendations, ...classRecs])
+  );
+  return {
+    file,
+    tokenCost,
+    linesOfCode: node.linesOfCode,
+    importDepth,
+    dependencyCount: transitiveDeps.length,
+    dependencyList: transitiveDeps,
+    circularDeps,
+    cohesionScore,
+    domains: Array.from(
+      new Set(
+        node.exports.flatMap(
+          (e) => e.domains?.map((d) => d.domain) || []
+        )
+      )
+    ),
+    exportCount: node.exports.length,
+    contextBudget,
+    fragmentationScore,
+    relatedFiles: cluster ? cluster.files : [],
+    fileClassification,
+    severity,
+    issues,
+    recommendations: allRecommendations,
+    potentialSavings
+  };
+}
+function calculateCohesion(exports, filePath, options) {
+  return calculateEnhancedCohesion(exports, filePath, options);
+}
+async function analyzeContext(options) {
+  const {
+    maxDepth = 5,
+    maxContextBudget = 25e3,
+    minCohesion = 0.6,
+    maxFragmentation = 0.5,
+    includeNodeModules = false,
+    ...scanOptions
+  } = options;
+  const files = await scanFiles({
+    ...scanOptions,
+    exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter(
+      (pattern) => pattern !== "**/node_modules/**"
+    ) : scanOptions.exclude
+  });
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await readFileContent(file)
+    }))
+  );
+  const graph = await buildDependencyGraph(
+    fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py"))
+  );
+  let pythonResults = [];
+  if (pythonFiles.length > 0) {
+    const { analyzePythonContext } = await import("./python-context-BWDC4E5Z.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: []
+      });
+      return {
+        file: metric.file,
+        tokenCost: 0,
+        linesOfCode: 0,
+        importDepth: metric.importDepth,
+        dependencyCount: 0,
+        dependencyList: [],
+        circularDeps: [],
+        cohesionScore: metric.cohesion,
+        domains: [],
+        exportCount: 0,
+        contextBudget: metric.contextBudget,
+        fragmentationScore: 0,
+        relatedFiles: [],
+        fileClassification: "unknown",
+        severity,
+        issues,
+        recommendations,
+        potentialSavings
+      };
+    });
+  }
+  const clusters = detectModuleClusters(graph);
+  const allCircularDeps = detectCircularDependencies(graph);
+  const results = Array.from(graph.nodes.values()).map(
+    (node) => mapNodeToResult(node, graph, clusters, allCircularDeps, {
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation
+    })
+  );
+  return [...results, ...pythonResults];
+}
+
+export {
+  buildCoUsageMatrix,
+  findSemanticClusters,
+  getCoUsageData,
+  buildTypeGraph,
+  calculateDomainConfidence,
+  inferDomainFromSemantics,
+  extractExports,
+  inferDomain,
+  extractDomainKeywordsFromPaths,
+  buildDependencyGraph,
+  calculateImportDepth,
+  getTransitiveDependencies,
+  calculateContextBudget,
+  detectCircularDependencies,
+  BARREL_EXPORT_MIN_EXPORTS,
+  BARREL_EXPORT_TOKEN_LIMIT,
+  HANDLER_NAME_PATTERNS,
+  SERVICE_NAME_PATTERNS,
+  EMAIL_NAME_PATTERNS,
+  PARSER_NAME_PATTERNS,
+  SESSION_NAME_PATTERNS,
+  NEXTJS_METADATA_EXPORTS,
+  CONFIG_NAME_PATTERNS,
+  isBoilerplateBarrel,
+  isBarrelExport,
+  isTypeDefinition,
+  isUtilityModule,
+  isLambdaHandler,
+  isServiceFile,
+  isEmailTemplate,
+  isParserFile,
+  isSessionFile,
+  isNextJsPage,
+  isConfigFile,
+  isHubAndSpokeFile,
+  Classification,
+  classifyFile,
+  adjustCohesionForClassification,
+  adjustFragmentationForClassification,
+  detectModuleClusters,
+  getClassificationRecommendations,
+  getGeneralRecommendations,
+  calculateCohesion,
+  analyzeContext
+};