@aiready/context-analyzer 0.22.9 → 0.22.11

package/dist/chunk-BD4NWUVG.mjs

@@ -1,1242 +0,0 @@
-// src/index.ts
-import { scanFiles, readFileContent } from "@aiready/core";
-
-// src/analyzer.ts
-import { estimateTokens, parseFileExports } from "@aiready/core";
-
-// src/semantic-analysis.ts
-function buildCoUsageMatrix(graph) {
-  const coUsageMatrix = /* @__PURE__ */ new Map();
-  for (const [sourceFile, 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 calculateDomainConfidence(signals) {
-  const weights = {
-    coUsage: 0.35,
-    // Strongest signal: actual usage patterns
-    typeReference: 0.3,
-    // Strong signal: shared types
-    exportName: 0.15,
-    // Medium signal: identifier semantics
-    importPath: 0.1,
-    // Weaker signal: path structure
-    folderStructure: 0.1
-    // Weakest signal: organization convention
-  };
-  let confidence = 0;
-  if (signals.coUsage) confidence += weights.coUsage;
-  if (signals.typeReference) confidence += weights.typeReference;
-  if (signals.exportName) confidence += weights.exportName;
-  if (signals.importPath) confidence += weights.importPath;
-  if (signals.folderStructure) confidence += weights.folderStructure;
-  return confidence;
-}
-function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGraph, exportTypeRefs) {
-  const assignments = [];
-  const domainSignals = /* @__PURE__ */ new Map();
-  const coUsages = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
-  const strongCoUsages = Array.from(coUsages.entries()).filter(([_, count]) => count >= 3).map(([coFile]) => coFile);
-  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) {
-            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;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  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 getCoUsageData(file, coUsageMatrix) {
-  const coImportedWith = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
-  const sharedImporters = [];
-  return {
-    file,
-    coImportedWith,
-    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, coUsageCount] of coUsages) {
-      if (fileB <= fileA) continue;
-      if (coUsageCount < 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) {
-        const strength = coUsageCount / 10 + sharedTypes.length / 5;
-        candidates.push({
-          files: [fileA, fileB],
-          reason: `High co-usage (${coUsageCount}x) and ${sharedTypes.length} shared types`,
-          strength
-        });
-      } else if (coUsageCount >= minCoUsage * 2) {
-        const strength = coUsageCount / 10;
-        candidates.push({
-          files: [fileA, fileB],
-          reason: `Very high co-usage (${coUsageCount}x)`,
-          strength
-        });
-      }
-    }
-  }
-  candidates.sort((a, b) => b.strength - a.strength);
-  return candidates;
-}
-
-// src/analyzer.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(".")) {
-        const singular = singularize(normalized);
-        folderNames.add(singular);
-      }
-    }
-  }
-  return Array.from(folderNames);
-}
-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 buildDependencyGraph(files) {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  const autoDetectedKeywords = 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 ... from '...'
-    /import\s+['"](.+?)['"]/g,
-    // import '...'
-    /require\(['"](.+?)['"]\)/g
-    // require('...')
-  ];
-  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) {
-    const depDepth = calculateImportDepth(dep, graph, visited, depth + 1);
-    maxDepth = Math.max(maxDepth, depDepth);
-  }
-  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;
-}
-function calculateCohesion(exports, filePath, options) {
-  return calculateEnhancedCohesion(exports, filePath, options);
-}
-function isTestFile(filePath) {
-  const lower = filePath.toLowerCase();
-  return lower.includes("test") || lower.includes("spec") || lower.includes("mock") || lower.includes("fixture") || lower.includes("__tests__") || lower.includes(".test.") || lower.includes(".spec.");
-}
-function calculateFragmentation(files, domain, options) {
-  if (files.length <= 1) return 0;
-  const directories = new Set(files.map((f) => f.split("/").slice(0, -1).join("/")));
-  const uniqueDirs = directories.size;
-  if (options?.useLogScale) {
-    if (uniqueDirs <= 1) return 0;
-    const total = files.length;
-    const base = options.logBase || Math.E;
-    const num = Math.log(uniqueDirs) / Math.log(base);
-    const den = Math.log(total) / Math.log(base);
-    return den > 0 ? num / den : 0;
-  }
-  return (uniqueDirs - 1) / (files.length - 1);
-}
-function calculatePathEntropy(files) {
-  if (!files || files.length === 0) return 0;
-  const dirCounts = /* @__PURE__ */ new Map();
-  for (const f of files) {
-    const dir = f.split("/").slice(0, -1).join("/") || ".";
-    dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
-  }
-  const counts = Array.from(dirCounts.values());
-  if (counts.length <= 1) return 0;
-  const total = counts.reduce((s, v) => s + v, 0);
-  let entropy = 0;
-  for (const c of counts) {
-    const p = c / total;
-    entropy -= p * Math.log2(p);
-  }
-  const maxEntropy = Math.log2(counts.length);
-  return maxEntropy > 0 ? entropy / maxEntropy : 0;
-}
-function calculateDirectoryDistance(files) {
-  if (!files || files.length <= 1) return 0;
-  function pathSegments(p) {
-    return p.split("/").filter(Boolean);
-  }
-  function commonAncestorDepth(a, b) {
-    const minLen = Math.min(a.length, b.length);
-    let i = 0;
-    while (i < minLen && a[i] === b[i]) i++;
-    return i;
-  }
-  let totalNormalized = 0;
-  let comparisons = 0;
-  for (let i = 0; i < files.length; i++) {
-    for (let j = i + 1; j < files.length; j++) {
-      const segA = pathSegments(files[i]);
-      const segB = pathSegments(files[j]);
-      const shared = commonAncestorDepth(segA, segB);
-      const maxDepth = Math.max(segA.length, segB.length);
-      const normalizedShared = maxDepth > 0 ? shared / maxDepth : 0;
-      totalNormalized += 1 - normalizedShared;
-      comparisons++;
-    }
-  }
-  return comparisons > 0 ? totalNormalized / comparisons : 0;
-}
-function detectModuleClusters(graph, options) {
-  const domainMap = /* @__PURE__ */ new Map();
-  for (const [file, node] of graph.nodes.entries()) {
-    const domains = node.exports.map((e) => e.inferredDomain || "unknown");
-    const primaryDomain = domains[0] || "unknown";
-    if (!domainMap.has(primaryDomain)) {
-      domainMap.set(primaryDomain, []);
-    }
-    domainMap.get(primaryDomain).push(file);
-  }
-  const clusters = [];
-  for (const [domain, files] of domainMap.entries()) {
-    if (files.length < 2) continue;
-    const totalTokens = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node?.tokenCost || 0);
-    }, 0);
-    const baseFragmentation = calculateFragmentation(files, domain, { useLogScale: !!options?.useLogScale });
-    let importSimilarityTotal = 0;
-    let importComparisons = 0;
-    for (let i = 0; i < files.length; i++) {
-      for (let j = i + 1; j < files.length; j++) {
-        const f1 = files[i];
-        const f2 = files[j];
-        const n1 = graph.nodes.get(f1)?.imports || [];
-        const n2 = graph.nodes.get(f2)?.imports || [];
-        const similarity = n1.length === 0 && n2.length === 0 ? 0 : calculateJaccardSimilarity(n1, n2);
-        importSimilarityTotal += similarity;
-        importComparisons++;
-      }
-    }
-    const importCohesion = importComparisons > 0 ? importSimilarityTotal / importComparisons : 0;
-    const couplingDiscountFactor = 1 - 0.2 * importCohesion;
-    const fragmentationScore = baseFragmentation * couplingDiscountFactor;
-    const pathEntropy = calculatePathEntropy(files);
-    const directoryDistance = calculateDirectoryDistance(files);
-    const avgCohesion = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node ? calculateCohesion(node.exports, file, { coUsageMatrix: graph.coUsageMatrix }) : 0);
-    }, 0) / files.length;
-    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
-    const consolidationPlan = generateConsolidationPlan(
-      domain,
-      files,
-      targetFiles
-    );
-    clusters.push({
-      domain,
-      files,
-      totalTokens,
-      fragmentationScore,
-      pathEntropy,
-      directoryDistance,
-      importCohesion,
-      avgCohesion,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan
-      }
-    });
-  }
-  return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
-}
-function extractExports(content, filePath, domainOptions, fileImports) {
-  const 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 && domainOptions.domainKeywords.length ? [...domainOptions.domainKeywords, ...defaultKeywords] : defaultKeywords;
-  for (const keyword of domainKeywords) {
-    if (tokens.includes(keyword)) {
-      return keyword;
-    }
-  }
-  for (const keyword of domainKeywords) {
-    if (lower.includes(keyword)) {
-      return keyword;
-    }
-  }
-  if (fileImports && fileImports.length > 0) {
-    for (const importPath of fileImports) {
-      const allSegments = importPath.split("/");
-      const relevantSegments = allSegments.filter((s) => {
-        if (!s) return false;
-        if (s === "." || s === "..") return false;
-        if (s.startsWith("@") && s.length === 1) return false;
-        return true;
-      }).map((s) => s.startsWith("@") ? s.slice(1) : s);
-      for (const segment of relevantSegments) {
-        const segLower = segment.toLowerCase();
-        const singularSegment = singularize(segLower);
-        for (const keyword of domainKeywords) {
-          if (singularSegment === keyword || segLower === keyword || segLower.includes(keyword)) {
-            return keyword;
-          }
-        }
-      }
-    }
-  }
-  if (filePath) {
-    const pathSegments = filePath.toLowerCase().split("/");
-    for (const segment of pathSegments) {
-      const singularSegment = singularize(segment);
-      for (const keyword of domainKeywords) {
-        if (singularSegment === keyword || segment === keyword || segment.includes(keyword)) {
-          return keyword;
-        }
-      }
-    }
-  }
-  return "unknown";
-}
-function generateConsolidationPlan(domain, files, targetFiles) {
-  const plan = [];
-  if (files.length <= targetFiles) {
-    return [`No consolidation needed for ${domain}`];
-  }
-  plan.push(
-    `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s):`
-  );
-  const dirGroups = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const dir = file.split("/").slice(0, -1).join("/");
-    if (!dirGroups.has(dir)) {
-      dirGroups.set(dir, []);
-    }
-    dirGroups.get(dir).push(file);
-  }
-  plan.push(`1. Create unified ${domain} module file`);
-  plan.push(
-    `2. Move related functionality from ${files.length} scattered files`
-  );
-  plan.push(`3. Update imports in dependent files`);
-  plan.push(
-    `4. Remove old files after consolidation (verify with tests first)`
-  );
-  return plan;
-}
-function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
-  try {
-    const { exports: astExports } = parseFileExports(content, filePath);
-    return astExports.map((exp) => ({
-      name: exp.name,
-      type: exp.type,
-      inferredDomain: inferDomain(exp.name, filePath, domainOptions, fileImports),
-      imports: exp.imports,
-      dependencies: exp.dependencies
-    }));
-  } catch (error) {
-    return extractExports(content, filePath, domainOptions, fileImports);
-  }
-}
-function calculateEnhancedCohesion(exports, filePath, options) {
-  if (exports.length === 0) return 1;
-  if (exports.length === 1) return 1;
-  if (filePath && isTestFile(filePath)) {
-    return 1;
-  }
-  const domainCohesion = calculateDomainCohesion(exports);
-  const hasImportData = exports.some((e) => e.imports && e.imports.length > 0);
-  const importCohesion = hasImportData ? calculateImportBasedCohesion(exports) : void 0;
-  const coUsageMatrix = options?.coUsageMatrix;
-  const structuralCohesion = filePath && coUsageMatrix ? calculateStructuralCohesionFromCoUsage(filePath, coUsageMatrix) : void 0;
-  const defaultWeights = { importBased: 0.5, structural: 0.3, domainBased: 0.2 };
-  const weights = { ...defaultWeights, ...options?.weights || {} };
-  const signals = [];
-  if (importCohesion !== void 0) signals.push({ score: importCohesion, weight: weights.importBased });
-  if (structuralCohesion !== void 0) signals.push({ score: structuralCohesion, weight: weights.structural });
-  signals.push({ score: domainCohesion, weight: weights.domainBased });
-  const totalWeight = signals.reduce((s, el) => s + el.weight, 0);
-  if (totalWeight === 0) return domainCohesion;
-  const combined = signals.reduce((sum, el) => sum + el.score * (el.weight / totalWeight), 0);
-  return combined;
-}
-function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
-  if (!coUsageMatrix) return 1;
-  const coUsages = coUsageMatrix.get(file);
-  if (!coUsages || coUsages.size === 0) return 1;
-  let total = 0;
-  for (const count of coUsages.values()) total += count;
-  if (total === 0) return 1;
-  const probs = [];
-  for (const count of coUsages.values()) {
-    if (count > 0) probs.push(count / total);
-  }
-  if (probs.length <= 1) return 1;
-  let entropy = 0;
-  for (const p of probs) {
-    entropy -= p * Math.log2(p);
-  }
-  const maxEntropy = Math.log2(probs.length);
-  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
-}
-function calculateImportBasedCohesion(exports) {
-  const exportsWithImports = exports.filter((e) => e.imports && e.imports.length > 0);
-  if (exportsWithImports.length < 2) {
-    return 1;
-  }
-  let totalSimilarity = 0;
-  let comparisons = 0;
-  for (let i = 0; i < exportsWithImports.length; i++) {
-    for (let j = i + 1; j < exportsWithImports.length; j++) {
-      const exp1 = exportsWithImports[i];
-      const exp2 = exportsWithImports[j];
-      const similarity = calculateJaccardSimilarity(exp1.imports, exp2.imports);
-      totalSimilarity += similarity;
-      comparisons++;
-    }
-  }
-  return comparisons > 0 ? totalSimilarity / comparisons : 1;
-}
-function calculateJaccardSimilarity(arr1, arr2) {
-  if (arr1.length === 0 && arr2.length === 0) return 1;
-  if (arr1.length === 0 || arr2.length === 0) return 0;
-  const set1 = new Set(arr1);
-  const set2 = new Set(arr2);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
-function calculateDomainCohesion(exports) {
-  const domains = exports.map((e) => e.inferredDomain || "unknown");
-  const domainCounts = /* @__PURE__ */ new Map();
-  for (const domain of domains) {
-    domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
-  }
-  const total = domains.length;
-  let entropy = 0;
-  for (const count of domainCounts.values()) {
-    const p = count / total;
-    if (p > 0) {
-      entropy -= p * Math.log2(p);
-    }
-  }
-  const maxEntropy = Math.log2(total);
-  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
-}
-
-// src/scoring.ts
-function calculateContextScore(summary) {
-  const {
-    avgContextBudget,
-    maxContextBudget,
-    avgImportDepth,
-    maxImportDepth,
-    avgFragmentation,
-    criticalIssues,
-    majorIssues
-  } = summary;
-  const budgetScore = avgContextBudget < 5e3 ? 100 : Math.max(0, 100 - (avgContextBudget - 5e3) / 150);
-  const depthScore = avgImportDepth < 5 ? 100 : Math.max(0, 100 - (avgImportDepth - 5) * 10);
-  const fragmentationScore = avgFragmentation < 0.3 ? 100 : Math.max(0, 100 - (avgFragmentation - 0.3) * 200);
-  const criticalPenalty = criticalIssues * 10;
-  const majorPenalty = majorIssues * 3;
-  const maxBudgetPenalty = maxContextBudget > 15e3 ? Math.min(20, (maxContextBudget - 15e3) / 500) : 0;
-  const rawScore = budgetScore * 0.4 + depthScore * 0.3 + fragmentationScore * 0.3;
-  const finalScore = rawScore - criticalPenalty - majorPenalty - maxBudgetPenalty;
-  const score = Math.max(0, Math.min(100, Math.round(finalScore)));
-  const factors = [
-    {
-      name: "Context Budget",
-      impact: Math.round(budgetScore * 0.4 - 40),
-      description: `Avg ${Math.round(avgContextBudget)} tokens per file ${avgContextBudget < 5e3 ? "(excellent)" : avgContextBudget < 1e4 ? "(acceptable)" : "(high)"}`
-    },
-    {
-      name: "Import Depth",
-      impact: Math.round(depthScore * 0.3 - 30),
-      description: `Avg ${avgImportDepth.toFixed(1)} levels ${avgImportDepth < 5 ? "(excellent)" : avgImportDepth < 8 ? "(acceptable)" : "(deep)"}`
-    },
-    {
-      name: "Fragmentation",
-      impact: Math.round(fragmentationScore * 0.3 - 30),
-      description: `${(avgFragmentation * 100).toFixed(0)}% fragmentation ${avgFragmentation < 0.3 ? "(well-organized)" : avgFragmentation < 0.5 ? "(moderate)" : "(high)"}`
-    }
-  ];
-  if (criticalIssues > 0) {
-    factors.push({
-      name: "Critical Issues",
-      impact: -criticalPenalty,
-      description: `${criticalIssues} critical context issue${criticalIssues > 1 ? "s" : ""}`
-    });
-  }
-  if (majorIssues > 0) {
-    factors.push({
-      name: "Major Issues",
-      impact: -majorPenalty,
-      description: `${majorIssues} major context issue${majorIssues > 1 ? "s" : ""}`
-    });
-  }
-  if (maxBudgetPenalty > 0) {
-    factors.push({
-      name: "Extreme File Detected",
-      impact: -Math.round(maxBudgetPenalty),
-      description: `One file requires ${Math.round(maxContextBudget)} tokens (very high)`
-    });
-  }
-  const recommendations = [];
-  if (avgContextBudget > 1e4) {
-    const estimatedImpact = Math.min(15, Math.round((avgContextBudget - 1e4) / 1e3));
-    recommendations.push({
-      action: "Reduce file dependencies to lower context requirements",
-      estimatedImpact,
-      priority: "high"
-    });
-  }
-  if (avgImportDepth > 8) {
-    const estimatedImpact = Math.min(10, Math.round((avgImportDepth - 8) * 2));
-    recommendations.push({
-      action: "Flatten import chains to reduce depth",
-      estimatedImpact,
-      priority: avgImportDepth > 10 ? "high" : "medium"
-    });
-  }
-  if (avgFragmentation > 0.5) {
-    const estimatedImpact = Math.min(12, Math.round((avgFragmentation - 0.5) * 40));
-    recommendations.push({
-      action: "Consolidate related code into cohesive modules",
-      estimatedImpact,
-      priority: "medium"
-    });
-  }
-  if (maxContextBudget > 2e4) {
-    recommendations.push({
-      action: `Split large file (${Math.round(maxContextBudget)} tokens) into smaller modules`,
-      estimatedImpact: 8,
-      priority: "high"
-    });
-  }
-  return {
-    toolName: "context-analyzer",
-    score,
-    rawMetrics: {
-      avgContextBudget: Math.round(avgContextBudget),
-      maxContextBudget: Math.round(maxContextBudget),
-      avgImportDepth: Math.round(avgImportDepth * 10) / 10,
-      maxImportDepth,
-      avgFragmentation: Math.round(avgFragmentation * 100) / 100,
-      criticalIssues,
-      majorIssues
-    },
-    factors,
-    recommendations
-  };
-}
-
-// src/index.ts
-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
-  };
-}
-async function analyzeContext(options) {
-  const {
-    maxDepth = 5,
-    maxContextBudget = 1e4,
-    minCohesion = 0.6,
-    maxFragmentation = 0.5,
-    focus = "all",
-    includeNodeModules = false,
-    ...scanOptions
-  } = options;
-  const files = await scanFiles({
-    ...scanOptions,
-    // Only add node_modules to exclude if includeNodeModules is false
-    // The DEFAULT_EXCLUDE already includes node_modules, so this is only needed
-    // if user overrides the default exclude list
-    exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter((pattern) => pattern !== "**/node_modules/**") : scanOptions.exclude
-  });
-  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
-  const tsJsFiles = files.filter((f) => !f.toLowerCase().endsWith(".py"));
-  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-UOPTQH44.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,
-        // Python analyzer doesn't calculate fragmentation yet
-        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)),
-        // Estimate
-        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"],
-        // Generic for now
-        exportCount: metric.exports.length,
-        contextBudget: metric.contextBudget,
-        fragmentationScore: 0,
-        relatedFiles: [],
-        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) : 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 { severity, issues, recommendations, potentialSavings } = analyzeIssues({
-      file,
-      importDepth,
-      contextBudget,
-      cohesionScore,
-      fragmentationScore,
-      maxDepth,
-      maxContextBudget,
-      minCohesion,
-      maxFragmentation,
-      circularDeps
-    });
-    const domains = [
-      ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
-    ];
-    results.push({
-      file,
-      tokenCost: node.tokenCost,
-      linesOfCode: node.linesOfCode,
-      importDepth,
-      dependencyCount: dependencyList.length,
-      dependencyList,
-      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
-      cohesionScore,
-      domains,
-      exportCount: node.exports.length,
-      contextBudget,
-      fragmentationScore,
-      relatedFiles,
-      severity,
-      issues,
-      recommendations,
-      potentialSavings
-    });
-  }
-  const allResults = [...results, ...pythonResults];
-  const issuesOnly = allResults.filter((r) => r.severity !== "info");
-  const sorted = issuesOnly.sort((a, b) => {
-    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
-    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
-    if (severityDiff !== 0) return severityDiff;
-    return b.contextBudget - a.contextBudget;
-  });
-  return sorted.length > 0 ? sorted : results;
-}
-function generateSummary(results) {
-  if (results.length === 0) {
-    return {
-      totalFiles: 0,
-      totalTokens: 0,
-      avgContextBudget: 0,
-      maxContextBudget: 0,
-      avgImportDepth: 0,
-      maxImportDepth: 0,
-      deepFiles: [],
-      avgFragmentation: 0,
-      fragmentedModules: [],
-      avgCohesion: 0,
-      lowCohesionFiles: [],
-      criticalIssues: 0,
-      majorIssues: 0,
-      minorIssues: 0,
-      totalPotentialSavings: 0,
-      topExpensiveFiles: []
-    };
-  }
-  const totalFiles = results.length;
-  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
-  const totalContextBudget = results.reduce(
-    (sum, r) => sum + r.contextBudget,
-    0
-  );
-  const avgContextBudget = totalContextBudget / totalFiles;
-  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
-  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
-  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
-  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
-  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
-  const moduleMap = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    for (const domain of result.domains) {
-      if (!moduleMap.has(domain)) {
-        moduleMap.set(domain, []);
-      }
-      moduleMap.get(domain).push(result);
-    }
-  }
-  const fragmentedModules = [];
-  for (const [domain, files] of moduleMap.entries()) {
-    let jaccard2 = function(a, b) {
-      const s1 = new Set(a || []);
-      const s2 = new Set(b || []);
-      if (s1.size === 0 && s2.size === 0) return 0;
-      const inter = new Set([...s1].filter((x) => s2.has(x)));
-      const uni = /* @__PURE__ */ new Set([...s1, ...s2]);
-      return uni.size === 0 ? 0 : inter.size / uni.size;
-    };
-    var jaccard = jaccard2;
-    if (files.length < 2) continue;
-    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
-    if (fragmentationScore < 0.3) continue;
-    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
-    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
-    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
-    const filePaths = files.map((f) => f.file);
-    const pathEntropy = calculatePathEntropy(filePaths);
-    const directoryDistance = calculateDirectoryDistance(filePaths);
-    let importSimTotal = 0;
-    let importPairs = 0;
-    for (let i = 0; i < files.length; i++) {
-      for (let j = i + 1; j < files.length; j++) {
-        importSimTotal += jaccard2(files[i].dependencyList || [], files[j].dependencyList || []);
-        importPairs++;
-      }
-    }
-    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
-    fragmentedModules.push({
-      domain,
-      files: files.map((f) => f.file),
-      totalTokens: totalTokens2,
-      fragmentationScore,
-      pathEntropy,
-      directoryDistance,
-      importCohesion,
-      avgCohesion: avgCohesion2,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan: [
-          `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s)`,
-          `Current token cost: ${totalTokens2.toLocaleString()}`,
-          `Estimated savings: ${Math.floor(totalTokens2 * 0.3).toLocaleString()} tokens (30%)`
-        ]
-      }
-    });
-  }
-  fragmentedModules.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
-  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
-  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.6).map((r) => ({ file: r.file, score: r.cohesionScore })).sort((a, b) => a.score - b.score).slice(0, 10);
-  const criticalIssues = results.filter((r) => r.severity === "critical").length;
-  const majorIssues = results.filter((r) => r.severity === "major").length;
-  const minorIssues = results.filter((r) => r.severity === "minor").length;
-  const totalPotentialSavings = results.reduce(
-    (sum, r) => sum + r.potentialSavings,
-    0
-  );
-  const topExpensiveFiles = results.sort((a, b) => b.contextBudget - a.contextBudget).slice(0, 10).map((r) => ({
-    file: r.file,
-    contextBudget: r.contextBudget,
-    severity: r.severity
-  }));
-  return {
-    totalFiles,
-    totalTokens,
-    avgContextBudget,
-    maxContextBudget,
-    avgImportDepth,
-    maxImportDepth,
-    deepFiles,
-    avgFragmentation,
-    fragmentedModules: fragmentedModules.slice(0, 10),
-    avgCohesion,
-    lowCohesionFiles,
-    criticalIssues,
-    majorIssues,
-    minorIssues,
-    totalPotentialSavings,
-    topExpensiveFiles
-  };
-}
-function analyzeIssues(params) {
-  const {
-    file,
-    importDepth,
-    contextBudget,
-    cohesionScore,
-    fragmentationScore,
-    maxDepth,
-    maxContextBudget,
-    minCohesion,
-    maxFragmentation,
-    circularDeps
-  } = params;
-  const issues = [];
-  const recommendations = [];
-  let severity = "info";
-  let potentialSavings = 0;
-  if (circularDeps.length > 0) {
-    severity = "critical";
-    issues.push(
-      `Part of ${circularDeps.length} circular dependency chain(s)`
-    );
-    recommendations.push("Break circular dependencies by extracting interfaces or using dependency injection");
-    potentialSavings += contextBudget * 0.2;
-  }
-  if (importDepth > maxDepth * 1.5) {
-    severity = severity === "critical" ? "critical" : "critical";
-    issues.push(`Import depth ${importDepth} exceeds limit by 50%`);
-    recommendations.push("Flatten dependency tree or use facade pattern");
-    potentialSavings += contextBudget * 0.3;
-  } else if (importDepth > maxDepth) {
-    severity = severity === "critical" ? "critical" : "major";
-    issues.push(`Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`);
-    recommendations.push("Consider reducing dependency depth");
-    potentialSavings += contextBudget * 0.15;
-  }
-  if (contextBudget > maxContextBudget * 1.5) {
-    severity = severity === "critical" ? "critical" : "critical";
-    issues.push(`Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`);
-    recommendations.push("Split into smaller modules or reduce dependency tree");
-    potentialSavings += contextBudget * 0.4;
-  } else if (contextBudget > maxContextBudget) {
-    severity = severity === "critical" || severity === "major" ? severity : "major";
-    issues.push(`Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`);
-    recommendations.push("Reduce file size or dependencies");
-    potentialSavings += contextBudget * 0.2;
-  }
-  if (cohesionScore < minCohesion * 0.5) {
-    severity = severity === "critical" ? "critical" : "major";
-    issues.push(`Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`);
-    recommendations.push("Split file by domain - separate unrelated functionality");
-    potentialSavings += contextBudget * 0.25;
-  } else if (cohesionScore < minCohesion) {
-    severity = severity === "critical" || severity === "major" ? severity : "minor";
-    issues.push(`Low cohesion (${(cohesionScore * 100).toFixed(0)}%)`);
-    recommendations.push("Consider grouping related exports together");
-    potentialSavings += contextBudget * 0.1;
-  }
-  if (fragmentationScore > maxFragmentation) {
-    severity = severity === "critical" || severity === "major" ? severity : "minor";
-    issues.push(`High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`);
-    recommendations.push("Consolidate with related files in same domain");
-    potentialSavings += contextBudget * 0.3;
-  }
-  if (issues.length === 0) {
-    issues.push("No significant issues detected");
-    recommendations.push("File is well-structured for AI context usage");
-  }
-  if (isBuildArtifact(file)) {
-    issues.push("Detected build artifact (bundled/output file)");
-    recommendations.push("Exclude build outputs (e.g., cdk.out, dist, build, .next) from analysis");
-    severity = downgradeSeverity(severity);
-    potentialSavings = 0;
-  }
-  return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
-}
-function isBuildArtifact(filePath) {
-  const lower = filePath.toLowerCase();
-  return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/output/") || lower.includes("/cdk.out/") || lower.includes("/.next/") || /\/asset\.[^/]+\//.test(lower);
-}
-function downgradeSeverity(s) {
-  switch (s) {
-    case "critical":
-      return "minor";
-    case "major":
-      return "minor";
-    case "minor":
-      return "info";
-    default:
-      return "info";
-  }
-}
-
-export {
-  buildCoUsageMatrix,
-  buildTypeGraph,
-  findSemanticClusters,
-  calculateDomainConfidence,
-  inferDomainFromSemantics,
-  getCoUsageData,
-  findConsolidationCandidates,
-  calculateContextScore,
-  getSmartDefaults,
-  analyzeContext,
-  generateSummary
-};