@dreamtree-org/graphify 1.2.0 → 1.4.0

package/dist/cli/index.js

@@ -13,7 +13,7 @@ import {
   runPipeline,
   saveResult,
   validateRules
-} from "../chunk-NS5HB65S.js";
+} from "../chunk-QEB7A5KB.js";
 import {
   affectedBy,
   buildContextPack,
@@ -25,7 +25,7 @@ import {
   shortestPath,
   testsForChangedFiles,
   testsForNode
-} from "../chunk-ZK3TA6FW.js";
+} from "../chunk-7LTO76UD.js";
 import {
   validateDsn,
   validateUrl

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   ExtractionCache: () => ExtractionCache,
   ExtractionResultSchema: () => ExtractionResultSchema,
   ExtractionValidationError: () => ExtractionValidationError,
+  LocalFileGraphStore: () => LocalFileGraphStore,
   affectedBy: () => affectedBy,
   analyze: () => analyze,
   buildContextPack: () => buildContextPack,
@@ -41,7 +42,9 @@ __export(index_exports, {
   checkRules: () => checkRules,
   cluster: () => cluster,
   collectFiles: () => collectFiles,
+  deserializeGraph: () => deserializeGraph,
   diffGraphs: () => diffGraphs,
+  expandRetrieval: () => expandRetrieval,
   explainNode: () => explainNode,
   exportGraph: () => exportGraph,
   extract: () => extract,
@@ -64,6 +67,7 @@ __export(index_exports, {
   runPipeline: () => runPipeline,
   saveResult: () => saveResult,
   scoreNodes: () => scoreNodes,
+  serializeGraph: () => serializeGraph,
   shortestPath: () => shortestPath,
   testsForChangedFiles: () => testsForChangedFiles,
   testsForNode: () => testsForNode,
@@ -2570,7 +2574,7 @@ function renderReport(graph, analysis, now = /* @__PURE__ */ new Date()) {
 
 // src/export.ts
 var import_node_module2 = require("module");
-var fs11 = __toESM(require("fs/promises"), 1);
+var fs12 = __toESM(require("fs/promises"), 1);
 var path6 = __toESM(require("path"), 1);
 
 // src/security.ts
@@ -2645,6 +2649,44 @@ function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 
+// src/store/localFile.ts
+var fs11 = __toESM(require("fs/promises"), 1);
+
+// src/store/serialize.ts
+var import_graphology3 = __toESM(require("graphology"), 1);
+function serializeGraph(graph) {
+  return graph.export();
+}
+function deserializeGraph(data) {
+  return import_graphology3.default.from(data);
+}
+
+// src/store/localFile.ts
+var LocalFileGraphStore = class {
+  async load(ref) {
+    let jsonPath;
+    try {
+      jsonPath = validateGraphPath("graph.json", ref);
+    } catch (error) {
+      if (error.message.startsWith("Base directory does not exist")) return null;
+      throw error;
+    }
+    let raw;
+    try {
+      raw = await fs11.readFile(jsonPath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+    return deserializeGraph(JSON.parse(raw));
+  }
+  async save(ref, graph) {
+    await fs11.mkdir(ref, { recursive: true });
+    const jsonPath = validateGraphPath("graph.json", ref);
+    await fs11.writeFile(jsonPath, JSON.stringify(serializeGraph(graph), null, 2), "utf-8");
+  }
+};
+
 // src/export.ts
 var require3 = (0, import_node_module2.createRequire)(importMetaUrl);
 function resolveVisNetworkAssets() {
@@ -2711,8 +2753,8 @@ community: ${communityLabel}` : ""}`,
 async function renderHtml(graph) {
   const { jsPath, cssPath } = resolveVisNetworkAssets();
   const [visJs, visCss] = await Promise.all([
-    fs11.readFile(jsPath, "utf-8"),
-    fs11.readFile(cssPath, "utf-8")
+    fs12.readFile(jsPath, "utf-8"),
+    fs12.readFile(cssPath, "utf-8")
   ]);
   const { nodes, edges } = buildVisNodesAndEdges(graph);
   const dataJson = safeInlineJson({ nodes, edges });
@@ -2753,16 +2795,15 @@ ${visJs}
 }
 async function exportGraph(graph, options, report) {
   const outDir = path6.resolve(options.outDir);
-  await fs11.mkdir(outDir, { recursive: true });
-  const jsonPath = validateGraphPath("graph.json", outDir);
-  await fs11.writeFile(jsonPath, JSON.stringify(graph.toJSON(), null, 2), "utf-8");
+  await fs12.mkdir(outDir, { recursive: true });
+  await new LocalFileGraphStore().save(outDir, graph);
   if (options.html !== false) {
     const htmlPath = validateGraphPath("graph.html", outDir);
-    await fs11.writeFile(htmlPath, await renderHtml(graph), "utf-8");
+    await fs12.writeFile(htmlPath, await renderHtml(graph), "utf-8");
   }
   if (report !== void 0) {
     const reportPath = validateGraphPath("GRAPH_REPORT.md", outDir);
-    await fs11.writeFile(reportPath, report, "utf-8");
+    await fs12.writeFile(reportPath, report, "utf-8");
   }
   const notImplemented = [];
   if (options.svg) notImplemented.push("--svg");
@@ -2775,12 +2816,12 @@ async function exportGraph(graph, options, report) {
 }
 
 // src/pipeline.ts
-var fs13 = __toESM(require("fs/promises"), 1);
+var fs14 = __toESM(require("fs/promises"), 1);
 var path8 = __toESM(require("path"), 1);
 
 // src/extractionCache.ts
 var import_node_crypto3 = require("crypto");
-var fs12 = __toESM(require("fs/promises"), 1);
+var fs13 = __toESM(require("fs/promises"), 1);
 var path7 = __toESM(require("path"), 1);
 var ExtractionCache = class {
   dir;
@@ -2792,7 +2833,7 @@ var ExtractionCache = class {
   }
   async get(key) {
     try {
-      const raw = await fs12.readFile(path7.join(this.dir, `${key}.json`), "utf-8");
+      const raw = await fs13.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;
@@ -2801,8 +2842,8 @@ var ExtractionCache = class {
     }
   }
   async put(key, extraction) {
-    await fs12.mkdir(this.dir, { recursive: true });
-    await fs12.writeFile(path7.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
+    await fs13.mkdir(this.dir, { recursive: true });
+    await fs13.writeFile(path7.join(this.dir, `${key}.json`), JSON.stringify(extraction), "utf-8");
   }
 };
 
@@ -2824,7 +2865,7 @@ async function runPipeline(root, options = {}) {
   for (const relFile of manifest.files.code.sort((a, b) => a.localeCompare(b))) {
     const filePath = path8.relative(process.cwd(), path8.join(resolvedRoot, relFile)) || relFile;
     try {
-      const key = cache.key(relFile, await fs13.readFile(path8.join(resolvedRoot, relFile)));
+      const key = cache.key(relFile, await fs14.readFile(path8.join(resolvedRoot, relFile)));
       let extraction = options.update ? await cache.get(key) : null;
       if (extraction) {
         cacheHits++;
@@ -2874,19 +2915,23 @@ async function runPipeline(root, options = {}) {
     },
     report
   );
+  if (options.store) {
+    const storeRef = options.storeRef ?? outDir;
+    progress(`Saving graph to store (${storeRef}) ...`);
+    await options.store.save(storeRef, graph);
+  }
   progress("Done.");
   return { manifest, graph, analysis, report };
 }
 
 // src/graphStore.ts
-var fs14 = __toESM(require("fs/promises"), 1);
 var path9 = __toESM(require("path"), 1);
-var import_graphology3 = __toESM(require("graphology"), 1);
 async function loadGraph(outDir = path9.join(process.cwd(), "graphify-out")) {
-  const jsonPath = validateGraphPath("graph.json", outDir);
-  const raw = await fs14.readFile(jsonPath, "utf-8");
-  const data = JSON.parse(raw);
-  return import_graphology3.default.from(data);
+  const graph = await new LocalFileGraphStore().load(outDir);
+  if (graph === null) {
+    throw new Error(`No graph found in ${outDir} \u2014 run \`graphify <path>\` to build one first.`);
+  }
+  return graph;
 }
 
 // src/query.ts
@@ -3156,6 +3201,141 @@ function explainNode(graph, query) {
   };
 }
 
+// src/retrieval.ts
+var DEFAULT_TOKEN_BUDGET2 = 2e3;
+var DEFAULT_MAX_HOPS = 2;
+function resolveSeeds(graph, hits) {
+  const seeds = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    let id = null;
+    if (hit.nodeId !== void 0 && graph.hasNode(hit.nodeId)) {
+      id = hit.nodeId;
+    } else if (hit.text !== void 0) {
+      id = resolveNode(graph, hit.text)?.id ?? null;
+    }
+    const key = id ?? hit.nodeId ?? hit.text ?? "";
+    if (key === "") continue;
+    const existing = seeds.get(key);
+    if (existing) {
+      if (hit.score !== void 0 && (existing.score === void 0 || hit.score > existing.score)) {
+        existing.score = hit.score;
+      }
+      continue;
+    }
+    seeds.set(key, { id: key, score: hit.score, inGraph: id !== null, text: hit.text });
+  }
+  return [...seeds.values()];
+}
+function expandRetrieval(graph, hits, options = {}) {
+  const tokenBudget = options.tokenBudget ?? DEFAULT_TOKEN_BUDGET2;
+  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;
+  const relations = options.relations ? new Set(options.relations) : null;
+  const seeds = resolveSeeds(graph, hits);
+  const graphSeeds = seeds.filter((s) => s.inGraph);
+  const seedScore = new Map(graphSeeds.map((s) => [s.id, s.score]));
+  const hops = /* @__PURE__ */ new Map();
+  const via = /* @__PURE__ */ new Map();
+  const frontier = [];
+  let spentTokens = 0;
+  for (const seed of graphSeeds) {
+    hops.set(seed.id, 0);
+    frontier.push(seed.id);
+    spentTokens += nodeTokenCost(graph, seed.id);
+  }
+  let truncated = false;
+  while (frontier.length > 0) {
+    const current = frontier.shift();
+    const currentHops = hops.get(current);
+    if (currentHops >= maxHops) continue;
+    const candidates = [];
+    graph.forEachEdge(current, (_key, attrs, source, target) => {
+      const relation = String(attrs.relation);
+      if (relations && !relations.has(relation)) return;
+      const neighbor = source === current ? target : source;
+      candidates.push({
+        neighbor,
+        edge: { source, target, relation, confidence: String(attrs.confidence) }
+      });
+    });
+    candidates.sort((a, b) => a.neighbor.localeCompare(b.neighbor));
+    for (const { neighbor, edge } of candidates) {
+      if (hops.has(neighbor)) continue;
+      const cost = nodeTokenCost(graph, neighbor);
+      if (spentTokens + cost > tokenBudget) {
+        truncated = true;
+        continue;
+      }
+      spentTokens += cost;
+      hops.set(neighbor, currentHops + 1);
+      via.set(neighbor, edge);
+      frontier.push(neighbor);
+    }
+  }
+  const degree = (id) => graph.degree(id);
+  const nodes = [...hops.entries()].map(([id, hopCount]) => {
+    const attrs = graph.getNodeAttributes(id);
+    return {
+      id,
+      label: attrs.label ?? id,
+      ...attrs.kind !== void 0 ? { kind: String(attrs.kind) } : {},
+      sourceFile: attrs.sourceFile ?? "",
+      sourceLocation: attrs.sourceLocation ?? "",
+      hops: hopCount,
+      ...via.has(id) ? { via: via.get(id) } : {},
+      ...hopCount === 0 && seedScore.get(id) !== void 0 ? { seedScore: seedScore.get(id) } : {}
+    };
+  });
+  for (const seed of seeds) {
+    if (seed.inGraph) continue;
+    nodes.push({
+      id: seed.id,
+      label: seed.text ?? seed.id,
+      sourceFile: "",
+      sourceLocation: "",
+      hops: 0,
+      ...seed.score !== void 0 ? { seedScore: seed.score } : {}
+    });
+  }
+  nodes.sort((a, b) => {
+    if (a.hops !== b.hops) return a.hops - b.hops;
+    if (a.hops === 0) {
+      return (b.seedScore ?? -Infinity) - (a.seedScore ?? -Infinity) || a.id.localeCompare(b.id);
+    }
+    const degreeDiff = (graph.hasNode(b.id) ? degree(b.id) : 0) - (graph.hasNode(a.id) ? degree(a.id) : 0);
+    return degreeDiff || a.id.localeCompare(b.id);
+  });
+  const included = /* @__PURE__ */ new Set([...hops.keys()]);
+  const edges = [];
+  graph.forEachEdge((_key, attrs, source, target) => {
+    if (!included.has(source) || !included.has(target)) return;
+    const relation = String(attrs.relation);
+    if (relations && !relations.has(relation)) return;
+    edges.push({ source, target, relation, confidence: String(attrs.confidence) });
+  });
+  edges.sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || a.relation.localeCompare(b.relation)
+  );
+  const communities = /* @__PURE__ */ new Map();
+  for (const id of included) {
+    const attrs = graph.getNodeAttributes(id);
+    const community = attrs.community;
+    if (community === void 0) continue;
+    const entry = communities.get(community) ?? {
+      id: community,
+      label: attrs.communityLabel ?? String(community),
+      seedCount: 0
+    };
+    if (hops.get(id) === 0) entry.seedCount += 1;
+    communities.set(community, entry);
+  }
+  return {
+    nodes,
+    edges,
+    communities: [...communities.values()].sort((a, b) => b.seedCount - a.seedCount || a.id - b.id),
+    truncated
+  };
+}
+
 // src/impact.ts
 var DEPENDENCY_RELATIONS = /* @__PURE__ */ new Set([
   "calls",
@@ -3951,6 +4131,7 @@ function checkRules(graph, config) {
   ExtractionCache,
   ExtractionResultSchema,
   ExtractionValidationError,
+  LocalFileGraphStore,
   affectedBy,
   analyze,
   buildContextPack,
@@ -3958,7 +4139,9 @@ function checkRules(graph, config) {
   checkRules,
   cluster,
   collectFiles,
+  deserializeGraph,
   diffGraphs,
+  expandRetrieval,
   explainNode,
   exportGraph,
   extract,
@@ -3981,6 +4164,7 @@ function checkRules(graph, config) {
   runPipeline,
   saveResult,
   scoreNodes,
+  serializeGraph,
   shortestPath,
   testsForChangedFiles,
   testsForNode,