@dreamtree-org/graphify 1.1.1 → 1.1.3

package/dist/index.cjs

@@ -1603,10 +1603,10 @@ async function extractRust(filePath, displayPath) {
         }
       }
     } else if (fn.type === "scoped_identifier") {
-      const path11 = fn.childForFieldName("path")?.text;
+      const path12 = fn.childForFieldName("path")?.text;
       const name = fn.childForFieldName("name")?.text;
-      if (path11 && name) {
-        const viaImport = importIndex.get(path11);
+      if (path12 && name) {
+        const viaImport = importIndex.get(path12);
         if (viaImport) {
           targetId = viaImport.id;
           confidence = "INFERRED";
@@ -1677,13 +1677,11 @@ async function extractTypeScript(filePath, displayPath) {
     });
   }
   function importTargetId(binding, property) {
-    if (!binding.ref.external) {
-      if (binding.kind === "named" && binding.importedName) {
-        return entityId(binding.ref.id, binding.importedName);
-      }
-      if (binding.kind === "namespace" && property) {
-        return entityId(binding.ref.id, property);
-      }
+    if (binding.kind === "named" && binding.importedName) {
+      return entityId(binding.ref.id, binding.importedName);
+    }
+    if (binding.kind === "namespace" && property) {
+      return entityId(binding.ref.id, property);
     }
     return binding.ref.id;
   }
@@ -1721,24 +1719,35 @@ async function extractTypeScript(filePath, displayPath) {
       }
     }
   }
+  function unwrapExpression(node) {
+    let current = node;
+    while (current.type === "as_expression" || current.type === "satisfies_expression" || current.type === "non_null_expression" || current.type === "parenthesized_expression") {
+      const inner = namedChildren(current)[0];
+      if (!inner) break;
+      current = inner;
+    }
+    return current;
+  }
   function handleTopLevelVariableFunctions(node) {
+    const isExported = node.parent?.type === "export_statement";
     for (const declarator of namedChildren(node)) {
       if (declarator.type !== "variable_declarator") continue;
       const value = declarator.childForFieldName("value");
       if (!value) continue;
-      if (value.type === "arrow_function" || value.type === "function_expression") {
+      const core = unwrapExpression(value);
+      if (core.type === "arrow_function" || core.type === "function_expression") {
         const name = declarator.childForFieldName("name")?.text;
         if (!name) continue;
         const id = entityId(sourceFile, name);
         builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(declarator) });
         builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
         nameIndex.set(name, id);
-        functionNodeMap.set(value.id, id);
+        functionNodeMap.set(core.id, id);
         continue;
       }
-      if (value.type === "call_expression") {
-        const callee = value.childForFieldName("function");
-        const specifier = callee?.type === "identifier" && callee.text === "require" ? firstStringArgument(value) : null;
+      if (core.type === "call_expression") {
+        const callee = core.childForFieldName("function");
+        const specifier = callee?.type === "identifier" && callee.text === "require" ? firstStringArgument(core) : null;
         if (specifier) {
           const nameNode = declarator.childForFieldName("name");
           if (nameNode) {
@@ -1746,6 +1755,21 @@ async function extractTypeScript(filePath, displayPath) {
             addModuleNode(ref);
             registerRequireBinding(nameNode, ref);
           }
+          continue;
+        }
+      }
+      if (isExported) {
+        const name = declarator.childForFieldName("name")?.text;
+        if (!name) continue;
+        const id = entityId(sourceFile, name);
+        builder.addNode({ id, label: `const ${name}`, sourceFile, sourceLocation: lineOf(declarator) });
+        builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+        nameIndex.set(name, id);
+        if (core.type === "identifier") {
+          const aliased = nameIndex.get(core.text);
+          if (aliased !== void 0 && aliased !== id) {
+            builder.addEdge({ source: id, target: aliased, relation: "references", confidence: "EXTRACTED" });
+          }
         }
       }
     }
@@ -2087,6 +2111,8 @@ function buildGraph(extractions) {
 }
 
 // src/resolve.ts
+var fs9 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
 var CODE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -2106,6 +2132,29 @@ var CODE_EXTENSIONS2 = [
 function isOpaque(id) {
   return id.startsWith("module:") || id.startsWith("external:") || id.startsWith("db:");
 }
+var SELF_IMPORT_STEMS = (subpath) => subpath === "" ? ["index", "src/index", "lib/index", "source/index", "src/main"] : [
+  subpath,
+  `src/${subpath}`,
+  `lib/${subpath}`,
+  `source/${subpath}`,
+  `${subpath}/index`,
+  `src/${subpath}/index`,
+  `lib/${subpath}/index`
+];
+function selfImportCandidates(spec, selfNames) {
+  const selfName = selfNames.find((n) => spec === n || spec.startsWith(`${n}/`));
+  if (selfName === void 0) return null;
+  const subpath = spec === selfName ? "" : spec.slice(selfName.length + 1);
+  return SELF_IMPORT_STEMS(subpath).flatMap((stem) => CODE_EXTENSIONS2.map((ext) => `${stem}${ext}`));
+}
+async function readSelfNames(root) {
+  try {
+    const pkg = JSON.parse(await fs9.readFile(path5.join(root, "package.json"), "utf-8"));
+    return typeof pkg.name === "string" && pkg.name.length > 0 ? [pkg.name] : [];
+  } catch {
+    return [];
+  }
+}
 function stripKnownExtension(p) {
   for (const ext of CODE_EXTENSIONS2) {
     if (p.endsWith(ext)) return p.slice(0, -ext.length);
@@ -2122,19 +2171,23 @@ function candidatePaths(guessed) {
   }
   return candidates.filter((c) => c !== guessed);
 }
-function uniqueMatch(guessed, candidates, realIds) {
+function uniqueMatch(candidates, real) {
   const matches = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
-    if (realIds.has(candidate)) matches.add(candidate);
+    if (real.has(candidate)) matches.add(candidate);
   }
-  if (matches.size !== 1) return null;
-  return [...matches][0];
+  return matches.size === 1 ? [...matches][0] : null;
 }
-function resolveCrossFileReferences(extractions) {
+function resolveCrossFileReferences(extractions, options = {}) {
+  const selfNames = options.selfNames ?? [];
   const realIds = /* @__PURE__ */ new Set();
   const realFiles = /* @__PURE__ */ new Set();
   for (const extraction of extractions) {
     for (const node of extraction.nodes) realIds.add(node.id);
+    const first = extraction.nodes[0];
+    if (first && first.id === first.sourceFile && !isOpaque(first.id)) {
+      realFiles.add(first.id);
+    }
     for (const node of extraction.nodes) {
       const sep3 = node.id.indexOf("::");
       if (sep3 > 0) realFiles.add(node.id.slice(0, sep3));
@@ -2144,7 +2197,24 @@ function resolveCrossFileReferences(extractions) {
     }
   }
   const remap = /* @__PURE__ */ new Map();
-  const resolveId = (id) => {
+  let resolvedEndpoints = 0;
+  const applyRemap = (resolveId) => {
+    for (const extraction of extractions) {
+      for (const edge of extraction.edges) {
+        const source = resolveId(edge.source);
+        if (source !== null) {
+          edge.source = source;
+          resolvedEndpoints++;
+        }
+        const target = resolveId(edge.target);
+        if (target !== null) {
+          edge.target = target;
+          resolvedEndpoints++;
+        }
+      }
+    }
+  };
+  const resolvePathId = (id) => {
     if (isOpaque(id)) return null;
     const cached = remap.get(id);
     if (cached !== void 0) return cached;
@@ -2154,30 +2224,77 @@ function resolveCrossFileReferences(extractions) {
       if (realIds.has(id)) return null;
       const guessedPath = id.slice(0, sep3);
       const name = id.slice(sep3);
-      const candidates = candidatePaths(guessedPath).map((p) => `${p}${name}`);
-      resolved = uniqueMatch(id, candidates, realIds);
+      resolved = uniqueMatch(candidatePaths(guessedPath).map((p) => `${p}${name}`), realIds);
     } else {
       if (realFiles.has(id)) return null;
-      resolved = uniqueMatch(id, candidatePaths(id), realFiles);
+      resolved = uniqueMatch(candidatePaths(id), realFiles);
     }
     if (resolved !== null) remap.set(id, resolved);
     return resolved;
   };
-  let resolvedEndpoints = 0;
+  applyRemap(resolvePathId);
+  const namedAlias = /* @__PURE__ */ new Map();
+  const starTargets = /* @__PURE__ */ new Map();
   for (const extraction of extractions) {
     for (const edge of extraction.edges) {
-      const source = resolveId(edge.source);
-      if (source !== null) {
-        edge.source = source;
-        resolvedEndpoints++;
-      }
-      const target = resolveId(edge.target);
-      if (target !== null) {
-        edge.target = target;
-        resolvedEndpoints++;
+      if (edge.relation !== "re_exports" || !realFiles.has(edge.source)) continue;
+      const sep3 = edge.target.lastIndexOf("::");
+      if (sep3 > 0 && realIds.has(edge.target)) {
+        namedAlias.set(`${edge.source}|${edge.target.slice(sep3 + 2)}`, edge.target);
+      } else if (sep3 < 0 && realFiles.has(edge.target)) {
+        const targets = starTargets.get(edge.source) ?? [];
+        targets.push(edge.target);
+        starTargets.set(edge.source, targets);
+      }
+    }
+  }
+  const throughBarrel = (file, name) => {
+    const direct = `${file}::${name}`;
+    if (realIds.has(direct)) return direct;
+    const aliased = namedAlias.get(`${file}|${name}`);
+    if (aliased !== void 0) return aliased;
+    const viaStar = (starTargets.get(file) ?? []).map((sf) => `${sf}::${name}`).filter((id) => realIds.has(id));
+    return viaStar.length === 1 ? viaStar[0] : null;
+  };
+  const resolveBarrelId = (id) => {
+    const cached = remap.get(id);
+    if (cached !== void 0) return cached;
+    if (id.startsWith("module:")) {
+      const spec = id.slice("module:".length);
+      const sep4 = spec.indexOf("::");
+      const moduleSpec = sep4 > 0 ? spec.slice(0, sep4) : spec;
+      const name = sep4 > 0 ? spec.slice(sep4 + 2) : null;
+      const candidates = selfImportCandidates(moduleSpec, selfNames);
+      if (candidates === null) {
+        if (name === null) return null;
+        remap.set(id, `module:${moduleSpec}`);
+        return `module:${moduleSpec}`;
+      }
+      const file = uniqueMatch(candidates, realFiles);
+      let resolved = null;
+      if (file !== null) {
+        resolved = name !== null ? throughBarrel(file, name) ?? file : file;
+      } else if (name !== null) {
+        resolved = `module:${moduleSpec}`;
+      }
+      if (resolved !== null) remap.set(id, resolved);
+      return resolved;
+    }
+    const sep3 = id.indexOf("::");
+    if (sep3 > 0 && !realIds.has(id)) {
+      const guessedPath = id.slice(0, sep3);
+      const name = id.slice(sep3 + 2);
+      const files = [guessedPath, ...candidatePaths(guessedPath)].filter((f) => realFiles.has(f));
+      const resolvedSet = new Set(files.map((f) => throughBarrel(f, name)).filter((r) => r !== null));
+      if (resolvedSet.size === 1) {
+        const resolved = [...resolvedSet][0];
+        remap.set(id, resolved);
+        return resolved;
       }
     }
-  }
+    return null;
+  };
+  applyRemap(resolveBarrelId);
   let droppedPlaceholders = 0;
   for (const extraction of extractions) {
     const before = extraction.nodes.length;
@@ -2453,15 +2570,15 @@ function renderReport(graph, analysis, now = /* @__PURE__ */ new Date()) {
 
 // src/export.ts
 var import_node_module2 = require("module");
-var fs10 = __toESM(require("fs/promises"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs/promises"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/security.ts
 var import_node_crypto2 = require("crypto");
 var dns = __toESM(require("dns"), 1);
 var http = __toESM(require("http"), 1);
 var https = __toESM(require("https"), 1);
-var fs9 = __toESM(require("fs"), 1);
+var fs10 = __toESM(require("fs"), 1);
 var net = __toESM(require("net"), 1);
 var nodePath = __toESM(require("path"), 1);
 var MAX_FETCH_BYTES = 50 * 1024 * 1024;
@@ -2497,25 +2614,25 @@ function validateDsn(dsn) {
     }
   };
 }
-function validateGraphPath(path11, base) {
+function validateGraphPath(path12, base) {
   const baseDir = base ?? nodePath.join(process.cwd(), "graphify-out");
   let resolvedBase;
   try {
-    resolvedBase = fs9.realpathSync(baseDir);
+    resolvedBase = fs10.realpathSync(baseDir);
   } catch {
     throw new Error(`Base directory does not exist: ${baseDir}`);
   }
-  const candidate = nodePath.isAbsolute(path11) ? path11 : nodePath.join(resolvedBase, path11);
+  const candidate = nodePath.isAbsolute(path12) ? path12 : nodePath.join(resolvedBase, path12);
   const resolvedCandidate = nodePath.resolve(candidate);
   let realCandidate = resolvedCandidate;
   try {
-    realCandidate = fs9.realpathSync(resolvedCandidate);
+    realCandidate = fs10.realpathSync(resolvedCandidate);
   } catch {
   }
   const relative4 = nodePath.relative(resolvedBase, realCandidate);
   const escapes = relative4 === ".." || relative4.startsWith(`..${nodePath.sep}`) || nodePath.isAbsolute(relative4);
   if (escapes) {
-    throw new Error(`Path escapes graphify-out/: ${path11}`);
+    throw new Error(`Path escapes graphify-out/: ${path12}`);
   }
   return realCandidate;
 }
@@ -2532,10 +2649,10 @@ function escapeHtml(text) {
 var require3 = (0, import_node_module2.createRequire)(importMetaUrl);
 function resolveVisNetworkAssets() {
   const packageJsonPath = require3.resolve("vis-network/package.json");
-  const root = path5.dirname(packageJsonPath);
+  const root = path6.dirname(packageJsonPath);
   return {
-    jsPath: path5.join(root, "standalone", "umd", "vis-network.min.js"),
-    cssPath: path5.join(root, "styles", "vis-network.min.css")
+    jsPath: path6.join(root, "standalone", "umd", "vis-network.min.js"),
+    cssPath: path6.join(root, "styles", "vis-network.min.css")
   };
 }
 var COMMUNITY_PALETTE = [
@@ -2594,8 +2711,8 @@ community: ${communityLabel}` : ""}`,
 async function renderHtml(graph) {
   const { jsPath, cssPath } = resolveVisNetworkAssets();
   const [visJs, visCss] = await Promise.all([
-    fs10.readFile(jsPath, "utf-8"),
-    fs10.readFile(cssPath, "utf-8")
+    fs11.readFile(jsPath, "utf-8"),
+    fs11.readFile(cssPath, "utf-8")
   ]);
   const { nodes, edges } = buildVisNodesAndEdges(graph);
   const dataJson = safeInlineJson({ nodes, edges });
@@ -2635,17 +2752,17 @@ ${visJs}
 `;
 }
 async function exportGraph(graph, options, report) {
-  const outDir = path5.resolve(options.outDir);
-  await fs10.mkdir(outDir, { recursive: true });
+  const outDir = path6.resolve(options.outDir);
+  await fs11.mkdir(outDir, { recursive: true });
   const jsonPath = validateGraphPath("graph.json", outDir);
-  await fs10.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
+  await fs11.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
   if (options.html !== false) {
     const htmlPath = validateGraphPath("graph.html", outDir);
-    await fs10.writeFile(htmlPath, await renderHtml(graph), "utf-8");
+    await fs11.writeFile(htmlPath, await renderHtml(graph), "utf-8");
   }
   if (report !== void 0) {
     const reportPath = validateGraphPath("GRAPH_REPORT.md", outDir);
-    await fs10.writeFile(reportPath, report, "utf-8");
+    await fs11.writeFile(reportPath, report, "utf-8");
   }
   const notImplemented = [];
   if (options.svg) notImplemented.push("--svg");
@@ -2658,24 +2775,24 @@ async function exportGraph(graph, options, report) {
 }
 
 // src/pipeline.ts
-var fs12 = __toESM(require("fs/promises"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs13 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
 
 // src/extractionCache.ts
 var import_node_crypto3 = require("crypto");
-var fs11 = __toESM(require("fs/promises"), 1);
-var path6 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs/promises"), 1);
+var path7 = __toESM(require("path"), 1);
 var ExtractionCache = class {
   dir;
   constructor(outDir) {
-    this.dir = path6.join(outDir, "cache");
+    this.dir = path7.join(outDir, "cache");
   }
   key(relFile, content) {
     return (0, import_node_crypto3.createHash)("sha256").update(relFile).update("\0").update(content).digest("hex");
   }
   async get(key) {
     try {
-      const raw = await fs11.readFile(path6.join(this.dir, `${key}.json`), "utf-8");
+      const raw = await fs12.readFile(path7.join(this.dir, `${key}.json`), "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed.nodes) || !Array.isArray(parsed.edges)) return null;
       return parsed;
@@ -2684,8 +2801,8 @@ var ExtractionCache = class {
     }
   }
   async put(key, extraction) {
-    await fs11.mkdir(this.dir, { recursive: true });
-    await fs11.writeFile(path6.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
+    await fs12.mkdir(this.dir, { recursive: true });
+    await fs12.writeFile(path7.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
   }
 };
 
@@ -2693,21 +2810,21 @@ var ExtractionCache = class {
 async function runPipeline(root, options = {}) {
   const progress = options.onProgress ?? (() => {
   });
-  const resolvedRoot = path7.resolve(root);
+  const resolvedRoot = path8.resolve(root);
   progress(`Scanning ${resolvedRoot} ...`);
   const manifest = collectFiles(resolvedRoot);
   progress(
     `Found ${manifest.totalFiles} file(s) (${manifest.files.code.length} code, ${manifest.skippedSensitive.length} skipped as sensitive).`
   );
-  const outDir = options.outDir ?? path7.join(resolvedRoot, "graphify-out");
+  const outDir = options.outDir ?? path8.join(resolvedRoot, "graphify-out");
   const cache = new ExtractionCache(outDir);
   progress("Extracting...");
   const extractions = [];
   let cacheHits = 0;
   for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
-    const filePath = path7.relative(process.cwd(), path7.join(resolvedRoot, relFile)) || relFile;
+    const filePath = path8.relative(process.cwd(), path8.join(resolvedRoot, relFile)) || relFile;
     try {
-      const key = cache.key(relFile, await fs12.readFile(path7.join(resolvedRoot, relFile)));
+      const key = cache.key(relFile, await fs13.readFile(path8.join(resolvedRoot, relFile)));
       let extraction = options.update ? await cache.get(key) : null;
       if (extraction) {
         cacheHits++;
@@ -2728,7 +2845,9 @@ async function runPipeline(root, options = {}) {
     extractions.push(...options.extraExtractions);
   }
   progress("Resolving cross-file references...");
-  const resolveStats = resolveCrossFileReferences(extractions);
+  const resolveStats = resolveCrossFileReferences(extractions, {
+    selfNames: await readSelfNames(resolvedRoot)
+  });
   if (resolveStats.resolvedEndpoints > 0) {
     progress(
       `  re-pointed ${resolveStats.resolvedEndpoints} guessed reference(s) at real nodes (${resolveStats.droppedPlaceholders} placeholder node(s) dropped).`
@@ -2760,12 +2879,12 @@ async function runPipeline(root, options = {}) {
 }
 
 // src/graphStore.ts
-var fs13 = __toESM(require("fs/promises"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs14 = __toESM(require("fs/promises"), 1);
+var path9 = __toESM(require("path"), 1);
 var import_graphology3 = __toESM(require("graphology"), 1);
-async function loadGraph(outDir = path8.join(process.cwd(), "graphify-out")) {
+async function loadGraph(outDir = path9.join(process.cwd(), "graphify-out")) {
   const jsonPath = validateGraphPath("graph.json", outDir);
-  const raw = await fs13.readFile(jsonPath, "utf-8");
+  const raw = await fs14.readFile(jsonPath, "utf-8");
   const data = JSON.parse(raw);
   return import_graphology3.default.from(data);
 }
@@ -2873,7 +2992,10 @@ function scoreNodes(graph, query) {
     }
     if (score > 0) matches.push({ id, label, score });
   });
-  matches.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  const placeholderRank = (id) => id.startsWith("module:") || id.startsWith("external:") ? 1 : 0;
+  matches.sort(
+    (a, b) => b.score - a.score || placeholderRank(a.id) - placeholderRank(b.id) || a.id.localeCompare(b.id)
+  );
   return matches;
 }
 function resolveNode(graph, query) {
@@ -2989,25 +3111,25 @@ function shortestPath(graph, fromQuery, toQuery) {
   if (!visited.has(to.id)) {
     return { from, to, found: false, path: [], edges: [] };
   }
-  const path11 = [to.id];
+  const path12 = [to.id];
   let cursor = to.id;
   while (cursor !== from.id) {
     const prev = predecessor.get(cursor);
     if (!prev) break;
-    path11.unshift(prev);
+    path12.unshift(prev);
     cursor = prev;
   }
   const edges = [];
-  for (let i = 0; i < path11.length - 1; i++) {
-    const a = path11[i];
-    const b = path11[i + 1];
+  for (let i = 0; i < path12.length - 1; i++) {
+    const a = path12[i];
+    const b = path12[i + 1];
     const key = graph.edges(a, b)[0] ?? graph.edges(b, a)[0];
     if (key) {
       const attrs = graph.getEdgeAttributes(key);
       edges.push({ source: a, target: b, relation: String(attrs.relation), confidence: String(attrs.confidence) });
     }
   }
-  return { from, to, found: true, path: path11, edges };
+  return { from, to, found: true, path: path12, edges };
 }
 function explainNode(graph, query) {
   const match = resolveNode(graph, query);
@@ -3056,6 +3178,7 @@ function affectedBy(graph, nodeQuery, options = {}) {
   if (!target) return null;
   const maxDepth = options.maxDepth ?? DEFAULT_IMPACT_DEPTH;
   const limit = options.limit ?? DEFAULT_IMPACT_LIMIT;
+  const followed = options.relations ? new Set(options.relations) : DEPENDENCY_RELATIONS;
   const affected = [];
   const visited = /* @__PURE__ */ new Set([target.id]);
   let frontier = [target.id];
@@ -3066,7 +3189,7 @@ function affectedBy(graph, nodeQuery, options = {}) {
       graph.forEachInEdge(current, (_edge, edgeAttrs, source) => {
         if (visited.has(source)) return;
         const relation = edgeAttrs.relation;
-        if (!DEPENDENCY_RELATIONS.has(relation)) return;
+        if (!followed.has(relation)) return;
         const confidence = edgeAttrs.confidence;
         const existing = nextFrontier.get(source);
         if (existing && CONFIDENCE_RANK2[existing.via.confidence] >= CONFIDENCE_RANK2[confidence]) return;
@@ -3302,8 +3425,8 @@ async function addViewEdges(query, schema, viewNames, tableNames, edges) {
 
 // src/memory.ts
 var import_node_crypto4 = require("crypto");
-var fs14 = __toESM(require("fs/promises"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs/promises"), 1);
+var path10 = __toESM(require("path"), 1);
 var OUTCOMES = /* @__PURE__ */ new Set(["useful", "dead_end", "corrected"]);
 var TYPES = /* @__PURE__ */ new Set(["query", "path", "explain", "affected"]);
 function validateResult(value) {
@@ -3321,25 +3444,25 @@ function validateResult(value) {
 }
 async function saveResult(entry, memoryDir, now = /* @__PURE__ */ new Date()) {
   validateResult(entry);
-  await fs14.mkdir(memoryDir, { recursive: true });
+  await fs15.mkdir(memoryDir, { recursive: true });
   const saved = { ...entry, savedAt: now.toISOString() };
   const hash = (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(saved)).digest("hex").slice(0, 8);
   const stamp = saved.savedAt.replace(/[:.]/g, "-");
-  const filePath = path9.join(memoryDir, `result-${stamp}-${hash}.json`);
-  await fs14.writeFile(filePath, JSON.stringify(saved, null, 2), "utf-8");
+  const filePath = path10.join(memoryDir, `result-${stamp}-${hash}.json`);
+  await fs15.writeFile(filePath, JSON.stringify(saved, null, 2), "utf-8");
   return filePath;
 }
 async function loadResults(memoryDir) {
   let files;
   try {
-    files = (await fs14.readdir(memoryDir)).filter((f) => f.startsWith("result-") && f.endsWith(".json"));
+    files = (await fs15.readdir(memoryDir)).filter((f) => f.startsWith("result-") && f.endsWith(".json"));
   } catch {
     return [];
   }
   const results = [];
   for (const file of files.sort((a, b) => a.localeCompare(b))) {
     try {
-      const parsed = JSON.parse(await fs14.readFile(path9.join(memoryDir, file), "utf-8"));
+      const parsed = JSON.parse(await fs15.readFile(path10.join(memoryDir, file), "utf-8"));
       if (parsed.question && parsed.savedAt) results.push(parsed);
     } catch {
     }
@@ -3452,7 +3575,7 @@ function snippetRange(startLine, fileLineCount, entityStartsInFile, maxLines) {
   const hardEnd = nextStart !== void 0 ? nextStart - 1 : fileLineCount;
   return { start: startLine, end: Math.min(hardEnd, startLine + maxLines - 1) };
 }
-async function buildContextPack(graph, task, readFile13, options = {}) {
+async function buildContextPack(graph, task, readFile14, options = {}) {
   const tokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_BUDGET;
   const maxSnippetLines = options.maxSnippetLines ?? DEFAULT_MAX_SNIPPET_LINES;
   const ranked = rankForTask(graph, task, options.maxSeeds);
@@ -3473,7 +3596,7 @@ async function buildContextPack(graph, task, readFile13, options = {}) {
     if (cached !== void 0) return cached;
     let lines;
     try {
-      lines = (await readFile13(file)).split("\n");
+      lines = (await readFile14(file)).split("\n");
     } catch {
       lines = null;
     }
@@ -3561,16 +3684,17 @@ var TEST_FILE_PATTERNS = [
   /_spec\.rb$/,
   /_test\.rb$/
 ];
-function isTestFile(path11) {
-  return TEST_FILE_PATTERNS.some((p) => p.test(path11));
+function isTestFile(path12) {
+  return TEST_FILE_PATTERNS.some((p) => p.test(path12));
 }
 var TEST_REACH_DEPTH = 4;
 var TEST_REACH_LIMIT = 2e3;
-function selectionFromImpact(graph, targetIds, targetLabel) {
+var USAGE_RELATIONS = ["calls", "inherits", "implements", "mixes_in", "embeds", "references"];
+function selectionFromImpact(graph, targetIds, targetLabel, relations) {
   const best = /* @__PURE__ */ new Map();
   let affectedNodeCount = 0;
   for (const id of targetIds) {
-    const impact = affectedBy(graph, id, { maxDepth: TEST_REACH_DEPTH, limit: TEST_REACH_LIMIT });
+    const impact = affectedBy(graph, id, { maxDepth: TEST_REACH_DEPTH, limit: TEST_REACH_LIMIT, relations });
     if (!impact) continue;
     affectedNodeCount += impact.affected.length;
     for (const node of impact.affected) {
@@ -3582,11 +3706,27 @@ function selectionFromImpact(graph, targetIds, targetLabel) {
     }
   }
   const testFiles = [...best.entries()].map(([file, info]) => ({ file, depth: info.depth, via: info.via })).sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
-  return { target: targetLabel, testFiles, affectedNodeCount };
+  return {
+    target: targetLabel,
+    testFiles,
+    affectedNodeCount,
+    precision: relations ? "usage" : "import-reachability"
+  };
+}
+function entityRootsOf(graph, id) {
+  if (id.includes("::")) return [id];
+  const roots = [];
+  graph.forEachOutEdge(id, (_edge, attrs, _source, target) => {
+    if (String(attrs.relation) === "contains") roots.push(target);
+  });
+  roots.sort((a, b) => a.localeCompare(b));
+  return roots.length > 0 ? roots : [id];
 }
 function testsForNode(graph, nodeQuery) {
   const match = resolveNode(graph, nodeQuery);
   if (!match) return null;
+  const precise = selectionFromImpact(graph, entityRootsOf(graph, match.id), match.id, USAGE_RELATIONS);
+  if (precise.testFiles.length > 0) return precise;
   return selectionFromImpact(graph, [match.id], match.id);
 }
 function testsForChangedFiles(graph, changedFiles) {
@@ -3599,7 +3739,12 @@ function testsForChangedFiles(graph, changedFiles) {
     }
     if (graph.hasNode(file)) fileIds.push(file);
   }
-  const selection = selectionFromImpact(graph, fileIds, changedFiles.join(", "));
+  const label = changedFiles.join(", ");
+  const preciseRoots = fileIds.flatMap((f) => entityRootsOf(graph, f));
+  let selection = selectionFromImpact(graph, preciseRoots, label, USAGE_RELATIONS);
+  if (selection.testFiles.length === 0) {
+    selection = selectionFromImpact(graph, fileIds, label);
+  }
   for (const [file, info] of selfSelected) {
     if (!selection.testFiles.some((t) => t.file === file)) {
       selection.testFiles.push({ file, depth: info.depth, via: info.via });
@@ -3611,22 +3756,22 @@ function testsForChangedFiles(graph, changedFiles) {
 
 // src/diff.ts
 var import_node_child_process = require("child_process");
-var fs15 = __toESM(require("fs/promises"), 1);
+var fs16 = __toESM(require("fs/promises"), 1);
 var os = __toESM(require("os"), 1);
-var path10 = __toESM(require("path"), 1);
+var path11 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 async function graphForDirectory(root) {
   const manifest = collectFiles(root);
   const extractions = [];
   for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
-    extractions.push(await extract(path10.join(root, relFile), relFile));
+    extractions.push(await extract(path11.join(root, relFile), relFile));
   }
-  resolveCrossFileReferences(extractions);
+  resolveCrossFileReferences(extractions, { selfNames: await readSelfNames(root) });
   return buildGraph(extractions);
 }
 async function checkoutRev(repoRoot, rev) {
-  const dest = await fs15.mkdtemp(path10.join(os.tmpdir(), `graphify-review-${rev.replace(/[^a-zA-Z0-9]/g, "_")}-`));
+  const dest = await fs16.mkdtemp(path11.join(os.tmpdir(), `graphify-review-${rev.replace(/[^a-zA-Z0-9]/g, "_")}-`));
   const { stdout } = await execFileAsync(
     "git",
     ["-C", repoRoot, "archive", "--format=tar", rev],
@@ -3694,8 +3839,8 @@ async function reviewRevisions(repoRoot, base, head = "HEAD") {
     return diffGraphs(baseGraph, headGraph, base, head);
   } finally {
     await Promise.all([
-      fs15.rm(baseDir, { recursive: true, force: true }),
-      fs15.rm(headDir, { recursive: true, force: true })
+      fs16.rm(baseDir, { recursive: true, force: true }),
+      fs16.rm(headDir, { recursive: true, force: true })
     ]);
   }
 }