@chappibunny/repolens 1.15.1 → 1.15.3

package/src/analyzers/context-builder.js

@@ -1,6 +1,6 @@
 // Build structured AI context from deterministic scan results
 
-import { groupModulesByDomain } from "./domain-inference.js";
+import { groupModulesByDomain, pathHasKeyword } from "./domain-inference.js";
 
 /**
  * Compute per-module dependency metrics from the dep graph.
@@ -91,7 +91,7 @@ export function buildAIContext(scanResult, config, depGraph = null) {
     : [];
   
   // Group modules by business domain
-  const domainGroups = groupModulesByDomain(modules, customHints);
+  const domainGroups = groupModulesByDomain(modules, customHints, depGraph);
   
   // Compute module-level dependency metrics
   const moduleMetrics = computeModuleLevelMetrics(depGraph, modules);
@@ -175,40 +175,99 @@ export function buildAIContext(scanResult, config, depGraph = null) {
 }
 
 function inferModuleType(modulePath) {
-  const lower = modulePath.toLowerCase();
-  
-  if (lower.includes("test") || lower.includes("spec") || lower.includes("__test")) return "test";
-  if (lower.includes("api") || lower.includes("endpoint")) return "api";
-  if (lower.includes("component") || lower.includes("widget")) return "ui";
-  if (lower.includes("lib") || lower.includes("util") || lower.includes("helper") || lower.includes("common") || lower.includes("shared")) return "library";
-  if (lower.includes("hook")) return "hooks";
-  if (lower.includes("store") || lower.includes("state") || lower.includes("redux") || lower.includes("zustand")) return "state";
-  if (lower.includes("page") || lower.includes("route") || lower.includes("view")) return "route";
-  if (lower.includes("config") || lower.includes("setting") || lower.includes("env")) return "config";
-  if (lower.includes("core") || lower.includes("kernel") || lower.includes("foundation")) return "core";
-  if (lower.includes("render") || lower.includes("template") || lower.includes("format")) return "renderer";
-  if (lower.includes("publish") || lower.includes("output") || lower.includes("export")) return "publisher";
-  if (lower.includes("analyz") || lower.includes("inspect") || lower.includes("detect")) return "analyzer";
-  if (lower.includes("plugin") || lower.includes("extension") || lower.includes("addon")) return "plugin";
-  if (lower.includes("deliver") || lower.includes("dispatch") || lower.includes("send")) return "delivery";
-  if (lower.includes("doc") || lower.includes("generate")) return "documentation";
-  if (lower.includes("integrat") || lower.includes("connect") || lower.includes("adapter")) return "integration";
-  if (lower.includes("cli") || lower.includes("command") || lower.includes("bin")) return "cli";
-  if (lower.includes("ai") || lower.includes("ml") || lower.includes("model") || lower.includes("prompt")) return "ai";
-  if (lower.includes("auth") || lower.includes("login") || lower.includes("session")) return "auth";
-  if (lower.includes("data") || lower.includes("db") || lower.includes("model") || lower.includes("schema")) return "data";
-  if (lower.includes("middleware")) return "middleware";
-  if (lower.includes("service")) return "service";
-  if (lower.includes("app")) return "app";
-  
+  const has = (keyword) => pathHasKeyword(modulePath, keyword);
+
+  if (has("test") || has("spec")) return "test";
+  if (has("api") || has("endpoint")) return "api";
+  if (has("component") || has("widget")) return "ui";
+  if (has("lib") || has("util") || has("helper") || has("common") || has("shared")) return "library";
+  if (has("hook")) return "hooks";
+  if (has("store") || has("state") || has("redux") || has("zustand")) return "state";
+  if (has("page") || has("route") || has("view")) return "route";
+  if (has("config") || has("setting") || has("env")) return "config";
+  if (has("core") || has("kernel") || has("foundation")) return "core";
+  if (has("render") || has("template") || has("format")) return "renderer";
+  if (has("publish") || has("output") || has("export")) return "publisher";
+  if (has("analyz") || has("inspect") || has("detect")) return "analyzer";
+  if (has("plugin") || has("extension") || has("addon")) return "plugin";
+  if (has("deliver") || has("dispatch") || has("send")) return "delivery";
+  if (has("doc") || has("generate")) return "documentation";
+  if (has("integrat") || has("connect") || has("adapter")) return "integration";
+  if (has("cli") || has("command") || has("bin")) return "cli";
+  if (has("ai") || has("llm") || has("openai") || has("prompt")) return "ai";
+  if (has("auth") || has("login") || has("session")) return "auth";
+  if (has("data") || has("db") || has("schema")) return "data";
+  if (has("middleware")) return "middleware";
+  if (has("service")) return "service";
+  if (has("app")) return "app";
+
   return "other";
 }
 
+function isTestEvidence(modulePath) {
+  const norm = String(modulePath || "").replace(/\\/g, "/");
+  if (/(^|\/)__(tests|mocks)__(\/|$)/.test(norm)) return true;
+  if (/(^|\/)(test|tests|spec|specs|fixtures|testdata)(\/|$)/.test(norm)) return true;
+  const base = norm.split("/").pop() || "";
+  if (/^(test_|spec_)/.test(base)) return true;
+  if (/(_test|_spec)\.[a-z0-9]+$/i.test(base)) return true;
+  if (/\.(test|spec)\.[a-z0-9]+$/i.test(base)) return true;
+  return false;
+}
+
+const API_DIRECTORY_SEGMENTS = new Set([
+  "api", "apis", "route", "routes", "router", "routers",
+  "endpoint", "endpoints", "controller", "controllers", "handler", "handlers",
+]);
+
+function hasApiDirectory(modulePath) {
+  return directoryPath(modulePath)
+    .split("/")
+    .some((segment) => API_DIRECTORY_SEGMENTS.has(segment.toLowerCase()));
+}
+
+function directoryPath(modulePath) {
+  const parts = String(modulePath || "").replace(/\\/g, "/").split("/");
+  const last = parts[parts.length - 1] || "";
+  if (/\.[a-z0-9]+$/i.test(last)) parts.pop();
+  return parts.join("/");
+}
+
 function inferArchitecturalPatterns(modules, depGraph = null) {
   const patterns = [];
-  const keys = modules.map(m => m.key.toLowerCase());
-  
-  const has = (keyword) => keys.some(k => k.includes(keyword));
+  const production = modules.filter((module) => !isTestEvidence(module.key));
+  const tests = modules.filter((module) => isTestEvidence(module.key));
+  const keys = production.map(m => m.key.toLowerCase());
+
+  const has = (keyword) => keys.some((key) => (
+    keyword.includes("/") ? key.includes(keyword) : pathHasKeyword(key, keyword)
+  ));
+  const matchingKeys = (keywords, source = production) => {
+    const found = [];
+    for (const keyword of keywords) {
+      for (const module of source) {
+        const key = module.key;
+        const matched = keyword.includes("/")
+          ? key.toLowerCase().includes(keyword)
+          : pathHasKeyword(key, keyword);
+        if (matched && !found.includes(key)) found.push(key);
+      }
+    }
+    return found;
+  };
+  const hasApiRouteEvidence = () => production.some((module) => hasApiDirectory(module.key));
+  const cite = (label, keywords, extra = "", source = production) => {
+    const found = matchingKeys(keywords, source);
+    if (found.length === 0 && !extra) return;
+    const sample = found.slice(0, 3).map((key) => `\`${key}\``).join(", ");
+    const more = found.length > 3 ? ` (+${found.length - 3} more)` : "";
+    const where = sample ? `${sample}${more}` : "";
+    const detail = [where, extra].filter(Boolean).join("; ");
+    patterns.push(detail ? `${label} — ${detail}` : label);
+  };
+  const externalNames = depGraph?.externalDeps || [];
+  const importsReact = externalNames.some((name) => name === "react" || name === "react-dom" || name.startsWith("react/"));
+  const importsAi = externalNames.some((name) => /(^|\/)(openai|anthropic|langchain|ollama)(\/|$)/i.test(name) || name.startsWith("@anthropic-ai/") || name.startsWith("@ai-sdk/"));
 
   // Compute module-level metrics for verification
   const moduleMetrics = depGraph ? computeModuleLevelMetrics(depGraph, modules) : new Map();
@@ -217,6 +276,7 @@ function inferArchitecturalPatterns(modules, depGraph = null) {
   // Verify pattern: a module matching `keyword` has high fan-in (truly central)
   const verifyHub = (keyword) => {
     for (const [mKey, m] of moduleMetrics) {
+      if (isTestEvidence(mKey)) continue;
       if (mKey.toLowerCase().includes(keyword) && m.fanIn >= 3) return true;
     }
     return false;
@@ -225,74 +285,69 @@ function inferArchitecturalPatterns(modules, depGraph = null) {
   // Verify pattern: modules matching keyword have mostly outbound deps (orchestrators)
   const verifyOrchestrator = (keyword) => {
     for (const [mKey, m] of moduleMetrics) {
+      if (isTestEvidence(mKey)) continue;
       if (mKey.toLowerCase().includes(keyword) && m.fanOut >= 3) return true;
     }
     return false;
   };
   
-  // Web framework patterns
-  if (has("app/")) patterns.push("Next.js App Router");
-  if (has("pages/")) patterns.push("Next.js Pages Router");
-  if (has("component") && has("lib")) patterns.push("Layered component architecture");
-  if (has("hook")) patterns.push("React hooks pattern");
-  if (has("store") || has("state") || has("redux") || has("zustand")) patterns.push("Centralized state management");
-  
-  // General patterns — verified against dep graph when available
-  if (has("api") || has("endpoint")) patterns.push("API route pattern");
+  // Web framework patterns. Each line names the modules (or imports) that triggered it.
+  if (has("app/")) cite("Next.js App Router", ["app/"]);
+  if (has("pages/")) cite("Next.js Pages Router", ["pages/"]);
+  if (has("component") && has("lib")) cite("Layered component architecture", ["component", "lib"]);
+  if (has("hook") && importsReact) cite("React hooks pattern", ["hook"], "imports react");
+  if (has("store") || has("state") || has("redux") || has("zustand")) {
+    cite("Centralized state management", ["store", "state", "redux", "zustand"]);
+  }
+
+  if (hasApiRouteEvidence()) {
+    const found = production
+      .filter((module) => hasApiDirectory(module.key))
+      .map((module) => module.key);
+    const sample = found.slice(0, 3).map((key) => `\`${key}\``).join(", ");
+    const more = found.length > 3 ? ` (+${found.length - 3} more)` : "";
+    patterns.push(`API route pattern — ${sample}${more}`);
+  }
 
   if (has("core") || has("kernel")) {
-    if (moduleMetrics.size > 0 && verifyHub("core")) {
-      patterns.push("Core/kernel architecture (verified — high fan-in)");
-    } else if (moduleMetrics.size > 0) {
-      patterns.push("Core/kernel architecture (naming only)");
-    } else {
-      patterns.push("Core/kernel architecture");
-    }
+    const note = moduleMetrics.size > 0 && verifyHub("core")
+      ? "high fan-in"
+      : "";
+    cite("Core/kernel architecture", ["core", "kernel"], note);
   }
 
   if (has("plugin") || has("extension")) {
-    if (moduleMetrics.size > 0 && (verifyHub("plugin") || verifyOrchestrator("plugin") || verifyHub("loader"))) {
-      patterns.push("Plugin system (verified — loader/registry detected)");
-    } else if (moduleMetrics.size > 0) {
-      patterns.push("Plugin system (naming only)");
-    } else {
-      patterns.push("Plugin system");
-    }
+    const verified = moduleMetrics.size > 0 && (verifyHub("plugin") || verifyOrchestrator("plugin") || verifyHub("loader"));
+    cite("Plugin system", ["plugin", "extension"], verified ? "loader or registry fan-in" : "");
   }
 
-  if (has("middleware")) patterns.push("Middleware pipeline");
+  if (has("middleware")) cite("Middleware pipeline", ["middleware"]);
 
   if (has("render") || has("template")) {
-    if (moduleMetrics.size > 0 && verifyOrchestrator("render")) {
-      patterns.push("Renderer pipeline (verified — multi-output)");
-    } else {
-      patterns.push("Renderer pipeline");
-    }
+    const note = moduleMetrics.size > 0 && verifyOrchestrator("render") ? "multi-output fan-out" : "";
+    cite("Renderer pipeline", ["render", "template"], note);
   }
 
   if (has("publish") || has("output")) {
-    if (moduleMetrics.size > 0 && verifyOrchestrator("publish")) {
-      patterns.push("Multi-output publishing (verified — multiple targets)");
-    } else {
-      patterns.push("Multi-output publishing");
-    }
+    const note = moduleMetrics.size > 0 && verifyOrchestrator("publish") ? "multiple publish targets" : "";
+    cite("Multi-output publishing", ["publish", "output"], note);
   }
 
-  if (has("analyz") || has("detect") || has("inspect")) patterns.push("Analysis pipeline");
-  if (has("cli") || has("command") || has("bin")) patterns.push("CLI tool architecture");
-  
+  if (has("analyz") || has("detect") || has("inspect")) cite("Analysis pipeline", ["analyz", "detect", "inspect"]);
+  if (has("cli") || has("command") || has("bin")) cite("CLI tool architecture", ["cli", "command", "bin"]);
+
   if (has("util") || has("helper") || has("lib")) {
-    if (moduleMetrics.size > 0 && verifyHub("util") || verifyHub("helper") || verifyHub("lib")) {
-      patterns.push("Shared utility layer (verified — high fan-in)");
-    } else {
-      patterns.push("Shared utility layer");
-    }
+    const verified = moduleMetrics.size > 0 && verifyHub("util") || verifyHub("helper") || verifyHub("lib");
+    cite("Shared utility layer", ["util", "helper", "lib"], verified ? "high fan-in" : "");
   }
-  
-  if (has("integrat") || has("adapter") || has("connect")) patterns.push("Integration adapters");
-  if (has("ai") || has("prompt") || has("provider")) patterns.push("AI/LLM integration");
-  if (has("deliver") || has("dispatch")) patterns.push("Delivery pipeline");
-  if (has("test") || has("spec")) patterns.push("Dedicated test infrastructure");
+
+  if (has("integrat") || has("adapter") || has("connect")) cite("Integration adapters", ["integrat", "adapter", "connect"]);
+  if (has("ai") || has("llm") || has("openai") || has("anthropic") || importsAi) {
+    const aiPackages = externalNames.filter((name) => /(^|\/)(openai|anthropic|langchain|ollama)(\/|$)/i.test(name) || name.startsWith("@anthropic-ai/") || name.startsWith("@ai-sdk/"));
+    cite("AI/LLM integration", ["ai", "llm", "openai", "anthropic"], aiPackages.length ? `imports ${aiPackages.slice(0, 3).join(", ")}` : "");
+  }
+  if (has("deliver") || has("dispatch")) cite("Delivery pipeline", ["deliver", "dispatch"]);
+  if (tests.length) cite("Dedicated test infrastructure", ["test", "spec"], "", tests);
 
   // Structural patterns from dep graph (not keyword-based)
   if (depGraph?.stats) {
@@ -334,7 +389,7 @@ export function buildModuleContext(modules, config, depGraph = null) {
       }))
     : [];
   
-  const domainGroups = groupModulesByDomain(modules, customHints);
+  const domainGroups = groupModulesByDomain(modules, customHints, depGraph);
   const moduleMetrics = computeModuleLevelMetrics(depGraph, modules);
   
   return modules.map(module => {

package/src/analyzers/dependency-graph.js

@@ -1,23 +1,25 @@
-// Dependency graph analysis with cycle detection
-// Parses import/require statements, builds a directed graph, detects cycles via DFS
+// Dependency graph analysis with cycle detection.
+// JavaScript, TypeScript, Python, and Go imports become edges.
+// Comments and strings are ignored. Type-only TypeScript imports are not edges.
 
 import fs from "node:fs/promises";
 import path from "node:path";
 import { info, warn } from "../utils/logger.js";
-
-const CODE_EXTENSIONS = new Set([".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"]);
-
-// Patterns for extracting imports
-const IMPORT_PATTERNS = [
-  // ES module: import ... from "..."
-  /import\s+(?:[\w*{},\s]+\s+from\s+)?['"]([^'"]+)['"]/g,
-  // Dynamic import: import("...")
-  /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-  // CommonJS: require("...")
-  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-  // Re-export: export ... from "..."
-  /export\s+(?:[\w*{},\s]+\s+from\s+)?['"]([^'"]+)['"]/g,
-];
+import {
+  extractJsImports,
+  externalPackageName,
+  extractPythonImports,
+  extractGoImports,
+  indexPythonModules,
+  resolvePythonImport,
+  goPackageDir,
+  isGoStdlib,
+  parseGoModule,
+} from "./import-parsers.js";
+
+const JS_EXTENSIONS = new Set([".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"]);
+const PY_EXTENSIONS = new Set([".py", ".pyw"]);
+const GO_EXTENSIONS = new Set([".go"]);
 
 async function readFileSafe(filePath) {
   try {
@@ -27,6 +29,10 @@ async function readFileSafe(filePath) {
   }
 }
 
+function isGoTestFile(file) {
+  return String(file).replace(/\\/g, "/").endsWith("_test.go");
+}
+
 function isRelativeImport(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
@@ -58,63 +64,140 @@ function normalizeFileKey(file) {
   return key;
 }
 
-export async function analyzeDependencyGraph(files, repoRoot) {
-  const result = {
-    nodes: [],       // { key, file, imports: string[], importedBy: string[] }
-    edges: [],       // { from, to }
-    cycles: [],      // [ [a, b, c, a], ... ]
-    externalDeps: [],// sorted unique bare-specifier imports
+function emptyResult() {
+  return {
+    nodes: [],
+    edges: [],
+    cycles: [],
+    externalDeps: [],
     stats: null,
     summary: null,
   };
+}
+
+async function loadGoModule(repoRoot) {
+  const text = await readFileSafe(path.join(repoRoot, "go.mod"));
+  return parseGoModule(text);
+}
+
+function goPackageImportPath(file, modulePath) {
+  const norm = String(file || "").replace(/\\/g, "/");
+  if (!norm.endsWith(".go")) return null;
+  const dir = path.posix.dirname(norm);
+  const rel = dir === "." ? "" : dir;
+  if (modulePath) return rel ? `${modulePath}/${rel}` : modulePath;
+  return rel || ".";
+}
+
+function aggregateHubs(nodes, fileKeyToFile, modulePath, hubThreshold) {
+  const groups = new Map();
+  for (const node of nodes) {
+    const pkg = goPackageImportPath(node.file, modulePath);
+    const key = pkg || node.key;
+    if (!groups.has(key)) groups.set(key, new Set());
+    const importers = groups.get(key);
+    for (const importer of node.importedBy || []) {
+      const importerFile = fileKeyToFile.get(importer) || importer;
+      if (pkg && goPackageImportPath(importerFile, modulePath) === pkg) continue;
+      importers.add(importer);
+    }
+  }
+  return [...groups.entries()]
+    .map(([key, importers]) => ({ key, importedBy: importers.size }))
+    .filter((hub) => hub.importedBy >= hubThreshold)
+    .sort((a, b) => b.importedBy - a.importedBy)
+    .slice(0, 10);
+}
 
-  const codeFiles = files.filter(f => {
-    const ext = path.extname(f);
-    return CODE_EXTENSIONS.has(ext);
+function goFilesInDir(goFiles, dir) {
+  const target = dir || "";
+  return goFiles.filter((file) => {
+    const fileDir = path.posix.dirname(file.replace(/\\/g, "/"));
+    const normalized = fileDir === "." ? "" : fileDir;
+    return normalized === target;
   });
+}
+
+export async function analyzeDependencyGraph(files, repoRoot) {
+  const result = emptyResult();
+
+  const jsFiles = files.filter((file) => JS_EXTENSIONS.has(path.extname(file)));
+  const pyFiles = files.filter((file) => PY_EXTENSIONS.has(path.extname(file)));
+  const goFiles = files.filter((file) => GO_EXTENSIONS.has(path.extname(file)) && !isGoTestFile(file));
+  const codeFiles = [...jsFiles, ...pyFiles, ...goFiles];
 
   if (codeFiles.length === 0) return result;
 
-  // Build adjacency: fileKey → Set<fileKey>
   const adjacency = new Map();
   const fileKeyToFile = new Map();
   const allFileKeys = new Set();
   const externalSet = new Set();
+  const externalByKey = new Map();
 
-  // Register all known file keys
-  for (const file of codeFiles) {
+  function register(file) {
     const key = normalizeFileKey(file);
     allFileKeys.add(key);
-    fileKeyToFile.set(key, file);
+    if (!fileKeyToFile.has(key)) fileKeyToFile.set(key, file);
     if (!adjacency.has(key)) adjacency.set(key, new Set());
+    if (!externalByKey.has(key)) externalByKey.set(key, new Set());
+    return key;
   }
 
-  // Parse imports and build edges
-  for (const file of codeFiles) {
+  function addExternal(fromKey, name) {
+    if (!name) return;
+    externalSet.add(name);
+    externalByKey.get(fromKey).add(name);
+  }
+
+  function addEdge(fromKey, toKey) {
+    if (!toKey || toKey === fromKey || !allFileKeys.has(toKey)) return;
+    adjacency.get(fromKey).add(toKey);
+  }
+
+  for (const file of codeFiles) register(file);
+
+  const pyIndex = indexPythonModules(pyFiles);
+  const goModulePath = goFiles.length > 0 ? await loadGoModule(repoRoot) : null;
+
+  for (const file of jsFiles) {
     const content = await readFileSafe(path.join(repoRoot, file));
     if (!content) continue;
+    const fromKey = normalizeFileKey(file);
+    for (const imported of extractJsImports(content)) {
+      if (imported.typeOnly) continue;
+      if (isRelativeImport(imported.specifier)) {
+        addEdge(fromKey, resolveImportPath(file, imported.specifier));
+      } else {
+        addExternal(fromKey, externalPackageName(imported.specifier));
+      }
+    }
+  }
 
+  for (const file of pyFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
     const fromKey = normalizeFileKey(file);
+    for (const imported of extractPythonImports(content)) {
+      if (imported.typeOnly) continue;
+      const resolved = resolvePythonImport(file, imported, pyIndex);
+      if (resolved.kind === "internal") addEdge(fromKey, normalizeFileKey(resolved.file));
+      else if (resolved.kind === "external") addExternal(fromKey, resolved.name);
+    }
+  }
 
-    for (const pattern of IMPORT_PATTERNS) {
-      // Reset lastIndex since we reuse regex objects
-      const regex = new RegExp(pattern.source, pattern.flags);
-      let match;
-      while ((match = regex.exec(content)) !== null) {
-        const specifier = match[1];
-
-        if (isRelativeImport(specifier)) {
-          const resolved = resolveImportPath(file, specifier);
-          if (resolved && allFileKeys.has(resolved)) {
-            adjacency.get(fromKey).add(resolved);
-          }
-        } else if (!specifier.startsWith("node:")) {
-          // Bare specifier → external dependency
-          // Normalize scoped packages: @scope/pkg/path → @scope/pkg
-          const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2) : specifier.split("/").slice(0, 1);
-          externalSet.add(parts.join("/"));
+  for (const file of goFiles) {
+    const content = await readFileSafe(path.join(repoRoot, file));
+    if (!content) continue;
+    const fromKey = normalizeFileKey(file);
+    for (const importPath of extractGoImports(content)) {
+      const dir = goPackageDir(importPath, goModulePath, "");
+      if (dir !== null) {
+        for (const target of goFilesInDir(goFiles, dir)) {
+          addEdge(fromKey, normalizeFileKey(target));
         }
+        continue;
       }
+      if (!isGoStdlib(importPath)) addExternal(fromKey, importPath);
     }
   }
 
@@ -139,6 +222,7 @@ export async function analyzeDependencyGraph(files, repoRoot) {
       file: fileKeyToFile.get(key) || key,
       imports: [...(adjacency.get(key) || [])],
       importedBy: importedByMap.get(key) || [],
+      externalImports: [...(externalByKey.get(key) || [])].sort(),
     });
   }
 
@@ -151,11 +235,7 @@ export async function analyzeDependencyGraph(files, repoRoot) {
   const totalImports = result.edges.length;
   const orphans = result.nodes.filter(n => n.imports.length === 0 && n.importedBy.length === 0);
   const hubThreshold = Math.max(5, Math.floor(result.nodes.length * 0.1));
-  const hubs = result.nodes
-    .filter(n => n.importedBy.length >= hubThreshold)
-    .sort((a, b) => b.importedBy.length - a.importedBy.length)
-    .slice(0, 10)
-    .map(n => ({ key: n.key, importedBy: n.importedBy.length }));
+  const hubs = aggregateHubs(result.nodes, fileKeyToFile, goModulePath, hubThreshold);
 
   result.stats = {
     totalFiles: codeFiles.length,

package/src/analyzers/domain-inference.js

@@ -133,16 +133,54 @@ const DEFAULT_DOMAIN_HINTS = [
   }
 ];
 
-export function inferDomain(modulePath, customHints = []) {
+const REACT_HOOK_KEYWORDS = new Set(["hook", "hooks", "use"]);
+
+export function pathTokens(modulePath) {
+  return String(modulePath).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+
+/** Match a path token, not a substring (`ai` does not match `_main` or `email`). */
+export function pathHasKeyword(modulePath, keyword) {
+  const needle = String(keyword).toLowerCase();
+  if (!needle) return false;
+  return pathTokens(modulePath).some((token) => {
+    if (token === needle || token === `${needle}s`) return true;
+    if (needle.length >= 5 && token.startsWith(needle)) return true;
+    return false;
+  });
+}
+
+export function moduleEvidence(moduleKey, depGraph) {
+  const key = String(moduleKey).replace(/\\/g, "/");
+  const nodes = (depGraph?.nodes || []).filter((node) => {
+    const file = String(node.file || node.key || "").replace(/\\/g, "/");
+    return file === key || file.startsWith(`${key}/`) || node.key === key;
+  });
+  const imports = new Set(nodes.flatMap((node) => node.externalImports || []));
+  const react = [...imports].some((name) => name === "react" || name === "react-dom" || name.startsWith("react/"));
+  const ai = [...imports].some((name) => /(^|\/)(openai|anthropic|langchain|ollama)(\/|$)/i.test(name) || name.startsWith("@anthropic-ai/") || name.startsWith("@ai-sdk/"));
+  return { react, ai };
+}
+
+function domainEvidenceText(hint, modulePath, keyword, evidence) {
+  const isDefault = DEFAULT_DOMAIN_HINTS.includes(hint);
+  if (!isDefault && hint.description) return hint.description;
+  const bits = [`path \`${modulePath}\` matches \`${keyword}\``];
+  if (REACT_HOOK_KEYWORDS.has(keyword) && evidence.react) bits.push("imports react");
+  if (hint.domain === "AI & Machine Learning" && evidence.ai) bits.push("imports an AI SDK");
+  return bits.join("; ");
+}
+
+export function inferDomain(modulePath, customHints = [], evidence = {}) {
   const hints = [...customHints, ...DEFAULT_DOMAIN_HINTS];
-  const lowerPath = modulePath.toLowerCase();
-  
+
   for (const hint of hints) {
     for (const keyword of hint.match) {
-      if (lowerPath.includes(keyword)) {
+      if (REACT_HOOK_KEYWORDS.has(keyword) && !evidence.react) continue;
+      if (pathHasKeyword(modulePath, keyword)) {
         return {
           domain: hint.domain,
-          description: hint.description,
+          description: domainEvidenceText(hint, modulePath, keyword, evidence),
           confidence: "pattern_match",
           matchedKeyword: keyword
         };
@@ -158,11 +196,11 @@ export function inferDomain(modulePath, customHints = []) {
   };
 }
 
-export function groupModulesByDomain(modules, customHints = []) {
+export function groupModulesByDomain(modules, customHints = [], depGraph = null) {
   const domainGroups = {};
   
   for (const module of modules) {
-    const inference = inferDomain(module.key, customHints);
+    const inference = inferDomain(module.key, customHints, moduleEvidence(module.key, depGraph));
     const domainName = inference.domain;
     
     if (!domainGroups[domainName]) {