@aiready/context-analyzer 0.5.3 → 0.7.0

package/dist/index.js

@@ -21,20 +21,252 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   analyzeContext: () => analyzeContext,
+  buildCoUsageMatrix: () => buildCoUsageMatrix,
+  buildTypeGraph: () => buildTypeGraph,
+  calculateDomainConfidence: () => calculateDomainConfidence,
+  findConsolidationCandidates: () => findConsolidationCandidates,
+  findSemanticClusters: () => findSemanticClusters,
   generateSummary: () => generateSummary,
-  getSmartDefaults: () => getSmartDefaults
+  getCoUsageData: () => getCoUsageData,
+  getSmartDefaults: () => getSmartDefaults,
+  inferDomainFromSemantics: () => inferDomainFromSemantics
 });
 module.exports = __toCommonJS(index_exports);
 var import_core2 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core = require("@aiready/core");
+
+// src/semantic-analysis.ts
+function buildCoUsageMatrix(graph) {
+  const coUsageMatrix = /* @__PURE__ */ new Map();
+  for (const [sourceFile, node] of graph.nodes) {
+    const imports = node.imports;
+    for (let i = 0; i < imports.length; i++) {
+      const fileA = imports[i];
+      if (!coUsageMatrix.has(fileA)) {
+        coUsageMatrix.set(fileA, /* @__PURE__ */ new Map());
+      }
+      for (let j = i + 1; j < imports.length; j++) {
+        const fileB = imports[j];
+        const fileAUsage = coUsageMatrix.get(fileA);
+        fileAUsage.set(fileB, (fileAUsage.get(fileB) || 0) + 1);
+        if (!coUsageMatrix.has(fileB)) {
+          coUsageMatrix.set(fileB, /* @__PURE__ */ new Map());
+        }
+        const fileBUsage = coUsageMatrix.get(fileB);
+        fileBUsage.set(fileA, (fileBUsage.get(fileA) || 0) + 1);
+      }
+    }
+  }
+  return coUsageMatrix;
+}
+function buildTypeGraph(graph) {
+  const typeGraph = /* @__PURE__ */ new Map();
+  for (const [file, node] of graph.nodes) {
+    for (const exp of node.exports) {
+      if (exp.typeReferences) {
+        for (const typeRef of exp.typeReferences) {
+          if (!typeGraph.has(typeRef)) {
+            typeGraph.set(typeRef, /* @__PURE__ */ new Set());
+          }
+          typeGraph.get(typeRef).add(file);
+        }
+      }
+    }
+  }
+  return typeGraph;
+}
+function findSemanticClusters(coUsageMatrix, minCoUsage = 3) {
+  const clusters = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  for (const [file, coUsages] of coUsageMatrix) {
+    if (visited.has(file)) continue;
+    const cluster = [file];
+    visited.add(file);
+    for (const [relatedFile, count] of coUsages) {
+      if (count >= minCoUsage && !visited.has(relatedFile)) {
+        cluster.push(relatedFile);
+        visited.add(relatedFile);
+      }
+    }
+    if (cluster.length > 1) {
+      clusters.set(file, cluster);
+    }
+  }
+  return clusters;
+}
+function calculateDomainConfidence(signals) {
+  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;
+}
+function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGraph, exportTypeRefs) {
+  const assignments = [];
+  const domainSignals = /* @__PURE__ */ new Map();
+  const coUsages = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
+  const strongCoUsages = Array.from(coUsages.entries()).filter(([_, count]) => count >= 3).map(([coFile]) => coFile);
+  for (const coFile of strongCoUsages) {
+    const coNode = graph.nodes.get(coFile);
+    if (coNode) {
+      for (const exp of coNode.exports) {
+        if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
+          const domain = exp.inferredDomain;
+          if (!domainSignals.has(domain)) {
+            domainSignals.set(domain, {
+              coUsage: false,
+              typeReference: false,
+              exportName: false,
+              importPath: false,
+              folderStructure: false
+            });
+          }
+          domainSignals.get(domain).coUsage = true;
+        }
+      }
+    }
+  }
+  if (exportTypeRefs) {
+    for (const typeRef of exportTypeRefs) {
+      const filesWithType = typeGraph.get(typeRef);
+      if (filesWithType) {
+        for (const typeFile of filesWithType) {
+          if (typeFile !== file) {
+            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;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const [domain, signals] of domainSignals) {
+    const confidence = calculateDomainConfidence(signals);
+    if (confidence >= 0.3) {
+      assignments.push({ domain, confidence, signals });
+    }
+  }
+  assignments.sort((a, b) => b.confidence - a.confidence);
+  return assignments;
+}
+function getCoUsageData(file, coUsageMatrix) {
+  const coImportedWith = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
+  const sharedImporters = [];
+  return {
+    file,
+    coImportedWith,
+    sharedImporters
+  };
+}
+function findConsolidationCandidates(graph, coUsageMatrix, typeGraph, minCoUsage = 5, minSharedTypes = 2) {
+  const candidates = [];
+  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;
+      if (coUsageCount < minCoUsage) continue;
+      const nodeB = graph.nodes.get(fileB);
+      if (!nodeB) continue;
+      const typesA = new Set(nodeA.exports.flatMap((e) => e.typeReferences || []));
+      const typesB = new Set(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;
+        candidates.push({
+          files: [fileA, fileB],
+          reason: `High co-usage (${coUsageCount}x) and ${sharedTypes.length} shared types`,
+          strength
+        });
+      } else if (coUsageCount >= minCoUsage * 2) {
+        const strength = coUsageCount / 10;
+        candidates.push({
+          files: [fileA, fileB],
+          reason: `Very high co-usage (${coUsageCount}x)`,
+          strength
+        });
+      }
+    }
+  }
+  candidates.sort((a, b) => b.strength - a.strength);
+  return candidates;
+}
+
+// src/analyzer.ts
+function extractDomainKeywordsFromPaths(files) {
+  const folderNames = /* @__PURE__ */ new Set();
+  for (const { file } of files) {
+    const segments = file.split("/");
+    const skipFolders = /* @__PURE__ */ 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(".")) {
+        const singular = singularize(normalized);
+        folderNames.add(singular);
+      }
+    }
+  }
+  return Array.from(folderNames);
+}
+function singularize(word) {
+  const irregulars = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman"
+  };
+  if (irregulars[word]) {
+    return irregulars[word];
+  }
+  if (word.endsWith("ies")) {
+    return word.slice(0, -3) + "y";
+  }
+  if (word.endsWith("ses")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && word.length > 3) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
 function buildDependencyGraph(files) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
+  const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
-    const exports2 = extractExports(content);
+    const exports2 = extractExportsWithAST(content, file, { domainKeywords: autoDetectedKeywords }, imports);
     const tokenCost = (0, import_core.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
     nodes.set(file, {
@@ -46,7 +278,28 @@ function buildDependencyGraph(files) {
     });
     edges.set(file, new Set(imports));
   }
-  return { nodes, edges };
+  const graph = { nodes, edges };
+  const coUsageMatrix = buildCoUsageMatrix(graph);
+  const typeGraph = buildTypeGraph(graph);
+  graph.coUsageMatrix = coUsageMatrix;
+  graph.typeGraph = typeGraph;
+  for (const [file, node] of nodes) {
+    for (const exp of node.exports) {
+      const semanticAssignments = inferDomainFromSemantics(
+        file,
+        exp.name,
+        graph,
+        coUsageMatrix,
+        typeGraph,
+        exp.typeReferences
+      );
+      exp.domains = semanticAssignments;
+      if (semanticAssignments.length > 0) {
+        exp.inferredDomain = semanticAssignments[0].domain;
+      }
+    }
+  }
+  return graph;
 }
 function extractImportsFromContent(content) {
   const imports = [];
@@ -62,7 +315,7 @@ function extractImportsFromContent(content) {
     let match;
     while ((match = pattern.exec(content)) !== null) {
       const importPath = match[1];
-      if (importPath && !importPath.startsWith("@") && !importPath.startsWith("node:")) {
+      if (importPath && !importPath.startsWith("node:")) {
         imports.push(importPath);
       }
     }
@@ -149,26 +402,7 @@ function detectCircularDependencies(graph) {
   return cycles;
 }
 function calculateCohesion(exports2, filePath) {
-  if (exports2.length === 0) return 1;
-  if (exports2.length === 1) return 1;
-  if (filePath && isTestFile(filePath)) {
-    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;
+  return calculateEnhancedCohesion(exports2, filePath);
 }
 function isTestFile(filePath) {
   const lower = filePath.toLowerCase();
@@ -221,7 +455,7 @@ function detectModuleClusters(graph) {
   }
   return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
 }
-function extractExports(content) {
+function extractExports(content, filePath, domainOptions, fileImports) {
   const exports2 = [];
   const patterns = [
     /export\s+function\s+(\w+)/g,
@@ -244,15 +478,20 @@ function extractExports(content) {
     while ((match = pattern.exec(content)) !== null) {
       const name = match[1] || "default";
       const type = types[index];
-      const inferredDomain = inferDomain(name);
+      const inferredDomain = inferDomain(name, filePath, domainOptions, fileImports);
       exports2.push({ name, type, inferredDomain });
     }
   });
   return exports2;
 }
-function inferDomain(name) {
+function inferDomain(name, filePath, domainOptions, fileImports) {
   const lower = name.toLowerCase();
-  const domainKeywords = [
+  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",
@@ -269,14 +508,11 @@ function inferDomain(name) {
     "config",
     "model",
     "view",
-    "auth",
-    "api",
-    "helper",
-    "util"
+    "auth"
   ];
+  const domainKeywords = domainOptions?.domainKeywords && domainOptions.domainKeywords.length ? [...domainOptions.domainKeywords, ...defaultKeywords] : defaultKeywords;
   for (const keyword of domainKeywords) {
-    const wordBoundaryPattern = new RegExp(`\\b${keyword}\\b`, "i");
-    if (wordBoundaryPattern.test(name)) {
+    if (tokens.includes(keyword)) {
       return keyword;
     }
   }
@@ -285,6 +521,37 @@ function inferDomain(name) {
       return keyword;
     }
   }
+  if (fileImports && fileImports.length > 0) {
+    for (const importPath of fileImports) {
+      const allSegments = importPath.split("/");
+      const relevantSegments = allSegments.filter((s) => {
+        if (!s) return false;
+        if (s === "." || s === "..") return false;
+        if (s.startsWith("@") && s.length === 1) return false;
+        return true;
+      }).map((s) => s.startsWith("@") ? s.slice(1) : s);
+      for (const segment of relevantSegments) {
+        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 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)) {
+          return keyword;
+        }
+      }
+    }
+  }
   return "unknown";
 }
 function generateConsolidationPlan(domain, files, targetFiles) {
@@ -313,6 +580,78 @@ function generateConsolidationPlan(domain, files, targetFiles) {
   );
   return plan;
 }
+function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
+  try {
+    const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
+    return astExports.map((exp) => ({
+      name: exp.name,
+      type: exp.type,
+      inferredDomain: inferDomain(exp.name, filePath, domainOptions, fileImports),
+      imports: exp.imports,
+      dependencies: exp.dependencies
+    }));
+  } catch (error) {
+    return extractExports(content, filePath, domainOptions, fileImports);
+  }
+}
+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) {
@@ -646,6 +985,13 @@ function downgradeSeverity(s) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyzeContext,
+  buildCoUsageMatrix,
+  buildTypeGraph,
+  calculateDomainConfidence,
+  findConsolidationCandidates,
+  findSemanticClusters,
   generateSummary,
-  getSmartDefaults
+  getCoUsageData,
+  getSmartDefaults,
+  inferDomainFromSemantics
 });

package/dist/index.mjs

@@ -1,10 +1,24 @@
 import {
   analyzeContext,
+  buildCoUsageMatrix,
+  buildTypeGraph,
+  calculateDomainConfidence,
+  findConsolidationCandidates,
+  findSemanticClusters,
   generateSummary,
-  getSmartDefaults
-} from "./chunk-EX7HCWAO.mjs";
+  getCoUsageData,
+  getSmartDefaults,
+  inferDomainFromSemantics
+} from "./chunk-DMRZMS2U.mjs";
 export {
   analyzeContext,
+  buildCoUsageMatrix,
+  buildTypeGraph,
+  calculateDomainConfidence,
+  findConsolidationCandidates,
+  findSemanticClusters,
   generateSummary,
-  getSmartDefaults
+  getCoUsageData,
+  getSmartDefaults,
+  inferDomainFromSemantics
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/context-analyzer",
-  "version": "0.5.3",
+  "version": "0.7.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.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",

package/src/__tests__/auto-detection.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect } from 'vitest';
+import { buildDependencyGraph } from '../analyzer';
+
+describe('Auto-detection from folder structure', () => {
+  it('should auto-detect domain keywords from folder paths', () => {
+    const files = [
+      {
+        file: 'src/payments/process.ts',
+        content: 'export function processPayment() { return 1; }',
+      },
+      {
+        file: 'src/orders/create.ts',
+        content: 'export function createOrder() { return 2; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const paymentsNode = graph.nodes.get('src/payments/process.ts');
+    const ordersNode = graph.nodes.get('src/orders/create.ts');
+
+    // Should detect 'payment' from processPayment (now part of auto-detected keywords)
+    expect(paymentsNode?.exports[0].inferredDomain).toBe('payment');
+    
+    // Should detect 'order' from createOrder
+    expect(ordersNode?.exports[0].inferredDomain).toBe('order');
+  });
+
+  it('should detect domains from nested folders', () => {
+    const files = [
+      {
+        file: 'src/api/invoices/handler.ts',
+        content: 'export function handleRequest() { return 1; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const node = graph.nodes.get('src/api/invoices/handler.ts');
+
+    // Should detect 'invoice' from path (invoices folder)
+    expect(node?.exports[0].inferredDomain).toBe('invoice');
+  });
+
+  it('should skip common infrastructure folders', () => {
+    const files = [
+      {
+        file: 'src/utils/helpers/format.ts',
+        content: 'export function formatData() { return 1; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const node = graph.nodes.get('src/utils/helpers/format.ts');
+
+    // 'utils' and 'helpers' should be skipped, no domain detected
+    expect(node?.exports[0].inferredDomain).toBe('unknown');
+  });
+
+  it('should merge auto-detected with custom keywords', () => {
+    const files = [
+      {
+        file: 'src/receipts/scan.ts',
+        content: 'export function scanReceipt() { return 1; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files, {
+      domainKeywords: ['receipt'], // Custom keyword
+    });
+    const node = graph.nodes.get('src/receipts/scan.ts');
+
+    // Should detect 'receipt' from both auto-detection AND custom keywords
+    expect(node?.exports[0].inferredDomain).toBe('receipt');
+  });
+});
+
+describe('Import-path domain inference', () => {
+  it('should infer domain from import paths', () => {
+    const files = [
+      {
+        file: 'src/lib/session.ts',
+        content: `
+          import { processPayment } from '../payments/processor';
+          export function createSession() { return 1; }
+        `,
+      },
+      {
+        file: 'src/payments/processor.ts',
+        content: 'export function processPayment() { return 2; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const sessionNode = graph.nodes.get('src/lib/session.ts');
+
+    // session.ts imports from '../payments/...' so should infer 'payment' domain
+    expect(sessionNode?.exports[0].inferredDomain).toBe('payment');
+  });
+
+  it('should infer domain from absolute import paths', () => {
+    const files = [
+      {
+        file: 'src/components/nav-links.ts',
+        content: `
+          import { getOrders } from '@/orders/service';
+          export function NavLinks() { return 'nav'; }
+        `,
+      },
+      {
+        file: 'src/orders/service.ts',
+        content: 'export function getOrders() { return []; }',
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const navNode = graph.nodes.get('src/components/nav-links.ts');
+
+    // nav-links.ts imports from '@/orders/...' so should infer 'order' domain
+    expect(navNode?.exports[0].inferredDomain).toBe('order');
+  });
+
+  it('should use identifier name first before import-path fallback', () => {
+    const files = [
+      {
+        file: 'src/lib/handler.ts',
+        content: `
+          import { processPayment } from '../payments/processor';
+          export function processInvoice() { return 1; }
+        `,
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const node = graph.nodes.get('src/lib/handler.ts');
+
+    // processInvoice should match 'invoice' from identifier, not 'payment' from imports
+    expect(node?.exports[0].inferredDomain).toBe('invoice');
+  });
+
+  it('should fall back to import-path when identifier is generic', () => {
+    const files = [
+      {
+        file: 'src/lib/dynamodb.ts',
+        content: `
+          import { Customer } from '../customers/model';
+          export function connect() { return 1; }
+        `,
+      },
+    ];
+
+    const graph = buildDependencyGraph(files);
+    const node = graph.nodes.get('src/lib/dynamodb.ts');
+
+    // 'connect' is generic, should infer 'customer' from import path
+    expect(node?.exports[0].inferredDomain).toBe('customer');
+  });
+});