@dreamtree-org/graphify 1.1.1 → 1.1.2

package/README.md

@@ -16,8 +16,12 @@ the right files. A graph fixes retrieval, but node lists alone still leave the a
 chase files. graphify closes the loop: its answers are **task-shaped** — actual code
 snippets, test lists, impact checklists, diffs — not just structure.
 
-Measured on this repository itself (`graphify benchmark`): answering through the graph uses
-**~8x fewer tokens** than reading the files each answer touches.
+Token savings depend on the shape of your repo: graph answers have a roughly fixed cost
+(they fill toward their token budget), so the win grows with how much code a naive file
+read would have pulled in. Measured with `graphify benchmark`: **up to ~8x** on this
+repository (~100 files, deep cross-file structure), closer to **~1.5x** on small,
+tightly-organized libraries — and on a trivial question in a tiny repo, reading the file
+directly can be cheaper. Run `graphify benchmark` on your own repo before quoting a number.
 
 ## Install
 

package/dist/{chunk-EW23BLJC.js → chunk-PXVI2L45.js}

@@ -1535,10 +1535,10 @@ async function extractRust(filePath, displayPath) {
         }
       }
     } else if (fn.type === "scoped_identifier") {
-      const path10 = fn.childForFieldName("path")?.text;
+      const path11 = fn.childForFieldName("path")?.text;
       const name = fn.childForFieldName("name")?.text;
-      if (path10 && name) {
-        const viaImport = importIndex.get(path10);
+      if (path11 && name) {
+        const viaImport = importIndex.get(path11);
         if (viaImport) {
           targetId = viaImport.id;
           confidence = "INFERRED";
@@ -2017,6 +2017,8 @@ function buildGraph(extractions) {
 }
 
 // src/resolve.ts
+import * as fs9 from "fs/promises";
+import * as path5 from "path";
 var CODE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -2036,6 +2038,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);
@@ -2060,11 +2085,16 @@ function uniqueMatch(guessed, candidates, realIds) {
   if (matches.size !== 1) return null;
   return [...matches][0];
 }
-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 sep2 = node.id.indexOf("::");
       if (sep2 > 0) realFiles.add(node.id.slice(0, sep2));
@@ -2075,6 +2105,19 @@ function resolveCrossFileReferences(extractions) {
   }
   const remap = /* @__PURE__ */ new Map();
   const resolveId = (id) => {
+    if (id.startsWith("module:") && selfNames.length > 0) {
+      const cachedSelf = remap.get(id);
+      if (cachedSelf !== void 0) return cachedSelf;
+      const candidates = selfImportCandidates(id.slice("module:".length), selfNames);
+      if (candidates !== null) {
+        const resolved2 = uniqueMatch(id, candidates, realFiles);
+        if (resolved2 !== null) {
+          remap.set(id, resolved2);
+          return resolved2;
+        }
+      }
+      return null;
+    }
     if (isOpaque(id)) return null;
     const cached = remap.get(id);
     if (cached !== void 0) return cached;
@@ -2383,15 +2426,15 @@ function renderReport(graph, analysis, now = /* @__PURE__ */ new Date()) {
 
 // src/export.ts
 import { createRequire as createRequire2 } from "module";
-import * as fs9 from "fs/promises";
-import * as path5 from "path";
+import * as fs10 from "fs/promises";
+import * as path6 from "path";
 var require3 = createRequire2(import.meta.url);
 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 = [
@@ -2450,8 +2493,8 @@ community: ${communityLabel}` : ""}`,
 async function renderHtml(graph) {
   const { jsPath, cssPath } = resolveVisNetworkAssets();
   const [visJs, visCss] = await Promise.all([
-    fs9.readFile(jsPath, "utf-8"),
-    fs9.readFile(cssPath, "utf-8")
+    fs10.readFile(jsPath, "utf-8"),
+    fs10.readFile(cssPath, "utf-8")
   ]);
   const { nodes, edges } = buildVisNodesAndEdges(graph);
   const dataJson = safeInlineJson({ nodes, edges });
@@ -2491,17 +2534,17 @@ ${visJs}
 `;
 }
 async function exportGraph(graph, options, report) {
-  const outDir = path5.resolve(options.outDir);
-  await fs9.mkdir(outDir, { recursive: true });
+  const outDir = path6.resolve(options.outDir);
+  await fs10.mkdir(outDir, { recursive: true });
   const jsonPath = validateGraphPath("graph.json", outDir);
-  await fs9.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
+  await fs10.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
   if (options.html !== false) {
     const htmlPath = validateGraphPath("graph.html", outDir);
-    await fs9.writeFile(htmlPath, await renderHtml(graph), "utf-8");
+    await fs10.writeFile(htmlPath, await renderHtml(graph), "utf-8");
   }
   if (report !== void 0) {
     const reportPath = validateGraphPath("GRAPH_REPORT.md", outDir);
-    await fs9.writeFile(reportPath, report, "utf-8");
+    await fs10.writeFile(reportPath, report, "utf-8");
   }
   const notImplemented = [];
   if (options.svg) notImplemented.push("--svg");
@@ -2515,19 +2558,19 @@ async function exportGraph(graph, options, report) {
 
 // src/extractionCache.ts
 import { createHash as createHash2 } from "crypto";
-import * as fs10 from "fs/promises";
-import * as path6 from "path";
+import * as fs11 from "fs/promises";
+import * as path7 from "path";
 var ExtractionCache = class {
   dir;
   constructor(outDir) {
-    this.dir = path6.join(outDir, "cache");
+    this.dir = path7.join(outDir, "cache");
   }
   key(relFile, content) {
     return createHash2("sha256").update(relFile).update("\0").update(content).digest("hex");
   }
   async get(key) {
     try {
-      const raw = await fs10.readFile(path6.join(this.dir, `${key}.json`), "utf-8");
+      const raw = await fs11.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;
@@ -2536,32 +2579,32 @@ var ExtractionCache = class {
     }
   }
   async put(key, extraction) {
-    await fs10.mkdir(this.dir, { recursive: true });
-    await fs10.writeFile(path6.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
+    await fs11.mkdir(this.dir, { recursive: true });
+    await fs11.writeFile(path7.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
   }
 };
 
 // src/pipeline.ts
-import * as fs11 from "fs/promises";
-import * as path7 from "path";
+import * as fs12 from "fs/promises";
+import * as path8 from "path";
 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 fs11.readFile(path7.join(resolvedRoot, relFile)));
+      const key = cache.key(relFile, await fs12.readFile(path8.join(resolvedRoot, relFile)));
       let extraction = options.update ? await cache.get(key) : null;
       if (extraction) {
         cacheHits++;
@@ -2582,7 +2625,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).`
@@ -2671,8 +2716,8 @@ function mergeGraphs(entries) {
 
 // src/memory.ts
 import { createHash as createHash3 } from "crypto";
-import * as fs12 from "fs/promises";
-import * as path8 from "path";
+import * as fs13 from "fs/promises";
+import * as path9 from "path";
 var OUTCOMES = /* @__PURE__ */ new Set(["useful", "dead_end", "corrected"]);
 var TYPES = /* @__PURE__ */ new Set(["query", "path", "explain", "affected"]);
 function validateResult(value) {
@@ -2690,25 +2735,25 @@ function validateResult(value) {
 }
 async function saveResult(entry, memoryDir, now = /* @__PURE__ */ new Date()) {
   validateResult(entry);
-  await fs12.mkdir(memoryDir, { recursive: true });
+  await fs13.mkdir(memoryDir, { recursive: true });
   const saved = { ...entry, savedAt: now.toISOString() };
   const hash = createHash3("sha256").update(JSON.stringify(saved)).digest("hex").slice(0, 8);
   const stamp = saved.savedAt.replace(/[:.]/g, "-");
-  const filePath = path8.join(memoryDir, `result-${stamp}-${hash}.json`);
-  await fs12.writeFile(filePath, JSON.stringify(saved, null, 2), "utf-8");
+  const filePath = path9.join(memoryDir, `result-${stamp}-${hash}.json`);
+  await fs13.writeFile(filePath, JSON.stringify(saved, null, 2), "utf-8");
   return filePath;
 }
 async function loadResults(memoryDir) {
   let files;
   try {
-    files = (await fs12.readdir(memoryDir)).filter((f) => f.startsWith("result-") && f.endsWith(".json"));
+    files = (await fs13.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 fs12.readFile(path8.join(memoryDir, file), "utf-8"));
+      const parsed = JSON.parse(await fs13.readFile(path9.join(memoryDir, file), "utf-8"));
       if (parsed.question && parsed.savedAt) results.push(parsed);
     } catch {
     }
@@ -2784,22 +2829,22 @@ function renderLessons(results, options = {}) {
 
 // src/diff.ts
 import { execFile } from "child_process";
-import * as fs13 from "fs/promises";
+import * as fs14 from "fs/promises";
 import * as os from "os";
-import * as path9 from "path";
+import * as path10 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(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(path9.join(root, relFile), relFile));
+    extractions.push(await extract(path10.join(root, relFile), relFile));
   }
-  resolveCrossFileReferences(extractions);
+  resolveCrossFileReferences(extractions, { selfNames: await readSelfNames(root) });
   return buildGraph(extractions);
 }
 async function checkoutRev(repoRoot, rev) {
-  const dest = await fs13.mkdtemp(path9.join(os.tmpdir(), `graphify-review-${rev.replace(/[^a-zA-Z0-9]/g, "_")}-`));
+  const dest = await fs14.mkdtemp(path10.join(os.tmpdir(), `graphify-review-${rev.replace(/[^a-zA-Z0-9]/g, "_")}-`));
   const { stdout } = await execFileAsync(
     "git",
     ["-C", repoRoot, "archive", "--format=tar", rev],
@@ -2867,8 +2912,8 @@ async function reviewRevisions(repoRoot, base, head = "HEAD") {
     return diffGraphs(baseGraph, headGraph, base, head);
   } finally {
     await Promise.all([
-      fs13.rm(baseDir, { recursive: true, force: true }),
-      fs13.rm(headDir, { recursive: true, force: true })
+      fs14.rm(baseDir, { recursive: true, force: true }),
+      fs14.rm(headDir, { recursive: true, force: true })
     ]);
   }
 }
@@ -3001,4 +3046,4 @@ export {
   validateRules,
   checkRules
 };
-//# sourceMappingURL=chunk-EW23BLJC.js.map
+//# sourceMappingURL=chunk-PXVI2L45.js.map