@aiready/context-analyzer 0.9.41 → 0.9.42

package/src/semantic-analysis.ts

@@ -3,41 +3,30 @@ import type {
   CoUsageData,
   DomainAssignment,
   DomainSignals,
+  ExportInfo,
 } from './types';
 
 /**
  * Build co-usage matrix: track which files are imported together
- *
- * Files frequently imported together likely belong to the same semantic domain
  */
 export function buildCoUsageMatrix(
   graph: DependencyGraph
 ): Map<string, Map<string, number>> {
   const coUsageMatrix = new Map<string, Map<string, number>>();
 
-  // For each file, track which other files are imported alongside it
-  for (const [sourceFile, node] of graph.nodes) {
-    void sourceFile;
+  for (const [, node] of graph.nodes) {
     const imports = node.imports;
 
-    // For each pair of imports in this file, increment their co-usage count
     for (let i = 0; i < imports.length; i++) {
       const fileA = imports[i];
-
-      if (!coUsageMatrix.has(fileA)) {
-        coUsageMatrix.set(fileA, new Map());
-      }
+      if (!coUsageMatrix.has(fileA)) coUsageMatrix.set(fileA, new Map());
 
       for (let j = i + 1; j < imports.length; j++) {
         const fileB = imports[j];
-
-        // Increment bidirectional co-usage count
         const fileAUsage = coUsageMatrix.get(fileA)!;
         fileAUsage.set(fileB, (fileAUsage.get(fileB) || 0) + 1);
 
-        if (!coUsageMatrix.has(fileB)) {
-          coUsageMatrix.set(fileB, new Map());
-        }
+        if (!coUsageMatrix.has(fileB)) coUsageMatrix.set(fileB, new Map());
         const fileBUsage = coUsageMatrix.get(fileB)!;
         fileBUsage.set(fileA, (fileBUsage.get(fileA) || 0) + 1);
       }
@@ -49,8 +38,6 @@ export function buildCoUsageMatrix(
 
 /**
  * Extract type dependencies from AST exports
- *
- * Files that share types are semantically related
  */
 export function buildTypeGraph(
   graph: DependencyGraph
@@ -61,9 +48,7 @@ export function buildTypeGraph(
     for (const exp of node.exports) {
       if (exp.typeReferences) {
         for (const typeRef of exp.typeReferences) {
-          if (!typeGraph.has(typeRef)) {
-            typeGraph.set(typeRef, new Set());
-          }
+          if (!typeGraph.has(typeRef)) typeGraph.set(typeRef, new Set());
           typeGraph.get(typeRef)!.add(file);
         }
       }
@@ -75,8 +60,6 @@ export function buildTypeGraph(
 
 /**
  * Find semantic clusters using co-usage patterns
- *
- * Files with high co-usage counts belong in the same cluster
  */
 export function findSemanticClusters(
   coUsageMatrix: Map<string, Map<string, number>>,
@@ -85,14 +68,12 @@ export function findSemanticClusters(
   const clusters = new Map<string, string[]>();
   const visited = new Set<string>();
 
-  // Simple clustering: group files with high co-usage
   for (const [file, coUsages] of coUsageMatrix) {
     if (visited.has(file)) continue;
 
     const cluster: string[] = [file];
     visited.add(file);
 
-    // Find strongly related files (co-imported >= minCoUsage times)
     for (const [relatedFile, count] of coUsages) {
       if (count >= minCoUsage && !visited.has(relatedFile)) {
         cluster.push(relatedFile);
@@ -100,41 +81,14 @@ export function findSemanticClusters(
       }
     }
 
-    if (cluster.length > 1) {
-      // Use first file as cluster ID
-      clusters.set(file, cluster);
-    }
+    if (cluster.length > 1) clusters.set(file, cluster);
   }
 
   return clusters;
 }
 
-/**
- * Calculate confidence score for domain assignment based on multiple signals
- */
-export function calculateDomainConfidence(signals: DomainSignals): number {
-  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;
-}
-
 /**
  * Infer domain from semantic analysis (co-usage + types)
- *
- * This replaces the folder-based heuristic with actual code relationships
  */
 export function inferDomainFromSemantics(
   file: string,
@@ -144,16 +98,13 @@ export function inferDomainFromSemantics(
   typeGraph: Map<string, Set<string>>,
   exportTypeRefs?: string[]
 ): DomainAssignment[] {
-  const assignments: DomainAssignment[] = [];
   const domainSignals = new Map<string, DomainSignals>();
 
-  // 1. Check co-usage patterns
   const coUsages = coUsageMatrix.get(file) || new Map();
   const strongCoUsages = Array.from(coUsages.entries())
     .filter(([, count]) => count >= 3)
     .map(([coFile]) => coFile);
 
-  // Extract domains from frequently co-imported files
   for (const coFile of strongCoUsages) {
     const coNode = graph.nodes.get(coFile);
     if (coNode) {
@@ -175,29 +126,27 @@ export function inferDomainFromSemantics(
     }
   }
 
-  // 2. Check type references
   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;
+          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;
               }
             }
           }
@@ -206,72 +155,203 @@ export function inferDomainFromSemantics(
     }
   }
 
-  // 3. Build domain assignments with confidence scores
+  const assignments: DomainAssignment[] = [];
   for (const [domain, signals] of domainSignals) {
     const confidence = calculateDomainConfidence(signals);
-    if (confidence >= 0.3) {
-      // Minimum confidence threshold
-      assignments.push({ domain, confidence, signals });
-    }
+    if (confidence >= 0.3) assignments.push({ domain, confidence, signals });
   }
 
-  // Sort by confidence (highest first)
   assignments.sort((a, b) => b.confidence - a.confidence);
-
   return assignments;
 }
 
+export function calculateDomainConfidence(signals: DomainSignals): number {
+  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;
+}
+
 /**
- * Get co-usage data for a specific file
+ * Regex-based export extraction (legacy/fallback)
  */
+export function extractExports(
+  content: string,
+  filePath?: string,
+  domainOptions?: { domainKeywords?: string[] },
+  fileImports?: string[]
+): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  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: ExportInfo['type'][] = [
+    '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;
+}
+
+/**
+ * Infer domain from name, path, or imports
+ */
+export function inferDomain(
+  name: string,
+  filePath?: string,
+  domainOptions?: { domainKeywords?: string[] },
+  fileImports?: string[]
+): string {
+  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';
+}
+
+function singularize(word: string): string {
+  const irregulars: Record<string, string> = {
+    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;
+}
+
 export function getCoUsageData(
   file: string,
   coUsageMatrix: Map<string, Map<string, number>>
 ): CoUsageData {
-  const coImportedWith = coUsageMatrix.get(file) || new Map();
-
-  // Find files that import both this file and others
-  const sharedImporters: string[] = [];
-  // This would require inverse mapping from imports, simplified for now
-
   return {
     file,
-    coImportedWith,
-    sharedImporters,
+    coImportedWith: coUsageMatrix.get(file) || new Map(),
+    sharedImporters: [],
   };
 }
 
-/**
- * Find files that should be consolidated based on semantic similarity
- *
- * High co-usage + shared types = strong consolidation candidate
- */
 export function findConsolidationCandidates(
   graph: DependencyGraph,
   coUsageMatrix: Map<string, Map<string, number>>,
   typeGraph: Map<string, Set<string>>,
   minCoUsage: number = 5,
   minSharedTypes: number = 2
-): Array<{ files: string[]; reason: string; strength: number }> {
-  const candidates: Array<{
-    files: string[];
-    reason: string;
-    strength: number;
-  }> = [];
-
-  // Find file pairs with both high co-usage AND shared types
+) {
+  const candidates: any[] = [];
   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; // Avoid duplicates
-      if (coUsageCount < minCoUsage) continue;
-
+    for (const [fileB, count] of coUsages) {
+      if (fileB <= fileA || count < minCoUsage) continue;
       const nodeB = graph.nodes.get(fileB);
       if (!nodeB) continue;
-
-      // Count shared types
       const typesA = new Set(
         nodeA.exports.flatMap((e) => e.typeReferences || [])
       );
@@ -279,28 +359,14 @@ export function findConsolidationCandidates(
         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;
+      if (sharedTypes.length >= minSharedTypes || count >= minCoUsage * 2) {
         candidates.push({
           files: [fileA, fileB],
-          reason: `High co-usage (${coUsageCount}x) and ${sharedTypes.length} shared types`,
-          strength,
-        });
-      } else if (coUsageCount >= minCoUsage * 2) {
-        // Very high co-usage alone is enough
-        const strength = coUsageCount / 10;
-        candidates.push({
-          files: [fileA, fileB],
-          reason: `Very high co-usage (${coUsageCount}x)`,
-          strength,
+          reason: `High co-usage (${count}x)`,
+          strength: count / 10,
         });
       }
     }
   }
-
-  // Sort by strength (highest first)
-  candidates.sort((a, b) => b.strength - a.strength);
-
-  return candidates;
+  return candidates.sort((a, b) => b.strength - a.strength);
 }

package/src/summary.ts

@@ -0,0 +1,168 @@
+import type {
+  ContextAnalysisResult,
+  ContextSummary,
+  ModuleCluster,
+} from './types';
+import { calculatePathEntropy, calculateDirectoryDistance } from './analyzer';
+
+/**
+ * Generate summary of context analysis results
+ */
+export function generateSummary(
+  results: ContextAnalysisResult[]
+): ContextSummary {
+  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 = new Map<string, ContextAnalysisResult[]>();
+  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: ModuleCluster[] = [];
+  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 totalTokens = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const avgCohesion =
+      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);
+
+    function jaccard(a: string[], b: string[]) {
+      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 = new Set([...s1, ...s2]);
+      return uni.size === 0 ? 0 : inter.size / uni.size;
+    }
+
+    let importSimTotal = 0;
+    let importPairs = 0;
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        importSimTotal += jaccard(
+          files[i].dependencyList || [],
+          files[j].dependencyList || []
+        );
+        importPairs++;
+      }
+    }
+
+    const importCohesion = importPairs > 0 ? importSimTotal / importPairs : 0;
+
+    fragmentedModules.push({
+      domain,
+      files: files.map((f) => f.file),
+      totalTokens,
+      fragmentationScore,
+      avgCohesion,
+      importCohesion,
+      pathEntropy,
+      directoryDistance,
+      suggestedStructure: {
+        targetFiles,
+        consolidationPlan: [
+          `Consolidate ${files.length} files across ${new Set(files.map((f) => f.file.split('/').slice(0, -1).join('/'))).size} directories`,
+          `Target ~${targetFiles} core modules to reduce context switching`,
+        ],
+      },
+    });
+  }
+
+  const avgCohesion =
+    results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
+  const lowCohesionFiles = results
+    .filter((r) => r.cohesionScore < 0.4)
+    .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,
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles,
+  };
+}