@aiready/context-analyzer 0.22.9 → 0.22.11

package/dist/chunk-4U4LDWGF.mjs

@@ -1,360 +0,0 @@
-// 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/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) {
-        if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
-          const domain = exp.inferredDomain;
-          if (!domainSignals.has(domain)) {
-            domainSignals.set(domain, {
-              coUsage: false,
-              typeReference: false,
-              exportName: false,
-              importPath: false,
-              folderStructure: false
-            });
-          }
-          domainSignals.get(domain).coUsage = true;
-        }
-      }
-    }
-  }
-  if (exportTypeRefs) {
-    for (const typeRef of exportTypeRefs) {
-      const filesWithType = typeGraph.get(typeRef);
-      if (filesWithType) {
-        for (const typeFile of filesWithType) {
-          if (typeFile === file) continue;
-          const typeNode = graph.nodes.get(typeFile);
-          if (typeNode) {
-            for (const exp of typeNode.exports) {
-              if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
-                const domain = exp.inferredDomain;
-                if (!domainSignals.has(domain)) {
-                  domainSignals.set(domain, {
-                    coUsage: false,
-                    typeReference: false,
-                    exportName: false,
-                    importPath: false,
-                    folderStructure: false
-                  });
-                }
-                domainSignals.get(domain).typeReference = true;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  const assignments = [];
-  for (const [domain, signals] of domainSignals) {
-    const confidence = calculateDomainConfidence(signals);
-    if (confidence >= 0.3) assignments.push({ domain, confidence, signals });
-  }
-  assignments.sort((a, b) => b.confidence - a.confidence);
-  return assignments;
-}
-function 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/metrics.ts
-import { calculateImportSimilarity } from "@aiready/core";
-
-// src/ast-utils.ts
-import { parseFileExports } 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);
-  }
-}
-function isTestFile(filePath) {
-  const lower = filePath.toLowerCase();
-  return lower.includes(".test.") || lower.includes(".spec.") || lower.includes("/__tests__/") || lower.includes("/tests/") || lower.includes("/test/") || lower.includes("test-") || lower.includes("-test") || lower.includes("/__mocks__/") || lower.includes("/mocks/") || lower.includes("/fixtures/") || lower.includes(".mock.") || lower.includes(".fixture.") || lower.includes("/test-utils/");
-}
-
-// src/metrics.ts
-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 {
-  singularize,
-  calculateDomainConfidence,
-  inferDomainFromSemantics,
-  extractExports,
-  inferDomain,
-  extractExportsWithAST,
-  calculateEnhancedCohesion,
-  calculateStructuralCohesionFromCoUsage,
-  calculateFragmentation,
-  calculatePathEntropy,
-  calculateDirectoryDistance
-};