@aiready/context-analyzer 0.9.34 → 0.9.36

package/src/analyzer.ts

@@ -1,13 +1,20 @@
-import { estimateTokens, parseFileExports, calculateImportSimilarity, type ExportWithImports } from '@aiready/core';
+import {
+  estimateTokens,
+  parseFileExports,
+  calculateImportSimilarity,
+} from '@aiready/core';
 import type {
-  ContextAnalysisResult,
   DependencyGraph,
   DependencyNode,
   ExportInfo,
   ModuleCluster,
   FileClassification,
 } from './types';
-import { buildCoUsageMatrix, buildTypeGraph, inferDomainFromSemantics } from './semantic-analysis';
+import {
+  buildCoUsageMatrix,
+  buildTypeGraph,
+  inferDomainFromSemantics,
+} from './semantic-analysis';
 
 interface FileContent {
   file: string;
@@ -20,22 +27,45 @@ interface FileContent {
  */
 function extractDomainKeywordsFromPaths(files: FileContent[]): string[] {
   const folderNames = new Set<string>();
-  
+
   for (const { file } of files) {
     const segments = file.split('/');
     // Extract meaningful folder names (skip common infrastructure folders)
-    const skipFolders = new Set(['src', 'lib', 'dist', 'build', 'node_modules', 'test', 'tests', '__tests__', 'spec', 'e2e', 'scripts', 'components', 'utils', 'helpers', 'util', 'helper', 'api', 'apis']);
-    
+    const skipFolders = new Set([
+      'src',
+      'lib',
+      'dist',
+      'build',
+      'node_modules',
+      'test',
+      'tests',
+      '__tests__',
+      'spec',
+      'e2e',
+      'scripts',
+      'components',
+      'utils',
+      'helpers',
+      'util',
+      'helper',
+      'api',
+      'apis',
+    ]);
+
     for (const segment of segments) {
       const normalized = segment.toLowerCase();
-      if (normalized && !skipFolders.has(normalized) && !normalized.includes('.')) {
+      if (
+        normalized &&
+        !skipFolders.has(normalized) &&
+        !normalized.includes('.')
+      ) {
         // Singularize common plural forms for better matching
         const singular = singularize(normalized);
         folderNames.add(singular);
       }
     }
   }
-  
+
   return Array.from(folderNames);
 }
 
@@ -50,11 +80,11 @@ function singularize(word: string): string {
     men: 'man',
     women: 'woman',
   };
-  
+
   if (irregulars[word]) {
     return irregulars[word];
   }
-  
+
   // Common plural patterns
   if (word.endsWith('ies')) {
     return word.slice(0, -3) + 'y'; // categories -> category
@@ -65,29 +95,35 @@ function singularize(word: string): string {
   if (word.endsWith('s') && word.length > 3) {
     return word.slice(0, -1); // orders -> order
   }
-  
+
   return word;
 }
 
 /**
  * Build a dependency graph from file contents
  */
-export function buildDependencyGraph(
-  files: FileContent[],
-): DependencyGraph {
+export function buildDependencyGraph(files: FileContent[]): DependencyGraph {
   const nodes = new Map<string, DependencyNode>();
   const edges = new Map<string, Set<string>>();
 
   // Auto-detect domain keywords from workspace folder structure
   const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
 
+  // Some imported helpers are optional for future features; reference to avoid lint warnings
+  void calculateImportSimilarity;
+
   // First pass: Create nodes with folder-based domain inference
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
-    
+
     // Use AST-based extraction for better accuracy, fallback to regex
-    const exports = extractExportsWithAST(content, file, { domainKeywords: autoDetectedKeywords }, imports);
-    
+    const exports = extractExportsWithAST(
+      content,
+      file,
+      { domainKeywords: autoDetectedKeywords },
+      imports
+    );
+
     const tokenCost = estimateTokens(content);
     const linesOfCode = content.split('\n').length;
 
@@ -106,7 +142,7 @@ export function buildDependencyGraph(
   const graph: DependencyGraph = { nodes, edges };
   const coUsageMatrix = buildCoUsageMatrix(graph);
   const typeGraph = buildTypeGraph(graph);
-  
+
   // Add semantic data to graph
   graph.coUsageMatrix = coUsageMatrix;
   graph.typeGraph = typeGraph;
@@ -123,10 +159,10 @@ export function buildDependencyGraph(
         typeGraph,
         exp.typeReferences
       );
-      
+
       // Add multi-domain assignments with confidence scores
       exp.domains = semanticAssignments;
-      
+
       // Keep inferredDomain for backwards compatibility (use highest confidence)
       if (semanticAssignments.length > 0) {
         exp.inferredDomain = semanticAssignments[0].domain;
@@ -248,9 +284,7 @@ export function calculateContextBudget(
 /**
  * Detect circular dependencies
  */
-export function detectCircularDependencies(
-  graph: DependencyGraph
-): string[][] {
+export function detectCircularDependencies(graph: DependencyGraph): string[][] {
   const cycles: string[][] = [];
   const visited = new Set<string>();
   const recursionStack = new Set<string>();
@@ -301,7 +335,14 @@ export function detectCircularDependencies(
 export function calculateCohesion(
   exports: ExportInfo[],
   filePath?: string,
-  options?: { coUsageMatrix?: Map<string, Map<string, number>>; weights?: { importBased?: number; structural?: number; domainBased?: number } }
+  options?: {
+    coUsageMatrix?: Map<string, Map<string, number>>;
+    weights?: {
+      importBased?: number;
+      structural?: number;
+      domainBased?: number;
+    };
+  }
 ): number {
   return calculateEnhancedCohesion(exports, filePath, options);
 }
@@ -333,7 +374,9 @@ export function calculateFragmentation(
   if (files.length <= 1) return 0; // Single file = no fragmentation
 
   // Calculate how many different directories contain these files
-  const directories = new Set(files.map((f) => f.split('/').slice(0, -1).join('/')));
+  const directories = new Set(
+    files.map((f) => f.split('/').slice(0, -1).join('/'))
+  );
   const uniqueDirs = directories.size;
 
   // If log-scaling requested, normalize using logarithms so that
@@ -450,7 +493,9 @@ export function detectModuleClusters(
       return sum + (node?.tokenCost || 0);
     }, 0);
 
-    const baseFragmentation = calculateFragmentation(files, domain, { useLogScale: !!options?.useLogScale });
+    const baseFragmentation = calculateFragmentation(files, domain, {
+      useLogScale: !!options?.useLogScale,
+    });
 
     // Compute import-based cohesion across files in this domain cluster.
     // This measures how much the files actually "talk" to each other.
@@ -466,16 +511,18 @@ export function detectModuleClusters(
         const n2 = graph.nodes.get(f2)?.imports || [];
 
         // Treat two empty import lists as not coupled (similarity 0)
-        const similarity = (n1.length === 0 && n2.length === 0)
-          ? 0
-          : calculateJaccardSimilarity(n1, n2);
+        const similarity =
+          n1.length === 0 && n2.length === 0
+            ? 0
+            : calculateJaccardSimilarity(n1, n2);
 
         importSimilarityTotal += similarity;
         importComparisons++;
       }
     }
 
-    const importCohesion = importComparisons > 0 ? importSimilarityTotal / importComparisons : 0;
+    const importCohesion =
+      importComparisons > 0 ? importSimilarityTotal / importComparisons : 0;
 
     // Coupling discount: if files are heavily importing each other, reduce fragmentation penalty.
     // Following recommendation: up to 20% discount proportional to import cohesion.
@@ -490,7 +537,14 @@ export function detectModuleClusters(
     const avgCohesion =
       files.reduce((sum, file) => {
         const node = graph.nodes.get(file);
-        return sum + (node ? calculateCohesion(node.exports, file, { coUsageMatrix: graph.coUsageMatrix }) : 0);
+        return (
+          sum +
+          (node
+            ? calculateCohesion(node.exports, file, {
+                coUsageMatrix: graph.coUsageMatrix,
+              })
+            : 0)
+        );
       }, 0) / files.length;
 
     // Generate consolidation plan
@@ -528,7 +582,11 @@ export function detectModuleClusters(
 function extractExports(
   content: string,
   filePath?: string,
-  domainOptions?: { domainKeywords?: string[]; domainPatterns?: string[]; pathDomainMap?: Record<string, string> },
+  domainOptions?: {
+    domainKeywords?: string[];
+    domainPatterns?: string[];
+    pathDomainMap?: Record<string, string>;
+  },
   fileImports?: string[]
 ): ExportInfo[] {
   const exports: ExportInfo[] = [];
@@ -557,7 +615,12 @@ function extractExports(
     while ((match = pattern.exec(content)) !== null) {
       const name = match[1] || 'default';
       const type = types[index];
-      const inferredDomain = inferDomain(name, filePath, domainOptions, fileImports);
+      const inferredDomain = inferDomain(
+        name,
+        filePath,
+        domainOptions,
+        fileImports
+      );
 
       exports.push({ name, type, inferredDomain });
     }
@@ -612,9 +675,10 @@ function inferDomain(
     'auth',
   ];
 
-  const domainKeywords = domainOptions?.domainKeywords && domainOptions.domainKeywords.length
-    ? [...domainOptions.domainKeywords, ...defaultKeywords]
-    : defaultKeywords;
+  const domainKeywords =
+    domainOptions?.domainKeywords && domainOptions.domainKeywords.length
+      ? [...domainOptions.domainKeywords, ...defaultKeywords]
+      : defaultKeywords;
 
   // Try word boundary matching first for more accurate detection
   for (const keyword of domainKeywords) {
@@ -637,23 +701,29 @@ function inferDomain(
       // e.g., '@/orders/service' -> ['orders', 'service']
       //       '../payments/processor' -> ['payments', 'processor']
       const allSegments = importPath.split('/');
-      const relevantSegments = allSegments.filter(s => {
-        if (!s) return false;
-        // Skip '.' and '..' but keep everything else
-        if (s === '.' || s === '..') return false;
-        // Skip '@' prefix but keep the path after it
-        if (s.startsWith('@') && s.length === 1) return false;
-        // Remove '@' prefix from scoped imports like '@/orders'
-        return true;
-      }).map(s => s.startsWith('@') ? s.slice(1) : s);
-      
+      const relevantSegments = allSegments
+        .filter((s) => {
+          if (!s) return false;
+          // Skip '.' and '..' but keep everything else
+          if (s === '.' || s === '..') return false;
+          // Skip '@' prefix but keep the path after it
+          if (s.startsWith('@') && s.length === 1) return false;
+          // Remove '@' prefix from scoped imports like '@/orders'
+          return true;
+        })
+        .map((s) => (s.startsWith('@') ? s.slice(1) : s));
+
       for (const segment of relevantSegments) {
         const segLower = segment.toLowerCase();
         const singularSegment = singularize(segLower);
-        
+
         // Check if any domain keyword matches the import path segment (with singularization)
         for (const keyword of domainKeywords) {
-          if (singularSegment === keyword || segLower === keyword || segLower.includes(keyword)) {
+          if (
+            singularSegment === keyword ||
+            segLower === keyword ||
+            segLower.includes(keyword)
+          ) {
             return keyword;
           }
         }
@@ -667,9 +737,13 @@ function inferDomain(
     const pathSegments = filePath.toLowerCase().split('/');
     for (const segment of pathSegments) {
       const singularSegment = singularize(segment);
-      
+
       for (const keyword of domainKeywords) {
-        if (singularSegment === keyword || segment === keyword || segment.includes(keyword)) {
+        if (
+          singularSegment === keyword ||
+          segment === keyword ||
+          segment.includes(keyword)
+        ) {
           return keyword;
         }
       }
@@ -731,15 +805,22 @@ export function extractExportsWithAST(
 ): ExportInfo[] {
   try {
     const { exports: astExports } = parseFileExports(content, filePath);
-    
-    return astExports.map(exp => ({
+
+    return astExports.map((exp) => ({
       name: exp.name,
       type: exp.type,
-      inferredDomain: inferDomain(exp.name, filePath, domainOptions, fileImports),
+      inferredDomain: inferDomain(
+        exp.name,
+        filePath,
+        domainOptions,
+        fileImports
+      ),
       imports: exp.imports,
       dependencies: exp.dependencies,
     }));
   } catch (error) {
+    // Avoid unused variable lint
+    void error;
     // Fallback to regex-based extraction
     return extractExports(content, filePath, domainOptions, fileImports);
   }
@@ -747,17 +828,24 @@ export function extractExportsWithAST(
 
 /**
  * Calculate enhanced cohesion score using both domain inference and import similarity
- * 
+ *
  * This combines:
  * 1. Domain-based cohesion (entropy of inferred domains)
  * 2. Import-based cohesion (Jaccard similarity of shared imports)
- * 
+ *
  * Weight: 60% import-based, 40% domain-based (import analysis is more reliable)
  */
 export function calculateEnhancedCohesion(
   exports: ExportInfo[],
   filePath?: string,
-  options?: { coUsageMatrix?: Map<string, Map<string, number>>; weights?: { importBased?: number; structural?: number; domainBased?: number } }
+  options?: {
+    coUsageMatrix?: Map<string, Map<string, number>>;
+    weights?: {
+      importBased?: number;
+      structural?: number;
+      domainBased?: number;
+    };
+  }
 ): number {
   if (exports.length === 0) return 1;
   if (exports.length === 1) return 1;
@@ -772,27 +860,41 @@ export function calculateEnhancedCohesion(
 
   // Calculate import-based cohesion if imports are available
   const hasImportData = exports.some((e) => e.imports && e.imports.length > 0);
-  const importCohesion = hasImportData ? calculateImportBasedCohesion(exports) : undefined;
+  const importCohesion = hasImportData
+    ? calculateImportBasedCohesion(exports)
+    : undefined;
 
   // Calculate structural cohesion (co-usage) if coUsageMatrix and filePath available
   const coUsageMatrix = options?.coUsageMatrix;
-  const structuralCohesion = filePath && coUsageMatrix ? calculateStructuralCohesionFromCoUsage(filePath, coUsageMatrix) : undefined;
+  const structuralCohesion =
+    filePath && coUsageMatrix
+      ? calculateStructuralCohesionFromCoUsage(filePath, coUsageMatrix)
+      : undefined;
 
   // Default weights (can be overridden via options)
-  const defaultWeights = { importBased: 0.5, structural: 0.3, domainBased: 0.2 };
+  const defaultWeights = {
+    importBased: 0.5,
+    structural: 0.3,
+    domainBased: 0.2,
+  };
   const weights = { ...defaultWeights, ...(options?.weights || {}) };
 
   // Collect available signals and normalize weights
   const signals: Array<{ score: number; weight: number }> = [];
-  if (importCohesion !== undefined) signals.push({ score: importCohesion, weight: weights.importBased });
-  if (structuralCohesion !== undefined) signals.push({ score: structuralCohesion, weight: weights.structural });
+  if (importCohesion !== undefined)
+    signals.push({ score: importCohesion, weight: weights.importBased });
+  if (structuralCohesion !== undefined)
+    signals.push({ score: structuralCohesion, weight: weights.structural });
   // domain cohesion is always available
   signals.push({ score: domainCohesion, weight: weights.domainBased });
 
   const totalWeight = signals.reduce((s, el) => s + el.weight, 0);
   if (totalWeight === 0) return domainCohesion;
 
-  const combined = signals.reduce((sum, el) => sum + el.score * (el.weight / totalWeight), 0);
+  const combined = signals.reduce(
+    (sum, el) => sum + el.score * (el.weight / totalWeight),
+    0
+  );
   return combined;
 }
 
@@ -838,8 +940,10 @@ export function calculateStructuralCohesionFromCoUsage(
  * Calculate cohesion based on shared imports (Jaccard similarity)
  */
 function calculateImportBasedCohesion(exports: ExportInfo[]): number {
-  const exportsWithImports = exports.filter(e => e.imports && e.imports.length > 0);
-  
+  const exportsWithImports = exports.filter(
+    (e) => e.imports && e.imports.length > 0
+  );
+
   if (exportsWithImports.length < 2) {
     return 1; // Not enough data
   }
@@ -852,7 +956,7 @@ function calculateImportBasedCohesion(exports: ExportInfo[]): number {
     for (let j = i + 1; j < exportsWithImports.length; j++) {
       const exp1 = exportsWithImports[i] as ExportInfo & { imports: string[] };
       const exp2 = exportsWithImports[j] as ExportInfo & { imports: string[] };
-      
+
       const similarity = calculateJaccardSimilarity(exp1.imports, exp2.imports);
       totalSimilarity += similarity;
       comparisons++;
@@ -871,10 +975,10 @@ function calculateJaccardSimilarity(arr1: string[], arr2: string[]): number {
 
   const set1 = new Set(arr1);
   const set2 = new Set(arr2);
-  
-  const intersection = new Set([...set1].filter(x => set2.has(x)));
+
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
   const union = new Set([...set1, ...set2]);
-  
+
   return intersection.size / union.size;
 }
 
@@ -906,7 +1010,7 @@ function calculateDomainCohesion(exports: ExportInfo[]): number {
 /**
  * Classify a file based on its characteristics to help distinguish
  * real issues from false positives.
- * 
+ *
  * Classification types:
  * - barrel-export: Re-exports from other modules (index.ts files)
  * - type-definition: Primarily type/interface definitions
@@ -925,57 +1029,61 @@ export function classifyFile(
   domains: string[]
 ): FileClassification {
   const { exports, imports, linesOfCode, file } = node;
-  
+
+  // Some node fields are inspected by heuristics later; reference to avoid lint warnings
+  void imports;
+  void linesOfCode;
+
   // 1. Check for barrel export (index file that re-exports)
   if (isBarrelExport(node)) {
     return 'barrel-export';
   }
-  
+
   // 2. Check for type definition file
   if (isTypeDefinitionFile(node)) {
     return 'type-definition';
   }
-  
+
   // 3. Check for config/schema file (special case - acceptable multi-domain)
   if (isConfigOrSchemaFile(node)) {
     return 'cohesive-module'; // Treat as cohesive since it's intentional
   }
-  
+
   // 4. Check for lambda handlers FIRST (they often look like mixed concerns)
   if (isLambdaHandler(node)) {
     return 'lambda-handler';
   }
-  
+
   // 4b. Check for data access layer (DAL) files
   if (isDataAccessFile(node)) {
     return 'cohesive-module';
   }
-  
+
   // 5. Check for email templates (they reference multiple domains but serve one purpose)
   if (isEmailTemplate(node)) {
     return 'email-template';
   }
-  
+
   // 6. Check for parser/transformer files
   if (isParserFile(node)) {
     return 'parser-file';
   }
-  
+
   // 7. Check for service files
   if (isServiceFile(node)) {
     return 'service-file';
   }
-  
+
   // 8. Check for session/state management files
   if (isSessionFile(node)) {
     return 'cohesive-module'; // Session files manage state cohesively
   }
-  
+
   // 9. Check for Next.js App Router pages (metadata + faqJsonLd + default export)
   if (isNextJsPage(node)) {
     return 'nextjs-page';
   }
-  
+
   // 10. Check for utility file pattern (multiple domains but utility purpose)
   if (isUtilityFile(node)) {
     return 'utility-module';
@@ -985,14 +1093,17 @@ export function classifyFile(
   // should be classified as utility-module regardless of domain count.
   // This ensures common helper modules (e.g., src/utils/dynamodb-utils.ts)
   // are treated as utility modules in tests and analysis.
-  if (file.toLowerCase().includes('/utils/') || file.toLowerCase().includes('/helpers/')) {
+  if (
+    file.toLowerCase().includes('/utils/') ||
+    file.toLowerCase().includes('/helpers/')
+  ) {
     return 'utility-module';
   }
-  
+
   // 10. Check for cohesive module (single domain + reasonable cohesion)
-  const uniqueDomains = domains.filter(d => d !== 'unknown');
+  const uniqueDomains = domains.filter((d) => d !== 'unknown');
   const hasSingleDomain = uniqueDomains.length <= 1;
-  
+
   // Single domain files are almost always cohesive (even with lower cohesion score)
   if (hasSingleDomain) {
     return 'cohesive-module';
@@ -1003,27 +1114,27 @@ export function classifyFile(
   if (allExportsShareEntityNoun(exports)) {
     return 'cohesive-module';
   }
-  
+
   // 11. Check for mixed concerns (multiple domains + low cohesion)
   const hasMultipleDomains = uniqueDomains.length > 1;
   const hasLowCohesion = cohesionScore < 0.4; // Lowered threshold
-  
+
   if (hasMultipleDomains && hasLowCohesion) {
     return 'mixed-concerns';
   }
-  
+
   // 12. Default to cohesive-module for files with reasonable cohesion
   // This reduces false positives for legitimate files
   if (cohesionScore >= 0.5) {
     return 'cohesive-module';
   }
-  
+
   return 'unknown';
 }
 
 /**
  * Detect if a file is a barrel export (re-exports from other modules)
- * 
+ *
  * Characteristics of barrel exports:
  * - Named "index.ts" or "index.js"
  * - Many re-export statements (export * from, export { x } from)
@@ -1032,42 +1143,46 @@ export function classifyFile(
  */
 function isBarrelExport(node: DependencyNode): boolean {
   const { file, exports, imports, linesOfCode } = node;
-  
+
   // Check filename pattern
   const fileName = file.split('/').pop()?.toLowerCase();
-  const isIndexFile = fileName === 'index.ts' || fileName === 'index.js' || 
-                      fileName === 'index.tsx' || fileName === 'index.jsx';
-  
+  const isIndexFile =
+    fileName === 'index.ts' ||
+    fileName === 'index.js' ||
+    fileName === 'index.tsx' ||
+    fileName === 'index.jsx';
+
   // Calculate re-export ratio
   // Re-exports typically have form: export { x } from 'module' or export * from 'module'
   // They have imports AND exports, with exports coming from those imports
   const hasReExports = exports.length > 0 && imports.length > 0;
-  const highExportToLinesRatio = exports.length > 3 && linesOfCode < exports.length * 5;
-  
+  const highExportToLinesRatio =
+    exports.length > 3 && linesOfCode < exports.length * 5;
+
   // Little actual code (mostly import/export statements)
   const sparseCode = linesOfCode > 0 && linesOfCode < 50 && exports.length >= 2;
-  
+
   // Index files with re-export patterns
   if (isIndexFile && hasReExports) {
     return true;
   }
-  
+
   // Non-index files that are clearly barrel exports
   if (highExportToLinesRatio && imports.length >= exports.length * 0.5) {
     return true;
   }
-  
+
   // Very sparse files with multiple re-exports
   if (sparseCode && imports.length > 0) {
     return true;
   }
-  
+
   return false;
 }
 
 /**
  * Detect if a file is primarily a type definition file
- * 
+ *
  * Characteristics:
  * - Mostly type/interface exports
  * - Little to no runtime code
@@ -1076,41 +1191,57 @@ function isBarrelExport(node: DependencyNode): boolean {
  */
 function isTypeDefinitionFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   // Check filename pattern
   const fileName = file.split('/').pop()?.toLowerCase();
-  const isTypesFile = fileName?.includes('types') || fileName?.includes('.d.ts') ||
-                      fileName === 'types.ts' || fileName === 'interfaces.ts';
-  
+  const isTypesFile =
+    fileName?.includes('types') ||
+    fileName?.includes('.d.ts') ||
+    fileName === 'types.ts' ||
+    fileName === 'interfaces.ts';
+
   // Check if file is in a types directory (path-based detection)
   const lowerPath = file.toLowerCase();
-  const isTypesPath = lowerPath.includes('/types/') || 
-                      lowerPath.includes('/typings/') ||
-                      lowerPath.includes('/@types/') ||
-                      lowerPath.startsWith('types/') ||
-                      lowerPath.startsWith('typings/');
-  
+  const isTypesPath =
+    lowerPath.includes('/types/') ||
+    lowerPath.includes('/typings/') ||
+    lowerPath.includes('/@types/') ||
+    lowerPath.startsWith('types/') ||
+    lowerPath.startsWith('typings/');
+
   // Count type exports vs other exports
-  const typeExports = exports.filter(e => e.type === 'type' || e.type === 'interface');
-  const runtimeExports = exports.filter(e => e.type === 'function' || e.type === 'class' || e.type === 'const');
-  
+  const typeExports = exports.filter(
+    (e) => e.type === 'type' || e.type === 'interface'
+  );
+  const runtimeExports = exports.filter(
+    (e) => e.type === 'function' || e.type === 'class' || e.type === 'const'
+  );
+
   // High ratio of type exports
-  const mostlyTypes = exports.length > 0 && 
-                      typeExports.length > runtimeExports.length &&
-                      typeExports.length / exports.length > 0.7;
-  
+  const mostlyTypes =
+    exports.length > 0 &&
+    typeExports.length > runtimeExports.length &&
+    typeExports.length / exports.length > 0.7;
+
   // Pure type files (only type/interface exports, no runtime code)
-  const pureTypeFile = exports.length > 0 && typeExports.length === exports.length;
-  
+  const pureTypeFile =
+    exports.length > 0 && typeExports.length === exports.length;
+
   // Empty export file in types directory (might just be re-exports)
   const emptyOrReExportInTypesDir = isTypesPath && exports.length === 0;
-  
-  return isTypesFile || isTypesPath || mostlyTypes || pureTypeFile || emptyOrReExportInTypesDir;
+
+  return (
+    isTypesFile ||
+    isTypesPath ||
+    mostlyTypes ||
+    pureTypeFile ||
+    emptyOrReExportInTypesDir
+  );
 }
 
 /**
  * Detect if a file is a config/schema file
- * 
+ *
  * Characteristics:
  * - Named with config, schema, or settings patterns
  * - Often defines database schemas, configuration objects
@@ -1118,38 +1249,51 @@ function isTypeDefinitionFile(node: DependencyNode): boolean {
  */
 function isConfigOrSchemaFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for config/schema files
   const configPatterns = [
-    'config', 'schema', 'settings', 'options', 'constants',
-    'env', 'environment', '.config.', '-config.', '_config.',
+    'config',
+    'schema',
+    'settings',
+    'options',
+    'constants',
+    'env',
+    'environment',
+    '.config.',
+    '-config.',
+    '_config.',
   ];
-  
-  const isConfigName = configPatterns.some(pattern => 
-    fileName?.includes(pattern) || fileName?.startsWith(pattern) || fileName?.endsWith(`${pattern}.ts`)
+
+  const isConfigName = configPatterns.some(
+    (pattern) =>
+      fileName?.includes(pattern) ||
+      fileName?.startsWith(pattern) ||
+      fileName?.endsWith(`${pattern}.ts`)
   );
-  
+
   // Check if file is in a config/settings directory
-  const isConfigPath = file.toLowerCase().includes('/config/') || 
-                       file.toLowerCase().includes('/schemas/') ||
-                       file.toLowerCase().includes('/settings/');
-  
+  const isConfigPath =
+    file.toLowerCase().includes('/config/') ||
+    file.toLowerCase().includes('/schemas/') ||
+    file.toLowerCase().includes('/settings/');
+
   // Check for schema-like exports (often have table/model definitions)
-  const hasSchemaExports = exports.some(e => 
-    e.name.toLowerCase().includes('table') ||
-    e.name.toLowerCase().includes('schema') ||
-    e.name.toLowerCase().includes('config') ||
-    e.name.toLowerCase().includes('setting')
+  const hasSchemaExports = exports.some(
+    (e) =>
+      e.name.toLowerCase().includes('table') ||
+      e.name.toLowerCase().includes('schema') ||
+      e.name.toLowerCase().includes('config') ||
+      e.name.toLowerCase().includes('setting')
   );
-  
+
   return isConfigName || isConfigPath || hasSchemaExports;
 }
 
 /**
  * Detect if a file is a utility/helper file
- * 
+ *
  * Characteristics:
  * - Named with util, helper, or utility patterns
  * - Often contains mixed helper functions by design
@@ -1157,35 +1301,48 @@ function isConfigOrSchemaFile(node: DependencyNode): boolean {
  */
 function isUtilityFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for utility files
   const utilityPatterns = [
-    'util', 'utility', 'utilities', 'helper', 'helpers',
-    'common', 'shared', 'toolbox', 'toolkit',
-    '.util.', '-util.', '_util.', '-utils.', '.utils.',
+    'util',
+    'utility',
+    'utilities',
+    'helper',
+    'helpers',
+    'common',
+    'shared',
+    'toolbox',
+    'toolkit',
+    '.util.',
+    '-util.',
+    '_util.',
+    '-utils.',
+    '.utils.',
   ];
-  
-  const isUtilityName = utilityPatterns.some(pattern => 
+
+  const isUtilityName = utilityPatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Check if file is in a utils/helpers directory
-  const isUtilityPath = file.toLowerCase().includes('/utils/') || 
-                        file.toLowerCase().includes('/helpers/') ||
-                        file.toLowerCase().includes('/common/') ||
-                        file.toLowerCase().endsWith('-utils.ts') ||
-                        file.toLowerCase().endsWith('-util.ts') ||
-                        file.toLowerCase().endsWith('-helper.ts') ||
-                        file.toLowerCase().endsWith('-helpers.ts');
-  
+  const isUtilityPath =
+    file.toLowerCase().includes('/utils/') ||
+    file.toLowerCase().includes('/helpers/') ||
+    file.toLowerCase().includes('/common/') ||
+    file.toLowerCase().endsWith('-utils.ts') ||
+    file.toLowerCase().endsWith('-util.ts') ||
+    file.toLowerCase().endsWith('-helper.ts') ||
+    file.toLowerCase().endsWith('-helpers.ts');
+
   // Only consider many small exports as utility pattern if also in utility-like path
   // This prevents false positives for regular modules with many functions
-  const hasManySmallExportsInUtilityContext = exports.length >= 3 && 
-    exports.every(e => e.type === 'function' || e.type === 'const') &&
+  const hasManySmallExportsInUtilityContext =
+    exports.length >= 3 &&
+    exports.every((e) => e.type === 'function' || e.type === 'const') &&
     (isUtilityName || isUtilityPath);
-  
+
   return isUtilityName || isUtilityPath || hasManySmallExportsInUtilityContext;
 }
 
@@ -1204,13 +1361,59 @@ function splitCamelCase(name: string): string[] {
 
 /** Common English verbs and adjectives to ignore when extracting entity nouns */
 const SKIP_WORDS = new Set([
-  'get', 'set', 'create', 'update', 'delete', 'fetch', 'save', 'load',
-  'parse', 'format', 'validate', 'convert', 'transform', 'build',
-  'generate', 'render', 'send', 'receive', 'find', 'list', 'add',
-  'remove', 'insert', 'upsert', 'put', 'read', 'write', 'check',
-  'handle', 'process', 'compute', 'calculate', 'init', 'reset', 'clear',
-  'pending', 'active', 'current', 'new', 'old', 'all', 'by', 'with',
-  'from', 'to', 'and', 'or', 'is', 'has', 'in', 'on', 'of', 'the',
+  'get',
+  'set',
+  'create',
+  'update',
+  'delete',
+  'fetch',
+  'save',
+  'load',
+  'parse',
+  'format',
+  'validate',
+  'convert',
+  'transform',
+  'build',
+  'generate',
+  'render',
+  'send',
+  'receive',
+  'find',
+  'list',
+  'add',
+  'remove',
+  'insert',
+  'upsert',
+  'put',
+  'read',
+  'write',
+  'check',
+  'handle',
+  'process',
+  'compute',
+  'calculate',
+  'init',
+  'reset',
+  'clear',
+  'pending',
+  'active',
+  'current',
+  'new',
+  'old',
+  'all',
+  'by',
+  'with',
+  'from',
+  'to',
+  'and',
+  'or',
+  'is',
+  'has',
+  'in',
+  'on',
+  'of',
+  'the',
 ]);
 
 /** Singularize a word simply (strip trailing 's') */
@@ -1227,7 +1430,7 @@ function simpleSingularize(word: string): string {
  */
 function extractEntityNouns(name: string): string[] {
   return splitCamelCase(name)
-    .filter(token => !SKIP_WORDS.has(token) && token.length > 2)
+    .filter((token) => !SKIP_WORDS.has(token) && token.length > 2)
     .map(simpleSingularize);
 }
 
@@ -1237,16 +1440,16 @@ function extractEntityNouns(name: string): string[] {
  */
 function allExportsShareEntityNoun(exports: ExportInfo[]): boolean {
   if (exports.length < 2 || exports.length > 30) return false;
-  
-  const nounSets = exports.map(e => new Set(extractEntityNouns(e.name)));
-  if (nounSets.some(s => s.size === 0)) return false;
-  
+
+  const nounSets = exports.map((e) => new Set(extractEntityNouns(e.name)));
+  if (nounSets.some((s) => s.size === 0)) return false;
+
   // Find nouns that appear in ALL exports
   const [first, ...rest] = nounSets;
-  const commonNouns = Array.from(first).filter(noun =>
-    rest.every(s => s.has(noun))
+  const commonNouns = Array.from(first).filter((noun) =>
+    rest.every((s) => s.has(noun))
   );
-  
+
   return commonNouns.length > 0;
 }
 
@@ -1261,26 +1464,40 @@ function allExportsShareEntityNoun(exports: ExportInfo[]): boolean {
 function isDataAccessFile(node: DependencyNode): boolean {
   const { file, exports } = node;
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   const dalPatterns = [
-    'dynamo', 'database', 'repository', 'repo', 'dao',
-    'firestore', 'postgres', 'mysql', 'mongo', 'redis',
-    'sqlite', 'supabase', 'prisma',
+    'dynamo',
+    'database',
+    'repository',
+    'repo',
+    'dao',
+    'firestore',
+    'postgres',
+    'mysql',
+    'mongo',
+    'redis',
+    'sqlite',
+    'supabase',
+    'prisma',
   ];
-  
-  const isDalName = dalPatterns.some(p => fileName?.includes(p));
-  
-  const isDalPath = file.toLowerCase().includes('/repositories/') ||
-                    file.toLowerCase().includes('/dao/') ||
-                    file.toLowerCase().includes('/data/');
-  
+
+  const isDalName = dalPatterns.some((p) => fileName?.includes(p));
+
+  const isDalPath =
+    file.toLowerCase().includes('/repositories/') ||
+    file.toLowerCase().includes('/dao/') ||
+    file.toLowerCase().includes('/data/');
+
   // File with few exports (≤10) that all share a common entity noun
-  const hasDalExportPattern = exports.length >= 1 &&
+  const hasDalExportPattern =
+    exports.length >= 1 &&
     exports.length <= 10 &&
     allExportsShareEntityNoun(exports);
-  
+
   // Exclude obvious utility paths from DAL detection (e.g., src/utils/)
-  const isUtilityPathLocal = file.toLowerCase().includes('/utils/') || file.toLowerCase().includes('/helpers/');
+  const isUtilityPathLocal =
+    file.toLowerCase().includes('/utils/') ||
+    file.toLowerCase().includes('/helpers/');
 
   // Only treat as DAL when the file is in a DAL path, or when the name/pattern
   // indicates a data access module AND exports follow a DAL-like pattern.
@@ -1290,7 +1507,7 @@ function isDataAccessFile(node: DependencyNode): boolean {
 
 /**
  * Detect if a file is a Lambda/API handler
- * 
+ *
  * Characteristics:
  * - Named with handler patterns or in handler directories
  * - Single entry point (handler function)
@@ -1298,46 +1515,58 @@ function isDataAccessFile(node: DependencyNode): boolean {
  */
 function isLambdaHandler(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for lambda handlers
   const handlerPatterns = [
-    'handler', '.handler.', '-handler.',
-    'lambda', '.lambda.', '-lambda.',
+    'handler',
+    '.handler.',
+    '-handler.',
+    'lambda',
+    '.lambda.',
+    '-lambda.',
   ];
-  
-  const isHandlerName = handlerPatterns.some(pattern => 
+
+  const isHandlerName = handlerPatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Check if file is in a handlers/lambdas/functions/lambda directory
   // Exclude /api/ unless it has handler-specific naming
-  const isHandlerPath = file.toLowerCase().includes('/handlers/') || 
-                        file.toLowerCase().includes('/lambdas/') ||
-                        file.toLowerCase().includes('/lambda/') ||
-                        file.toLowerCase().includes('/functions/');
-  
+  const isHandlerPath =
+    file.toLowerCase().includes('/handlers/') ||
+    file.toLowerCase().includes('/lambdas/') ||
+    file.toLowerCase().includes('/lambda/') ||
+    file.toLowerCase().includes('/functions/');
+
   // Check for typical lambda handler exports (handler, main, etc.)
-  const hasHandlerExport = exports.some(e => 
-    e.name.toLowerCase() === 'handler' ||
-    e.name.toLowerCase() === 'main' ||
-    e.name.toLowerCase() === 'lambdahandler' ||
-    e.name.toLowerCase().endsWith('handler')
+  const hasHandlerExport = exports.some(
+    (e) =>
+      e.name.toLowerCase() === 'handler' ||
+      e.name.toLowerCase() === 'main' ||
+      e.name.toLowerCase() === 'lambdahandler' ||
+      e.name.toLowerCase().endsWith('handler')
   );
-  
+
   // Only consider single export as lambda handler if it's in a handler-like context
   // (either in handler directory OR has handler naming)
-  const hasSingleEntryInHandlerContext = exports.length === 1 && 
+  const hasSingleEntryInHandlerContext =
+    exports.length === 1 &&
     (exports[0].type === 'function' || exports[0].name === 'default') &&
     (isHandlerPath || isHandlerName);
-  
-  return isHandlerName || isHandlerPath || hasHandlerExport || hasSingleEntryInHandlerContext;
+
+  return (
+    isHandlerName ||
+    isHandlerPath ||
+    hasHandlerExport ||
+    hasSingleEntryInHandlerContext
+  );
 }
 
 /**
  * Detect if a file is a service file
- * 
+ *
  * Characteristics:
  * - Named with service pattern
  * - Often a class or object with multiple methods
@@ -1345,39 +1574,40 @@ function isLambdaHandler(node: DependencyNode): boolean {
  */
 function isServiceFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for service files
-  const servicePatterns = [
-    'service', '.service.', '-service.', '_service.',
-  ];
-  
-  const isServiceName = servicePatterns.some(pattern => 
+  const servicePatterns = ['service', '.service.', '-service.', '_service.'];
+
+  const isServiceName = servicePatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Check if file is in a services directory
   const isServicePath = file.toLowerCase().includes('/services/');
-  
+
   // Check for service-like exports (class with "Service" in the name)
-  const hasServiceNamedExport = exports.some(e => 
-    e.name.toLowerCase().includes('service') ||
-    e.name.toLowerCase().endsWith('service')
+  const hasServiceNamedExport = exports.some(
+    (e) =>
+      e.name.toLowerCase().includes('service') ||
+      e.name.toLowerCase().endsWith('service')
   );
-  
+
   // Check for typical service pattern (class export with service in name)
-  const hasClassExport = exports.some(e => e.type === 'class');
-  
+  const hasClassExport = exports.some((e) => e.type === 'class');
+
   // Service files need either:
   // 1. Service in filename/path, OR
   // 2. Class with "Service" in the class name
-  return isServiceName || isServicePath || (hasServiceNamedExport && hasClassExport);
+  return (
+    isServiceName || isServicePath || (hasServiceNamedExport && hasClassExport)
+  );
 }
 
 /**
  * Detect if a file is an email template/layout
- * 
+ *
  * Characteristics:
  * - Named with email/template patterns
  * - Contains render/template logic
@@ -1385,58 +1615,70 @@ function isServiceFile(node: DependencyNode): boolean {
  */
 function isEmailTemplate(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for email templates (more specific patterns)
   const emailTemplatePatterns = [
-    '-email-', '.email.', '_email_',
-    '-template', '.template.', '_template',
-    '-mail.', '.mail.',
+    '-email-',
+    '.email.',
+    '_email_',
+    '-template',
+    '.template.',
+    '_template',
+    '-mail.',
+    '.mail.',
   ];
-  
-  const isEmailTemplateName = emailTemplatePatterns.some(pattern => 
+
+  const isEmailTemplateName = emailTemplatePatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Specific template file names
-  const isSpecificTemplateName = 
+  const isSpecificTemplateName =
     fileName?.includes('receipt') ||
     fileName?.includes('invoice-email') ||
     fileName?.includes('welcome-email') ||
     fileName?.includes('notification-email') ||
-    fileName?.includes('writer') && fileName.includes('receipt');
-  
+    (fileName?.includes('writer') && fileName.includes('receipt'));
+
   // Check if file is in emails/templates directory (high confidence)
-  const isEmailPath = file.toLowerCase().includes('/emails/') || 
-                      file.toLowerCase().includes('/mail/') ||
-                      file.toLowerCase().includes('/notifications/');
-  
+  const isEmailPath =
+    file.toLowerCase().includes('/emails/') ||
+    file.toLowerCase().includes('/mail/') ||
+    file.toLowerCase().includes('/notifications/');
+
   // Check for template patterns (function that returns string/HTML)
   // More specific: must have render/generate in the function name
-  const hasTemplateFunction = exports.some(e => 
-    e.type === 'function' && (
-      e.name.toLowerCase().startsWith('render') ||
-      e.name.toLowerCase().startsWith('generate') ||
-      (e.name.toLowerCase().includes('template') && e.name.toLowerCase().includes('email'))
-    )
+  const hasTemplateFunction = exports.some(
+    (e) =>
+      e.type === 'function' &&
+      (e.name.toLowerCase().startsWith('render') ||
+        e.name.toLowerCase().startsWith('generate') ||
+        (e.name.toLowerCase().includes('template') &&
+          e.name.toLowerCase().includes('email')))
   );
-  
+
   // Check for email-related exports (but not service classes)
-  const hasEmailExport = exports.some(e => 
-    (e.name.toLowerCase().includes('template') && e.type === 'function') ||
-    (e.name.toLowerCase().includes('render') && e.type === 'function') ||
-    (e.name.toLowerCase().includes('email') && e.type !== 'class')
+  const hasEmailExport = exports.some(
+    (e) =>
+      (e.name.toLowerCase().includes('template') && e.type === 'function') ||
+      (e.name.toLowerCase().includes('render') && e.type === 'function') ||
+      (e.name.toLowerCase().includes('email') && e.type !== 'class')
   );
-  
+
   // Require path-based match OR combination of name and export patterns
-  return isEmailPath || isEmailTemplateName || isSpecificTemplateName || 
-         (hasTemplateFunction && hasEmailExport);
+  return (
+    isEmailPath ||
+    isEmailTemplateName ||
+    isSpecificTemplateName ||
+    (hasTemplateFunction && hasEmailExport)
+  );
 }
 
 /**
  * Detect if a file is a parser/transformer
- * 
+ *
  * Characteristics:
  * - Named with parser/transform patterns
  * - Contains parse/transform logic
@@ -1444,56 +1686,68 @@ function isEmailTemplate(node: DependencyNode): boolean {
  */
 function isParserFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for parser files
   const parserPatterns = [
-    'parser', '.parser.', '-parser.', '_parser.',
-    'transform', '.transform.', '-transform.',
-    'converter', '.converter.', '-converter.',
-    'mapper', '.mapper.', '-mapper.',
-    'serializer', '.serializer.',
+    'parser',
+    '.parser.',
+    '-parser.',
+    '_parser.',
+    'transform',
+    '.transform.',
+    '-transform.',
+    'converter',
+    '.converter.',
+    '-converter.',
+    'mapper',
+    '.mapper.',
+    '-mapper.',
+    'serializer',
+    '.serializer.',
     'deterministic', // For base-parser-deterministic.ts pattern
   ];
-  
-  const isParserName = parserPatterns.some(pattern => 
+
+  const isParserName = parserPatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Check if file is in parsers/transformers directory
-  const isParserPath = file.toLowerCase().includes('/parsers/') || 
-                       file.toLowerCase().includes('/transformers/') ||
-                       file.toLowerCase().includes('/converters/') ||
-                       file.toLowerCase().includes('/mappers/');
-  
+  const isParserPath =
+    file.toLowerCase().includes('/parsers/') ||
+    file.toLowerCase().includes('/transformers/') ||
+    file.toLowerCase().includes('/converters/') ||
+    file.toLowerCase().includes('/mappers/');
+
   // Check for parser-related exports
-  const hasParserExport = exports.some(e => 
-    e.name.toLowerCase().includes('parse') ||
-    e.name.toLowerCase().includes('transform') ||
-    e.name.toLowerCase().includes('convert') ||
-    e.name.toLowerCase().includes('map') ||
-    e.name.toLowerCase().includes('serialize') ||
-    e.name.toLowerCase().includes('deserialize')
+  const hasParserExport = exports.some(
+    (e) =>
+      e.name.toLowerCase().includes('parse') ||
+      e.name.toLowerCase().includes('transform') ||
+      e.name.toLowerCase().includes('convert') ||
+      e.name.toLowerCase().includes('map') ||
+      e.name.toLowerCase().includes('serialize') ||
+      e.name.toLowerCase().includes('deserialize')
   );
-  
+
   // Check for function patterns typical of parsers
-  const hasParseFunction = exports.some(e => 
-    e.type === 'function' && (
-      e.name.toLowerCase().startsWith('parse') ||
-      e.name.toLowerCase().startsWith('transform') ||
-      e.name.toLowerCase().startsWith('convert') ||
-      e.name.toLowerCase().startsWith('map') ||
-      e.name.toLowerCase().startsWith('extract')
-    )
+  const hasParseFunction = exports.some(
+    (e) =>
+      e.type === 'function' &&
+      (e.name.toLowerCase().startsWith('parse') ||
+        e.name.toLowerCase().startsWith('transform') ||
+        e.name.toLowerCase().startsWith('convert') ||
+        e.name.toLowerCase().startsWith('map') ||
+        e.name.toLowerCase().startsWith('extract'))
   );
-  
+
   return isParserName || isParserPath || hasParserExport || hasParseFunction;
 }
 
 /**
  * Detect if a file is a session/state management file
- * 
+ *
  * Characteristics:
  * - Named with session/state patterns
  * - Manages state across operations
@@ -1501,42 +1755,52 @@ function isParserFile(node: DependencyNode): boolean {
  */
 function isSessionFile(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Check filename patterns for session files
   const sessionPatterns = [
-    'session', '.session.', '-session.',
-    'state', '.state.', '-state.',
-    'context', '.context.', '-context.',
-    'store', '.store.', '-store.',
+    'session',
+    '.session.',
+    '-session.',
+    'state',
+    '.state.',
+    '-state.',
+    'context',
+    '.context.',
+    '-context.',
+    'store',
+    '.store.',
+    '-store.',
   ];
-  
-  const isSessionName = sessionPatterns.some(pattern => 
+
+  const isSessionName = sessionPatterns.some((pattern) =>
     fileName?.includes(pattern)
   );
-  
+
   // Check if file is in sessions/state directory
-  const isSessionPath = file.toLowerCase().includes('/sessions/') || 
-                        file.toLowerCase().includes('/state/') ||
-                        file.toLowerCase().includes('/context/') ||
-                        file.toLowerCase().includes('/store/');
-  
+  const isSessionPath =
+    file.toLowerCase().includes('/sessions/') ||
+    file.toLowerCase().includes('/state/') ||
+    file.toLowerCase().includes('/context/') ||
+    file.toLowerCase().includes('/store/');
+
   // Check for session-related exports
-  const hasSessionExport = exports.some(e => 
-    e.name.toLowerCase().includes('session') ||
-    e.name.toLowerCase().includes('state') ||
-    e.name.toLowerCase().includes('context') ||
-    e.name.toLowerCase().includes('manager') ||
-    e.name.toLowerCase().includes('store')
+  const hasSessionExport = exports.some(
+    (e) =>
+      e.name.toLowerCase().includes('session') ||
+      e.name.toLowerCase().includes('state') ||
+      e.name.toLowerCase().includes('context') ||
+      e.name.toLowerCase().includes('manager') ||
+      e.name.toLowerCase().includes('store')
   );
-  
+
   return isSessionName || isSessionPath || hasSessionExport;
 }
 
 /**
  * Detect if a file is a Next.js App Router page
- * 
+ *
  * Characteristics:
  * - Located in /app/ directory (Next.js App Router)
  * - Named page.tsx or page.ts
@@ -1544,38 +1808,47 @@ function isSessionFile(node: DependencyNode): boolean {
  *   - faqJsonLd, jsonLd (structured data)
  *   - icon (for tool cards)
  *   - generateMetadata (dynamic SEO)
- * 
+ *
  * This is the canonical Next.js pattern for SEO-optimized pages.
  * Multiple exports are COHESIVE - they all serve the page's purpose.
  */
 function isNextJsPage(node: DependencyNode): boolean {
   const { file, exports } = node;
-  
+
   const lowerPath = file.toLowerCase();
   const fileName = file.split('/').pop()?.toLowerCase();
-  
+
   // Must be in /app/ directory (Next.js App Router)
-  const isInAppDir = lowerPath.includes('/app/') || lowerPath.startsWith('app/');
-  
+  const isInAppDir =
+    lowerPath.includes('/app/') || lowerPath.startsWith('app/');
+
   // Must be named page.tsx or page.ts
   const isPageFile = fileName === 'page.tsx' || fileName === 'page.ts';
-  
+
   if (!isInAppDir || !isPageFile) {
     return false;
   }
-  
+
   // Check for Next.js page export patterns
-  const exportNames = exports.map(e => e.name.toLowerCase());
-  
+  const exportNames = exports.map((e) => e.name.toLowerCase());
+
   // Must have default export (the page component)
-  const hasDefaultExport = exports.some(e => e.type === 'default');
-  
+  const hasDefaultExport = exports.some((e) => e.type === 'default');
+
   // Common Next.js page exports
-  const nextJsExports = ['metadata', 'generatemetadata', 'faqjsonld', 'jsonld', 'icon', 'viewport', 'dynamic'];
-  const hasNextJsExports = exportNames.some(name => 
-    nextJsExports.includes(name) || name.includes('jsonld')
+  const nextJsExports = [
+    'metadata',
+    'generatemetadata',
+    'faqjsonld',
+    'jsonld',
+    'icon',
+    'viewport',
+    'dynamic',
+  ];
+  const hasNextJsExports = exportNames.some(
+    (name) => nextJsExports.includes(name) || name.includes('jsonld')
   );
-  
+
   // A Next.js page typically has:
   // 1. Default export (page component) - required
   // 2. Metadata or other Next.js-specific exports - optional but indicative
@@ -1584,7 +1857,7 @@ function isNextJsPage(node: DependencyNode): boolean {
 
 /**
  * Adjust cohesion score based on file classification.
- * 
+ *
  * This reduces false positives by recognizing that certain file types
  * have inherently different cohesion patterns:
  * - Utility modules may touch multiple domains but serve one purpose
@@ -1592,7 +1865,7 @@ function isNextJsPage(node: DependencyNode): boolean {
  * - Lambda handlers coordinate multiple services
  * - Email templates reference multiple domains for rendering
  * - Parser files transform data across domains
- * 
+ *
  * @param baseCohesion - The calculated cohesion score (0-1)
  * @param classification - The file classification
  * @param node - Optional node for additional heuristics
@@ -1614,10 +1887,10 @@ export function adjustCohesionForClassification(
       // Utility modules serve a functional purpose despite multi-domain.
       // Use a floor of 0.75 so related utilities never appear as low-cohesion.
       if (node) {
-        const exportNames = node.exports.map(e => e.name.toLowerCase());
+        const exportNames = node.exports.map((e) => e.name.toLowerCase());
         const hasRelatedNames = hasRelatedExportNames(exportNames);
         if (hasRelatedNames) {
-          return Math.max(0.80, Math.min(1, baseCohesion + 0.45));
+          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
         }
       }
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
@@ -1625,18 +1898,19 @@ export function adjustCohesionForClassification(
     case 'service-file': {
       // Services orchestrate dependencies by design.
       // Floor at 0.72 so service files are never flagged as low-cohesion.
-      if (node?.exports.some(e => e.type === 'class')) {
-        return Math.max(0.78, Math.min(1, baseCohesion + 0.40));
+      if (node?.exports.some((e) => e.type === 'class')) {
+        return Math.max(0.78, Math.min(1, baseCohesion + 0.4));
       }
-      return Math.max(0.72, Math.min(1, baseCohesion + 0.30));
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
     }
     case 'lambda-handler': {
       // Lambda handlers have single business purpose; floor at 0.75.
       if (node) {
-        const hasSingleEntry = node.exports.length === 1 || 
-          node.exports.some(e => e.name.toLowerCase() === 'handler');
+        const hasSingleEntry =
+          node.exports.length === 1 ||
+          node.exports.some((e) => e.name.toLowerCase() === 'handler');
         if (hasSingleEntry) {
-          return Math.max(0.80, Math.min(1, baseCohesion + 0.45));
+          return Math.max(0.8, Math.min(1, baseCohesion + 0.45));
         }
       }
       return Math.max(0.75, Math.min(1, baseCohesion + 0.35));
@@ -1644,31 +1918,33 @@ export function adjustCohesionForClassification(
     case 'email-template': {
       // Email templates are structurally cohesive (single rendering purpose); floor at 0.72.
       if (node) {
-        const hasTemplateFunc = node.exports.some(e => 
-          e.name.toLowerCase().includes('render') ||
-          e.name.toLowerCase().includes('generate') ||
-          e.name.toLowerCase().includes('template')
+        const hasTemplateFunc = node.exports.some(
+          (e) =>
+            e.name.toLowerCase().includes('render') ||
+            e.name.toLowerCase().includes('generate') ||
+            e.name.toLowerCase().includes('template')
         );
         if (hasTemplateFunc) {
-          return Math.max(0.75, Math.min(1, baseCohesion + 0.40));
+          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
         }
       }
-      return Math.max(0.72, Math.min(1, baseCohesion + 0.30));
+      return Math.max(0.72, Math.min(1, baseCohesion + 0.3));
     }
     case 'parser-file': {
       // Parsers transform data - single transformation purpose
       if (node) {
         // Check for parse/transform functions
-        const hasParseFunc = node.exports.some(e => 
-          e.name.toLowerCase().startsWith('parse') ||
-          e.name.toLowerCase().startsWith('transform') ||
-          e.name.toLowerCase().startsWith('convert')
+        const hasParseFunc = node.exports.some(
+          (e) =>
+            e.name.toLowerCase().startsWith('parse') ||
+            e.name.toLowerCase().startsWith('transform') ||
+            e.name.toLowerCase().startsWith('convert')
         );
         if (hasParseFunc) {
-          return Math.max(0.75, Math.min(1, baseCohesion + 0.40));
+          return Math.max(0.75, Math.min(1, baseCohesion + 0.4));
         }
       }
-      return Math.max(0.70, Math.min(1, baseCohesion + 0.30));
+      return Math.max(0.7, Math.min(1, baseCohesion + 0.3));
     }
     case 'nextjs-page':
       // Next.js pages have multiple exports by design (metadata, jsonLd, page component)
@@ -1682,13 +1958,13 @@ export function adjustCohesionForClassification(
       return baseCohesion;
     default:
       // Unknown - give benefit of doubt with small boost
-      return Math.min(1, baseCohesion + 0.10);
+      return Math.min(1, baseCohesion + 0.1);
   }
 }
 
 /**
  * Check if export names suggest related functionality
- * 
+ *
  * Examples of related patterns:
  * - formatDate, parseDate, validateDate (date utilities)
  * - getUser, saveUser, deleteUser (user utilities)
@@ -1696,40 +1972,73 @@ export function adjustCohesionForClassification(
  */
 function hasRelatedExportNames(exportNames: string[]): boolean {
   if (exportNames.length < 2) return true;
-  
+
   // Extract common prefixes/suffixes
   const stems = new Set<string>();
   const domains = new Set<string>();
-  
+
   for (const name of exportNames) {
     // Check for common verb prefixes
-    const verbs = ['get', 'set', 'create', 'update', 'delete', 'fetch', 'save', 'load', 'parse', 'format', 'validate', 'convert', 'transform', 'build', 'generate', 'render', 'send', 'receive'];
+    const verbs = [
+      'get',
+      'set',
+      'create',
+      'update',
+      'delete',
+      'fetch',
+      'save',
+      'load',
+      'parse',
+      'format',
+      'validate',
+      'convert',
+      'transform',
+      'build',
+      'generate',
+      'render',
+      'send',
+      'receive',
+    ];
     for (const verb of verbs) {
       if (name.startsWith(verb) && name.length > verb.length) {
         stems.add(name.slice(verb.length).toLowerCase());
       }
     }
-    
+
     // Check for domain suffixes (User, Order, etc.)
-    const domainPatterns = ['user', 'order', 'product', 'session', 'email', 'file', 'db', 's3', 'dynamo', 'api', 'config'];
+    const domainPatterns = [
+      'user',
+      'order',
+      'product',
+      'session',
+      'email',
+      'file',
+      'db',
+      's3',
+      'dynamo',
+      'api',
+      'config',
+    ];
     for (const domain of domainPatterns) {
       if (name.includes(domain)) {
         domains.add(domain);
       }
     }
   }
-  
+
   // If exports share common stems or domains, they're related
   if (stems.size === 1 && exportNames.length >= 2) return true;
   if (domains.size === 1 && exportNames.length >= 2) return true;
-  
+
   // Check for utilities with same service prefix (e.g., dynamodbGet, dynamodbPut)
-  const prefixes = exportNames.map(name => {
-    // Extract prefix before first capital letter or common separator
-    const match = name.match(/^([a-z]+)/);
-    return match ? match[1] : '';
-  }).filter(p => p.length >= 3);
-  
+  const prefixes = exportNames
+    .map((name) => {
+      // Extract prefix before first capital letter or common separator
+      const match = name.match(/^([a-z]+)/);
+      return match ? match[1] : '';
+    })
+    .filter((p) => p.length >= 3);
+
   if (prefixes.length >= 2) {
     const uniquePrefixes = new Set(prefixes);
     if (uniquePrefixes.size === 1) return true;
@@ -1737,23 +2046,62 @@ function hasRelatedExportNames(exportNames: string[]): boolean {
 
   // Check for shared entity noun across all exports using camelCase token splitting
   // e.g. getUserReceipts + createPendingReceipt both contain 'receipt'
-  const nounSets = exportNames.map(name => {
+  const nounSets = exportNames.map((name) => {
     const tokens = name
       .replace(/([A-Z])/g, ' $1')
       .trim()
       .toLowerCase()
       .split(/[\s_-]+/)
       .filter(Boolean);
-    const skip = new Set(['get','set','create','update','delete','fetch','save','load',
-      'parse','format','validate','convert','transform','build','generate','render',
-      'send','receive','find','list','add','remove','insert','upsert','put','read',
-      'write','check','handle','process','pending','active','current','new','old','all']);
-    const singularize = (w: string) => w.endsWith('s') && w.length > 3 ? w.slice(0,-1) : w;
-    return new Set(tokens.filter(t => !skip.has(t) && t.length > 2).map(singularize));
+    const skip = new Set([
+      'get',
+      'set',
+      'create',
+      'update',
+      'delete',
+      'fetch',
+      'save',
+      'load',
+      'parse',
+      'format',
+      'validate',
+      'convert',
+      'transform',
+      'build',
+      'generate',
+      'render',
+      'send',
+      'receive',
+      'find',
+      'list',
+      'add',
+      'remove',
+      'insert',
+      'upsert',
+      'put',
+      'read',
+      'write',
+      'check',
+      'handle',
+      'process',
+      'pending',
+      'active',
+      'current',
+      'new',
+      'old',
+      'all',
+    ]);
+    const singularize = (w: string) =>
+      w.endsWith('s') && w.length > 3 ? w.slice(0, -1) : w;
+    return new Set(
+      tokens.filter((t) => !skip.has(t) && t.length > 2).map(singularize)
+    );
   });
-  if (nounSets.length >= 2 && nounSets.every(s => s.size > 0)) {
+  if (nounSets.length >= 2 && nounSets.every((s) => s.size > 0)) {
     const [first, ...rest] = nounSets;
-    const commonNouns = Array.from(first).filter(n => rest.every(s => s.has(n)));
+    const commonNouns = Array.from(first).filter((n) =>
+      rest.every((s) => s.has(n))
+    );
     if (commonNouns.length > 0) return true;
   }
 
@@ -1762,7 +2110,7 @@ function hasRelatedExportNames(exportNames: string[]): boolean {
 
 /**
  * Adjust fragmentation score based on file classification
- * 
+ *
  * This reduces false positives by:
  * - Ignoring fragmentation for barrel exports (they're meant to aggregate)
  * - Ignoring fragmentation for type definitions (centralized types are good)