@aiready/context-analyzer 0.21.26 → 0.21.27

package/dist/chunk-BQCISA2F.mjs

@@ -0,0 +1,91 @@
+import {
+  calculatePathEntropy
+} from "./chunk-EMYD7NS6.mjs";
+
+// src/summary.ts
+import { GLOBAL_SCAN_OPTIONS } from "@aiready/core";
+function generateSummary(results, options = {}) {
+  const config = options ? Object.fromEntries(
+    Object.entries(options).filter(
+      ([key]) => !GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
+    )
+  ) : {};
+  const totalFiles = results.length;
+  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
+  const avgContextBudget = totalFiles > 0 ? results.reduce((sum, r) => sum + r.contextBudget, 0) / totalFiles : 0;
+  const deepFiles = results.filter((r) => r.importDepth > 5).map((r) => ({ file: r.file, depth: r.importDepth }));
+  const maxImportDepth = Math.max(0, ...results.map((r) => r.importDepth));
+  const moduleMap = /* @__PURE__ */ new Map();
+  results.forEach((r) => {
+    const parts = r.file.split("/");
+    let domain = "root";
+    if (parts.length > 2) {
+      domain = parts.slice(0, 2).join("/");
+    }
+    if (!moduleMap.has(domain)) moduleMap.set(domain, []);
+    moduleMap.get(domain).push(r);
+  });
+  const fragmentedModules = [];
+  moduleMap.forEach((files, domain) => {
+    const clusterTokens = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const filePaths = files.map((f) => f.file);
+    const avgEntropy = calculatePathEntropy(filePaths);
+    const fragmentationScore = Math.min(1, avgEntropy * (files.length / 10));
+    if (fragmentationScore > 0.4) {
+      fragmentedModules.push({
+        domain,
+        files: filePaths,
+        fragmentationScore,
+        totalTokens: clusterTokens,
+        avgCohesion: files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length,
+        suggestedStructure: {
+          targetFiles: Math.ceil(files.length / 2),
+          consolidationPlan: [
+            `Consolidate ${files.length} files in ${domain} into fewer modules`
+          ]
+        }
+      });
+    }
+  });
+  fragmentedModules.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
+  const avgFragmentation = fragmentedModules.length > 0 ? fragmentedModules.reduce((sum, m) => sum + m.fragmentationScore, 0) / fragmentedModules.length : 0;
+  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / (totalFiles || 1);
+  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.4).map((r) => ({ file: r.file, score: r.cohesionScore }));
+  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),
+    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: Math.max(0, ...results.map((r) => r.contextBudget)),
+    avgImportDepth: results.reduce((sum, r) => sum + r.importDepth, 0) / (totalFiles || 1),
+    maxImportDepth,
+    deepFiles,
+    avgFragmentation,
+    fragmentedModules,
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles,
+    config
+  };
+}
+
+export {
+  generateSummary
+};

package/dist/chunk-EMYD7NS6.mjs

@@ -0,0 +1,137 @@
+// src/metrics.ts
+import { calculateImportSimilarity, isTestFile } from "@aiready/core";
+function calculateEnhancedCohesion(exports, filePath, options) {
+  if (exports.length <= 1) return 1;
+  if (filePath && isTestFile(filePath)) 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);
+  if (domainCounts.size === 1 && domains[0] !== "unknown") {
+    if (!options?.weights) return 1;
+  }
+  const probs = Array.from(domainCounts.values()).map(
+    (count) => count / exports.length
+  );
+  let domainEntropy = 0;
+  for (const prob of probs) {
+    if (prob > 0) domainEntropy -= prob * Math.log2(prob);
+  }
+  const maxEntropy = Math.log2(Math.max(2, domainCounts.size));
+  const domainScore = 1 - domainEntropy / maxEntropy;
+  let importScoreTotal = 0;
+  let pairsWithData = 0;
+  let anyImportData = false;
+  for (let i = 0; i < exports.length; i++) {
+    for (let j = i + 1; j < exports.length; j++) {
+      const exp1Imports = exports[i].imports;
+      const exp2Imports = exports[j].imports;
+      if (exp1Imports || exp2Imports) {
+        anyImportData = true;
+        const sim = calculateImportSimilarity(
+          { ...exports[i], imports: exp1Imports || [] },
+          { ...exports[j], imports: exp2Imports || [] }
+        );
+        importScoreTotal += sim;
+        pairsWithData++;
+      }
+    }
+  }
+  const avgImportScore = pairsWithData > 0 ? importScoreTotal / pairsWithData : 0;
+  let score = anyImportData ? domainScore * 0.4 + avgImportScore * 0.6 : domainScore;
+  if (anyImportData && score === 0 && domainScore === 0) {
+    score = 0.1;
+  }
+  let structuralScore = 0;
+  for (const exp of exports) {
+    if (exp.dependencies && exp.dependencies.length > 0) {
+      structuralScore += 1;
+    }
+  }
+  if (structuralScore > 0) {
+    score = Math.min(1, score + 0.1);
+  }
+  if (!options?.weights && !anyImportData && domainCounts.size === 1) return 1;
+  return score;
+}
+function calculateStructuralCohesionFromCoUsage(file, coUsageMatrix) {
+  if (!coUsageMatrix) return 1;
+  const coUsages = coUsageMatrix.get(file);
+  if (!coUsages || coUsages.size === 0) return 1;
+  let total = 0;
+  for (const count of coUsages.values()) total += count;
+  if (total === 0) return 1;
+  const probs = [];
+  for (const count of coUsages.values()) {
+    if (count > 0) probs.push(count / total);
+  }
+  if (probs.length <= 1) return 1;
+  let entropy = 0;
+  for (const prob of probs) {
+    entropy -= prob * Math.log2(prob);
+  }
+  const maxEntropy = Math.log2(probs.length);
+  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
+}
+function calculateFragmentation(files, domain, options) {
+  if (files.length <= 1) return 0;
+  const directories = new Set(
+    files.map((file) => file.split("/").slice(0, -1).join("/"))
+  );
+  const uniqueDirs = directories.size;
+  let score = options?.useLogScale ? uniqueDirs <= 1 ? 0 : Math.log(uniqueDirs) / Math.log(options.logBase || Math.E) / (Math.log(files.length) / Math.log(options.logBase || Math.E)) : (uniqueDirs - 1) / (files.length - 1);
+  if (options?.sharedImportRatio && options.sharedImportRatio > 0.5) {
+    const discount = (options.sharedImportRatio - 0.5) * 0.4;
+    score = score * (1 - discount);
+  }
+  return score;
+}
+function calculatePathEntropy(files) {
+  if (!files || files.length === 0) return 0;
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dir = file.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((sum, value) => sum + value, 0);
+  let entropy = 0;
+  for (const count of counts) {
+    const prob = count / total;
+    entropy -= prob * Math.log2(prob);
+  }
+  const maxEntropy = Math.log2(counts.length);
+  return maxEntropy > 0 ? entropy / maxEntropy : 0;
+}
+function calculateDirectoryDistance(files) {
+  if (!files || files.length <= 1) return 0;
+  const pathSegments = (pathStr) => pathStr.split("/").filter(Boolean);
+  const commonAncestorDepth = (pathA, pathB) => {
+    const minLen = Math.min(pathA.length, pathB.length);
+    let i = 0;
+    while (i < minLen && pathA[i] === pathB[i]) i++;
+    return i;
+  };
+  let totalNormalized = 0;
+  let comparisons = 0;
+  for (let i = 0; i < files.length; i++) {
+    for (let j = i + 1; j < files.length; j++) {
+      const segA = pathSegments(files[i]);
+      const segB = pathSegments(files[j]);
+      const shared = commonAncestorDepth(segA, segB);
+      const maxDepth = Math.max(segA.length, segB.length);
+      totalNormalized += 1 - (maxDepth > 0 ? shared / maxDepth : 0);
+      comparisons++;
+    }
+  }
+  return comparisons > 0 ? totalNormalized / comparisons : 0;
+}
+
+export {
+  calculateEnhancedCohesion,
+  calculateStructuralCohesionFromCoUsage,
+  calculateFragmentation,
+  calculatePathEntropy,
+  calculateDirectoryDistance
+};