@aiready/context-analyzer 0.5.1 → 0.6.0

package/dist/cli.js

@@ -36,7 +36,7 @@ function buildDependencyGraph(files) {
   const edges = /* @__PURE__ */ new Map();
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
-    const exports2 = extractExports(content);
+    const exports2 = extractExportsWithAST(content, file);
     const tokenCost = (0, import_core.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
     nodes.set(file, {
@@ -150,24 +150,12 @@ function detectCircularDependencies(graph) {
   }
   return cycles;
 }
-function calculateCohesion(exports2) {
-  if (exports2.length === 0) return 1;
-  if (exports2.length === 1) return 1;
-  const domains = exports2.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 calculateCohesion(exports2, filePath) {
+  return calculateEnhancedCohesion(exports2, filePath);
+}
+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) {
   if (files.length <= 1) return 0;
@@ -194,7 +182,7 @@ function detectModuleClusters(graph) {
     const fragmentationScore = calculateFragmentation(files, domain);
     const avgCohesion = files.reduce((sum, file) => {
       const node = graph.nodes.get(file);
-      return sum + (node ? calculateCohesion(node.exports) : 0);
+      return sum + (node ? calculateCohesion(node.exports, file) : 0);
     }, 0) / files.length;
     const targetFiles = Math.max(1, Math.ceil(files.length / 3));
     const consolidationPlan = generateConsolidationPlan(
@@ -248,25 +236,33 @@ function extractExports(content) {
 function inferDomain(name) {
   const lower = name.toLowerCase();
   const domainKeywords = [
-    "user",
-    "auth",
-    "order",
-    "product",
+    "authentication",
+    "authorization",
     "payment",
-    "cart",
     "invoice",
     "customer",
+    "product",
+    "order",
+    "cart",
+    "user",
     "admin",
-    "api",
-    "util",
-    "helper",
-    "config",
-    "service",
     "repository",
     "controller",
+    "service",
+    "config",
     "model",
-    "view"
+    "view",
+    "auth",
+    "api",
+    "helper",
+    "util"
   ];
+  for (const keyword of domainKeywords) {
+    const wordBoundaryPattern = new RegExp(`\\b${keyword}\\b`, "i");
+    if (wordBoundaryPattern.test(name)) {
+      return keyword;
+    }
+  }
   for (const keyword of domainKeywords) {
     if (lower.includes(keyword)) {
       return keyword;
@@ -300,6 +296,78 @@ function generateConsolidationPlan(domain, files, targetFiles) {
   );
   return plan;
 }
+function extractExportsWithAST(content, filePath) {
+  try {
+    const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
+    return astExports.map((exp) => ({
+      name: exp.name,
+      type: exp.type,
+      inferredDomain: inferDomain(exp.name),
+      imports: exp.imports,
+      dependencies: exp.dependencies
+    }));
+  } catch (error) {
+    return extractExports(content);
+  }
+}
+function calculateEnhancedCohesion(exports2, filePath) {
+  if (exports2.length === 0) return 1;
+  if (exports2.length === 1) return 1;
+  if (filePath && isTestFile(filePath)) {
+    return 1;
+  }
+  const domainCohesion = calculateDomainCohesion(exports2);
+  const hasImportData = exports2.some((e) => e.imports && e.imports.length > 0);
+  if (!hasImportData) {
+    return domainCohesion;
+  }
+  const importCohesion = calculateImportBasedCohesion(exports2);
+  return importCohesion * 0.6 + domainCohesion * 0.4;
+}
+function calculateImportBasedCohesion(exports2) {
+  const exportsWithImports = exports2.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(exports2) {
+  const domains = exports2.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/index.ts
 async function analyzeContext(options) {
@@ -341,7 +409,7 @@ async function analyzeContext(options) {
     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 cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports, file) : 1;
     const fragmentationScore = fragmentationMap.get(file) || 0;
     const relatedFiles = [];
     for (const cluster of clusters) {

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeContext,
   generateSummary
-} from "./chunk-NJUW6VED.mjs";
+} from "./chunk-DD7UVNE3.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -34,7 +34,7 @@ function buildDependencyGraph(files) {
   const edges = /* @__PURE__ */ new Map();
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
-    const exports2 = extractExports(content);
+    const exports2 = extractExportsWithAST(content, file);
     const tokenCost = (0, import_core.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
     nodes.set(file, {
@@ -148,24 +148,12 @@ function detectCircularDependencies(graph) {
   }
   return cycles;
 }
-function calculateCohesion(exports2) {
-  if (exports2.length === 0) return 1;
-  if (exports2.length === 1) return 1;
-  const domains = exports2.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 calculateCohesion(exports2, filePath) {
+  return calculateEnhancedCohesion(exports2, filePath);
+}
+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) {
   if (files.length <= 1) return 0;
@@ -192,7 +180,7 @@ function detectModuleClusters(graph) {
     const fragmentationScore = calculateFragmentation(files, domain);
     const avgCohesion = files.reduce((sum, file) => {
       const node = graph.nodes.get(file);
-      return sum + (node ? calculateCohesion(node.exports) : 0);
+      return sum + (node ? calculateCohesion(node.exports, file) : 0);
     }, 0) / files.length;
     const targetFiles = Math.max(1, Math.ceil(files.length / 3));
     const consolidationPlan = generateConsolidationPlan(
@@ -246,25 +234,33 @@ function extractExports(content) {
 function inferDomain(name) {
   const lower = name.toLowerCase();
   const domainKeywords = [
-    "user",
-    "auth",
-    "order",
-    "product",
+    "authentication",
+    "authorization",
     "payment",
-    "cart",
     "invoice",
     "customer",
+    "product",
+    "order",
+    "cart",
+    "user",
     "admin",
-    "api",
-    "util",
-    "helper",
-    "config",
-    "service",
     "repository",
     "controller",
+    "service",
+    "config",
     "model",
-    "view"
+    "view",
+    "auth",
+    "api",
+    "helper",
+    "util"
   ];
+  for (const keyword of domainKeywords) {
+    const wordBoundaryPattern = new RegExp(`\\b${keyword}\\b`, "i");
+    if (wordBoundaryPattern.test(name)) {
+      return keyword;
+    }
+  }
   for (const keyword of domainKeywords) {
     if (lower.includes(keyword)) {
       return keyword;
@@ -298,6 +294,78 @@ function generateConsolidationPlan(domain, files, targetFiles) {
   );
   return plan;
 }
+function extractExportsWithAST(content, filePath) {
+  try {
+    const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
+    return astExports.map((exp) => ({
+      name: exp.name,
+      type: exp.type,
+      inferredDomain: inferDomain(exp.name),
+      imports: exp.imports,
+      dependencies: exp.dependencies
+    }));
+  } catch (error) {
+    return extractExports(content);
+  }
+}
+function calculateEnhancedCohesion(exports2, filePath) {
+  if (exports2.length === 0) return 1;
+  if (exports2.length === 1) return 1;
+  if (filePath && isTestFile(filePath)) {
+    return 1;
+  }
+  const domainCohesion = calculateDomainCohesion(exports2);
+  const hasImportData = exports2.some((e) => e.imports && e.imports.length > 0);
+  if (!hasImportData) {
+    return domainCohesion;
+  }
+  const importCohesion = calculateImportBasedCohesion(exports2);
+  return importCohesion * 0.6 + domainCohesion * 0.4;
+}
+function calculateImportBasedCohesion(exports2) {
+  const exportsWithImports = exports2.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(exports2) {
+  const domains = exports2.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/index.ts
 async function getSmartDefaults(directory, userOptions) {
@@ -383,7 +451,7 @@ async function analyzeContext(options) {
     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 cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports, file) : 1;
     const fragmentationScore = fragmentationMap.get(file) || 0;
     const relatedFiles = [];
     for (const cluster of clusters) {

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzeContext,
   generateSummary,
   getSmartDefaults
-} from "./chunk-NJUW6VED.mjs";
+} from "./chunk-DD7UVNE3.mjs";
 export {
   analyzeContext,
   generateSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/context-analyzer",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "AI context window cost analysis - detect fragmented code, deep import chains, and expensive context budgets",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -50,7 +50,7 @@
     "commander": "^12.1.0",
     "chalk": "^5.3.0",
     "prompts": "^2.4.2",
-    "@aiready/core": "0.5.6"
+    "@aiready/core": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",

package/src/__tests__/analyzer.test.ts

@@ -148,6 +148,30 @@ describe('calculateCohesion', () => {
     const cohesion = calculateCohesion(exports);
     expect(cohesion).toBeLessThan(0.5);
   });
+
+  it('should return 1 for test files even with mixed domains', () => {
+    const exports = [
+      { name: 'mockUser', type: 'function' as const, inferredDomain: 'user' },
+      { name: 'mockOrder', type: 'function' as const, inferredDomain: 'order' },
+      { name: 'setupTestDb', type: 'function' as const, inferredDomain: 'helper' },
+    ];
+
+    // Test file - should return 1 despite mixed domains
+    const cohesionTestFile = calculateCohesion(exports, 'src/__tests__/helpers.test.ts');
+    expect(cohesionTestFile).toBe(1);
+
+    // Mock file - should return 1 despite mixed domains
+    const cohesionMockFile = calculateCohesion(exports, 'src/test-utils/mocks.ts');
+    expect(cohesionMockFile).toBe(1);
+
+    // Fixture file - should return 1 despite mixed domains
+    const cohesionFixtureFile = calculateCohesion(exports, 'src/fixtures/data.ts');
+    expect(cohesionFixtureFile).toBe(1);
+
+    // Regular file - should have low cohesion
+    const cohesionRegularFile = calculateCohesion(exports, 'src/utils/helpers.ts');
+    expect(cohesionRegularFile).toBeLessThan(0.5);
+  });
 });
 
 describe('calculateFragmentation', () => {

package/src/__tests__/enhanced-cohesion.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from 'vitest';
+import { calculateCohesion } from '../analyzer';
+import type { ExportInfo } from '../types';
+
+describe('Enhanced Cohesion Calculation', () => {
+  it('should use domain-based cohesion when no import data available', () => {
+    const exports: ExportInfo[] = [
+      { name: 'getUserData', type: 'function', inferredDomain: 'user' },
+      { name: 'getProductData', type: 'function', inferredDomain: 'product' },
+    ];
+
+    const cohesion = calculateCohesion(exports);
+    
+    // With mixed domains (user, product) and no import data, should use domain-based calculation
+    // Domain entropy for 2 different domains = low cohesion
+    expect(cohesion).toBeLessThan(0.5);
+  });
+
+  it('should use import-based cohesion when import data available', () => {
+    const exports: ExportInfo[] = [
+      {
+        name: 'getUserData',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react', 'axios', 'lodash'],
+      },
+      {
+        name: 'getProductData',
+        type: 'function',
+        inferredDomain: 'product',
+        imports: ['react', 'axios', 'lodash'], // Same imports!
+      },
+    ];
+
+    const cohesion = calculateCohesion(exports);
+    
+    // Even though domains differ, imports are identical (Jaccard = 1.0)
+    // Enhanced cohesion = 0.6 * 1.0 + 0.4 * 0.0 (different domains) = 0.6
+    // Should be >= 0.6 (import-based weight)
+    expect(cohesion).toBeGreaterThanOrEqual(0.6);
+  });
+
+  it('should weight import-based similarity higher than domain-based', () => {
+    const exportsWithSharedImports: ExportInfo[] = [
+      {
+        name: 'getUserData',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react', 'axios'],
+      },
+      {
+        name: 'getProductData',
+        type: 'function',
+        inferredDomain: 'product',
+        imports: ['react', 'axios'],
+      },
+    ];
+
+    const exportsWithoutSharedImports: ExportInfo[] = [
+      {
+        name: 'getUserData',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react', 'axios'],
+      },
+      {
+        name: 'getProductData',
+        type: 'function',
+        inferredDomain: 'product',
+        imports: ['lodash', 'moment'],
+      },
+    ];
+
+    const cohesionWithShared = calculateCohesion(exportsWithSharedImports);
+    const cohesionWithoutShared = calculateCohesion(exportsWithoutSharedImports);
+    
+    // Shared imports should result in higher cohesion
+    expect(cohesionWithShared).toBeGreaterThan(cohesionWithoutShared);
+  });
+
+  it('should handle mixed case: some exports with imports, some without', () => {
+    const exports: ExportInfo[] = [
+      {
+        name: 'getUserData',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react', 'axios'],
+      },
+      {
+        name: 'getProductData',
+        type: 'function',
+        inferredDomain: 'product',
+        // No imports field
+      },
+    ];
+
+    const cohesion = calculateCohesion(exports);
+    
+    // Should fall back to domain-based when not all exports have import data
+    expect(cohesion).toBeGreaterThan(0);
+    expect(cohesion).toBeLessThan(1);
+  });
+
+  it('should return 1 for single export', () => {
+    const exports: ExportInfo[] = [
+      {
+        name: 'getUserData',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react'],
+      },
+    ];
+
+    expect(calculateCohesion(exports)).toBe(1);
+  });
+
+  it('should return 1 for test files regardless of domains or imports', () => {
+    const exports: ExportInfo[] = [
+      { name: 'testUserLogin', type: 'function', inferredDomain: 'user', imports: ['react'] },
+      { name: 'testProductView', type: 'function', inferredDomain: 'product', imports: [] },
+    ];
+
+    const cohesion = calculateCohesion(exports, 'src/utils/test-helpers.ts');
+    expect(cohesion).toBe(1);
+  });
+});