@aiready/context-analyzer 0.22.8 → 0.22.11

package/dist/chunk-5N5DCJOV.mjs

@@ -1,583 +0,0 @@
-// src/index.ts
-import { scanFiles, readFileContent } from "@aiready/core";
-
-// src/analyzer.ts
-import { estimateTokens } from "@aiready/core";
-function buildDependencyGraph(files) {
-  const nodes = /* @__PURE__ */ new Map();
-  const edges = /* @__PURE__ */ new Map();
-  for (const { file, content } of files) {
-    const imports = extractImportsFromContent(content);
-    const exports = extractExports(content);
-    const tokenCost = estimateTokens(content);
-    const linesOfCode = content.split("\n").length;
-    nodes.set(file, {
-      file,
-      imports,
-      exports,
-      tokenCost,
-      linesOfCode
-    });
-    edges.set(file, new Set(imports));
-  }
-  return { nodes, edges };
-}
-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("@") && !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) {
-  if (exports.length === 0) return 1;
-  if (exports.length === 1) return 1;
-  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;
-}
-function calculateFragmentation(files, domain) {
-  if (files.length <= 1) return 0;
-  const directories = new Set(files.map((f) => f.split("/").slice(0, -1).join("/")));
-  return (directories.size - 1) / (files.length - 1);
-}
-function detectModuleClusters(graph) {
-  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 fragmentationScore = calculateFragmentation(files, domain);
-    const avgCohesion = files.reduce((sum, file) => {
-      const node = graph.nodes.get(file);
-      return sum + (node ? calculateCohesion(node.exports) : 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,
-      avgCohesion,
-      suggestedStructure: {
-        targetFiles,
-        consolidationPlan
-      }
-    });
-  }
-  return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
-}
-function extractExports(content) {
-  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);
-      exports.push({ name, type, inferredDomain });
-    }
-  });
-  return exports;
-}
-function inferDomain(name) {
-  const lower = name.toLowerCase();
-  const domainKeywords = [
-    "user",
-    "auth",
-    "order",
-    "product",
-    "payment",
-    "cart",
-    "invoice",
-    "customer",
-    "admin",
-    "api",
-    "util",
-    "helper",
-    "config",
-    "service",
-    "repository",
-    "controller",
-    "model",
-    "view"
-  ];
-  for (const keyword of domainKeywords) {
-    if (lower.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;
-}
-
-// 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 = 3;
-    maxContextBudget = 5e3;
-    minCohesion = 0.7;
-    maxFragmentation = 0.3;
-  } else if (estimatedBlocks < 500) {
-    maxDepth = 4;
-    maxContextBudget = 8e3;
-    minCohesion = 0.65;
-    maxFragmentation = 0.4;
-  } else if (estimatedBlocks < 2e3) {
-    maxDepth = 5;
-    maxContextBudget = 12e3;
-    minCohesion = 0.6;
-    maxFragmentation = 0.5;
-  } else {
-    maxDepth = 6;
-    maxContextBudget = 2e4;
-    minCohesion = 0.55;
-    maxFragmentation = 0.6;
-  }
-  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,
-    exclude: includeNodeModules ? scanOptions.exclude : [...scanOptions.exclude || [], "**/node_modules/**"]
-  });
-  const fileContents = await Promise.all(
-    files.map(async (file) => ({
-      file,
-      content: await readFileContent(file)
-    }))
-  );
-  const graph = buildDependencyGraph(fileContents);
-  const circularDeps = detectCircularDependencies(graph);
-  const clusters = detectModuleClusters(graph);
-  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) : 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
-    });
-  }
-  return results.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;
-  });
-}
-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()) {
-    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));
-    fragmentedModules.push({
-      domain,
-      files: files.map((f) => f.file),
-      totalTokens: totalTokens2,
-      fragmentationScore,
-      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");
-  }
-  return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
-}
-
-export {
-  getSmartDefaults,
-  analyzeContext,
-  generateSummary
-};