@deeplake/hivemind 0.7.44 → 0.7.46

package/cursor/bundle/shell/deeplake-shell.js

@@ -46081,14 +46081,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self2, node);
         }
-        return join14(output, replacement);
+        return join18(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self2 = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join14(output, rule.append(self2.options));
+          output = join18(output, rule.append(self2.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -46100,7 +46100,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace.leading || whitespace.trailing) content = content.trim();
       return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
     }
-    function join14(output, replacement) {
+    function join18(output, replacement) {
       var s12 = trimTrailingNewlines(output);
       var s22 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s12.length, replacement.length - s22.length);
@@ -66792,6 +66792,7 @@ function loadConfig() {
     tableName: process.env.HIVEMIND_TABLE ?? "memory",
     sessionsTableName: process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions",
     skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    codebaseTableName: process.env.HIVEMIND_CODEBASE_TABLE ?? "codebase",
     memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join4(home, ".deeplake", "memory")
   };
 }
@@ -66909,9 +66910,33 @@ function validateSchema(label, cols) {
     }
   }
 }
+var CODEBASE_COLUMNS = Object.freeze([
+  // Identity key (matches the PK below)
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "repo_slug", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "user_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "worktree_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "commit_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Observation metadata
+  { name: "parent_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "branch", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TIMESTAMP" },
+  { name: "pushed_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Snapshot payload
+  { name: "snapshot_sha256", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "snapshot_jsonb", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "node_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "edge_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // Generator metadata (for drift diagnostics — what hivemind version produced this?)
+  { name: "generator", sql: "TEXT NOT NULL DEFAULT 'hivemind-graph'" },
+  { name: "generator_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "schema_version", sql: "BIGINT NOT NULL DEFAULT 1" }
+]);
 validateSchema("MEMORY_COLUMNS", MEMORY_COLUMNS);
 validateSchema("SESSIONS_COLUMNS", SESSIONS_COLUMNS);
 validateSchema("SKILLS_COLUMNS", SKILLS_COLUMNS);
+validateSchema("CODEBASE_COLUMNS", CODEBASE_COLUMNS);
 function buildCreateTableSql(tableName, cols) {
   const safe = sqlIdent(tableName);
   const colSql = cols.map((c15) => `${c15.name} ${c15.sql}`).join(", ");
@@ -67136,7 +67161,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms3) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms3));
+  return new Promise((resolve7) => setTimeout(resolve7, ms3));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -67166,7 +67191,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve6) => this.waiting.push(resolve6));
+    await new Promise((resolve7) => this.waiting.push(resolve7));
   }
   release() {
     this.active--;
@@ -67476,6 +67501,24 @@ var DeeplakeApi = class {
    * This sidesteps the Deeplake UPDATE-coalescing quirk that bit the wiki
    * worker.
    */
+  /**
+   * Create the codebase table. One row per (org, workspace, repo, user,
+   * worktree, commit) — see CODEBASE_COLUMNS for the schema. Healing
+   * + index follow the same pattern as ensureSessionsTable.
+   */
+  async ensureCodebaseTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, CODEBASE_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, CODEBASE_COLUMNS);
+    await this.ensureLookupIndex(safe, "codebase_identity", `("org_id", "workspace_id", "repo_slug", "user_id", "worktree_id", "commit_sha")`);
+  }
   async ensureSkillsTable(name) {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
@@ -67492,10 +67535,10 @@ var DeeplakeApi = class {
 };
 
 // dist/src/shell/deeplake-fs.js
-import { basename as basename4, posix } from "node:path";
+import { basename as basename5, posix } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname9, join as join16 } from "node:path";
 
 // dist/src/shell/grep-core.js
 var TOOL_INPUT_FIELDS = [
@@ -68176,7 +68219,7 @@ var EmbedClient = class {
     }
   }
   connectOnce() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const sock = connect(this.socketPath);
       const to3 = setTimeout(() => {
         sock.destroy();
@@ -68184,7 +68227,7 @@ var EmbedClient = class {
       }, this.timeoutMs);
       sock.once("connect", () => {
         clearTimeout(to3);
-        resolve6(sock);
+        resolve7(sock);
       });
       sock.once("error", (e6) => {
         clearTimeout(to3);
@@ -68266,7 +68309,7 @@ var EmbedClient = class {
     throw new Error("daemon did not become ready within spawnWaitMs");
   }
   sendAndWait(sock, req) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       let buf = "";
       const to3 = setTimeout(() => {
         sock.destroy();
@@ -68281,7 +68324,7 @@ var EmbedClient = class {
         const line = buf.slice(0, nl3);
         clearTimeout(to3);
         try {
-          resolve6(JSON.parse(line));
+          resolve7(JSON.parse(line));
         } catch (e6) {
           reject(e6);
         }
@@ -68501,6 +68544,440 @@ function buildVirtualIndexContent(summaryRows, sessionRows = [], opts = {}) {
   return lines.join("\n");
 }
 
+// dist/src/graph/vfs-handler.js
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { join as join15, dirname as dirname8 } from "node:path";
+
+// dist/src/graph/last-build.js
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join12 } from "node:path";
+function lastBuildPath(baseDir, worktreeId) {
+  if (worktreeId !== void 0) {
+    return join12(baseDir, "worktrees", worktreeId, ".last-build.json");
+  }
+  return join12(baseDir, ".last-build.json");
+}
+function readLastBuild(baseDir, worktreeId) {
+  let path2 = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync6(path2)) {
+    if (worktreeId === void 0)
+      return null;
+    const legacy = lastBuildPath(baseDir, void 0);
+    if (!existsSync6(legacy))
+      return null;
+    path2 = legacy;
+  }
+  let raw;
+  try {
+    raw = readFileSync7(path2, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object")
+    return null;
+  const o14 = parsed;
+  if (typeof o14.ts !== "number" || !Number.isFinite(o14.ts))
+    return null;
+  if (o14.commit_sha !== null && typeof o14.commit_sha !== "string")
+    return null;
+  if (typeof o14.snapshot_sha256 !== "string")
+    return null;
+  const out = { ts: o14.ts, commit_sha: o14.commit_sha, snapshot_sha256: o14.snapshot_sha256 };
+  if (typeof o14.node_count === "number" && Number.isFinite(o14.node_count) && o14.node_count >= 0) {
+    out.node_count = o14.node_count;
+  }
+  if (typeof o14.edge_count === "number" && Number.isFinite(o14.edge_count) && o14.edge_count >= 0) {
+    out.edge_count = o14.edge_count;
+  }
+  return out;
+}
+
+// dist/src/graph/snapshot.js
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync7, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname7, join as join14 } from "node:path";
+
+// dist/src/graph/history.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname6, join as join13 } from "node:path";
+
+// dist/src/graph/snapshot.js
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join14(homedir8(), ".hivemind", "graphs");
+}
+function repoDir(repoKey) {
+  return join14(graphsRoot(), repoKey);
+}
+
+// dist/src/utils/repo-identity.js
+import { execSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { basename as basename4, resolve as resolve5 } from "node:path";
+var DEFAULT_PORTS = {
+  http: "80",
+  https: "443",
+  ssh: "22",
+  git: "9418"
+};
+function normalizeGitRemoteUrl(url) {
+  let s10 = url.trim();
+  const schemeMatch = s10.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
+  if (schemeMatch)
+    s10 = s10.slice(schemeMatch[0].length);
+  if (!scheme) {
+    const scp = s10.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      s10 = `${scp[1]}/${scp[2]}`;
+  }
+  s10 = s10.replace(/^[^@/]+@/, "");
+  if (scheme && DEFAULT_PORTS[scheme]) {
+    s10 = s10.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
+  }
+  s10 = s10.replace(/\.git\/?$/i, "");
+  s10 = s10.replace(/\/+$/, "");
+  return s10.toLowerCase();
+}
+function deriveProjectKey(cwd) {
+  const absCwd = resolve5(cwd);
+  const project = basename4(absCwd) || "unknown";
+  let signature = null;
+  try {
+    const raw = execSync("git config --get remote.origin.url", {
+      cwd: absCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? absCwd;
+  const key = createHash2("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/graph/vfs-handler.js
+function workTreeIdFor(cwd) {
+  return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function handleGraphVfs(subpath, cwd) {
+  const path2 = subpath.replace(/^\/+/, "");
+  if (path2 === "" || path2 === "/") {
+    return { kind: "ok", body: dirListing() };
+  }
+  if (path2 === "index.md" || path2 === "index") {
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderIndex(snap, baseDir, cwd)
+    }));
+  }
+  if (path2.startsWith("find/")) {
+    const pattern = path2.slice("find/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "find/ requires a pattern: cat memory/graph/find/<keyword>" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderFind(snap, pattern, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path2.startsWith("show/")) {
+    const key = path2.slice("show/".length);
+    if (key === "") {
+      return { kind: "not-found", message: "show/ requires a handle or pattern" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  return {
+    kind: "not-found",
+    message: `Unknown endpoint: graph/${path2}
+Available: index.md, find/<pattern>, show/<handle-or-pattern>`
+  };
+}
+function loadSnapshotOrError(cwd, fn4) {
+  let key;
+  let baseDir;
+  try {
+    key = deriveProjectKey(cwd).key;
+    baseDir = repoDir(key);
+  } catch (e6) {
+    return { kind: "no-graph", message: `Cannot derive repo identity: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+  const wt3 = workTreeIdFor(cwd);
+  const last = readLastBuild(baseDir, wt3);
+  if (last === null) {
+    return {
+      kind: "no-graph",
+      message: "No local graph for this worktree yet. Run `hivemind graph build` (or `hivemind graph pull` if a teammate has built this commit)."
+    };
+  }
+  const fileBase = last.commit_sha ?? last.snapshot_sha256;
+  const snapPath = join15(baseDir, "snapshots", `${fileBase}.json`);
+  if (!existsSync8(snapPath)) {
+    return { kind: "no-graph", message: `Snapshot file missing on disk: ${snapPath}` };
+  }
+  let snap;
+  try {
+    snap = JSON.parse(readFileSync9(snapPath, "utf8"));
+  } catch (e6) {
+    return { kind: "no-graph", message: `Failed to parse snapshot: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+  if (!Array.isArray(snap.nodes) || !Array.isArray(snap.links)) {
+    return { kind: "no-graph", message: "Snapshot schema is invalid (missing nodes/links arrays)." };
+  }
+  try {
+    return fn4(snap, baseDir);
+  } catch (e6) {
+    return { kind: "no-graph", message: `Failed to render graph view: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+}
+function dirListing() {
+  return [
+    "index.md",
+    "find/",
+    "show/"
+  ].join("\n");
+}
+function renderIndex(snap, baseDir, cwd) {
+  const commit = snap.graph.commit_sha?.slice(0, 7) ?? "no-commit";
+  const fullCommit = snap.graph.commit_sha ?? "no-commit";
+  const totalNodes = snap.nodes.length;
+  const totalEdges = snap.links.length;
+  const byFile = {};
+  for (const n24 of snap.nodes)
+    byFile[n24.source_file] = (byFile[n24.source_file] ?? 0) + 1;
+  const topFiles = Object.entries(byFile).sort(([, a15], [, b26]) => b26 - a15).slice(0, 8);
+  const byRel = {};
+  for (const e6 of snap.links)
+    byRel[e6.relation] = (byRel[e6.relation] ?? 0) + 1;
+  const byKind = {};
+  for (const n24 of snap.nodes)
+    byKind[n24.kind] = (byKind[n24.kind] ?? 0) + 1;
+  const lines = [];
+  lines.push(`# Code Graph \u2014 ${snap.observation.repo_project}`);
+  lines.push("");
+  lines.push(`Commit:  ${fullCommit}  (built ${snap.observation.ts})`);
+  lines.push(`Branch:  ${snap.observation.branch ?? "(detached)"}`);
+  lines.push(`Source:  ${join15(baseDir, "snapshots", `${commit ? snap.graph.commit_sha : "?"}.json`)}`);
+  lines.push("");
+  lines.push(`Nodes:   ${totalNodes}    Edges: ${totalEdges}`);
+  lines.push("");
+  lines.push("## How to query");
+  lines.push("  cat ~/.deeplake/memory/graph/find/<pattern>");
+  lines.push("    Case-insensitive substring match on node id + label.");
+  lines.push("    Emits numbered handles [1] [2] ... saved for this worktree.");
+  lines.push("");
+  lines.push("  cat ~/.deeplake/memory/graph/show/<handle-or-pattern>");
+  lines.push("    <handle>: a digit from a prior `find/` (e.g. 3).");
+  lines.push("    <pattern>: a substring; resolves to a unique node if possible,");
+  lines.push("               or shows candidates if ambiguous.");
+  lines.push("    Output: node detail + 1-hop neighbors grouped by edge kind.");
+  lines.push("");
+  lines.push("## Node kinds");
+  for (const [k17, n24] of Object.entries(byKind).sort(([, a15], [, b26]) => b26 - a15)) {
+    lines.push(`  ${k17.padEnd(12)} ${n24}`);
+  }
+  lines.push("");
+  lines.push("## Edge kinds");
+  for (const [k17, n24] of Object.entries(byRel).sort(([, a15], [, b26]) => b26 - a15)) {
+    lines.push(`  ${k17.padEnd(12)} ${n24}`);
+  }
+  lines.push("");
+  lines.push("## Top files by node count");
+  for (const [f11, n24] of topFiles) {
+    lines.push(`  ${String(n24).padStart(4)}  ${f11}`);
+  }
+  lines.push("");
+  lines.push(`Limitations:`);
+  lines.push(`  - TypeScript only. AST-based, no semantic similarity edges.`);
+  lines.push(`  - 'calls' edges are intra-file only (Phase 1 extractor doesn't resolve cross-file).`);
+  lines.push(`    A node showing "Incoming (0)" may still have callers in OTHER files \u2014`);
+  lines.push(`    treat it as "no callers in the same file", not "unused".`);
+  lines.push(`  - 'imports' edges are file-level and DO span files; trust them.`);
+  lines.push(`  - Stale after edits \u2014 if a file's mtime is newer than the build, read the live source.`);
+  void cwd;
+  return lines.join("\n");
+}
+function renderFind(snap, pattern, baseDir, worktreeId) {
+  const needle = pattern.toLowerCase();
+  const matches = [];
+  for (const n24 of snap.nodes) {
+    const id = n24.id.toLowerCase();
+    const lbl = n24.label.toLowerCase();
+    if (id.includes(needle) || lbl.includes(needle))
+      matches.push(n24);
+  }
+  matches.sort((a15, b26) => {
+    const ra2 = rank(a15, needle);
+    const rb = rank(b26, needle);
+    if (ra2 !== rb)
+      return ra2 - rb;
+    return a15.id.localeCompare(b26.id);
+  });
+  const capped = matches.slice(0, 50);
+  if (capped.length === 0) {
+    return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
+Try a shorter or different substring.`;
+  }
+  saveHandles(baseDir, worktreeId, capped.map((n24) => n24.id), pattern);
+  const lines = [];
+  lines.push(`${matches.length} match${matches.length === 1 ? "" : "es"} for "${pattern}"${matches.length > capped.length ? ` (showing first ${capped.length})` : ""}:`);
+  lines.push("");
+  for (let i11 = 0; i11 < capped.length; i11++) {
+    const n24 = capped[i11];
+    const tag = n24.exported ? "exported" : "internal";
+    lines.push(`  [${i11 + 1}]  ${n24.id}   ${n24.kind} (${tag})`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> to see node + 1-hop neighbors");
+  return lines.join("\n");
+}
+function renderShow(snap, key, baseDir, worktreeId) {
+  if (/^\d+$/.test(key)) {
+    const idx = parseInt(key, 10);
+    const handles = loadHandles(baseDir, worktreeId);
+    if (handles === null) {
+      return `Handle [${idx}] not resolvable: no recent find/ in this worktree. Run cat memory/graph/find/<pattern> first.`;
+    }
+    if (idx < 1 || idx > handles.ids.length) {
+      return `Handle [${idx}] out of range. Last find/${handles.pattern} produced ${handles.ids.length} matches.`;
+    }
+    const nodeId = handles.ids[idx - 1];
+    const node = snap.nodes.find((n24) => n24.id === nodeId);
+    if (!node) {
+      return `Handle [${idx}] points at "${nodeId}" but that node is no longer in the snapshot (graph rebuilt since last find?). Re-run find.`;
+    }
+    return renderNodeDetail(snap, node);
+  }
+  const needle = key.toLowerCase();
+  const matches = snap.nodes.filter((n24) => n24.id.toLowerCase().includes(needle));
+  if (matches.length === 0) {
+    return `No node matches "${key}". Try cat memory/graph/find/${key} for fuzzy search.`;
+  }
+  if (matches.length === 1) {
+    return renderNodeDetail(snap, matches[0]);
+  }
+  saveHandles(baseDir, worktreeId, matches.slice(0, 50).map((n24) => n24.id), key);
+  const lines = [];
+  lines.push(`"${key}" matches ${matches.length} nodes. Pick one:`);
+  lines.push("");
+  for (let i11 = 0; i11 < Math.min(matches.length, 50); i11++) {
+    lines.push(`  [${i11 + 1}]  ${matches[i11].id}`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N>");
+  return lines.join("\n");
+}
+function renderNodeDetail(snap, node) {
+  const incoming = [];
+  const outgoing = [];
+  for (const e6 of snap.links) {
+    if (e6.target === node.id)
+      incoming.push(e6);
+    if (e6.source === node.id)
+      outgoing.push(e6);
+  }
+  const groupBy = (es3) => {
+    const m26 = /* @__PURE__ */ new Map();
+    for (const e6 of es3) {
+      const list = m26.get(e6.relation) ?? [];
+      list.push(e6);
+      m26.set(e6.relation, list);
+    }
+    return m26;
+  };
+  const inGrp = groupBy(incoming);
+  const outGrp = groupBy(outgoing);
+  const lines = [];
+  lines.push(`Node: ${node.id}`);
+  lines.push(`  source: ${node.source_file}:${node.source_location}`);
+  lines.push(`  kind:   ${node.kind}`);
+  lines.push(`  label:  ${node.label}`);
+  lines.push(`  ${node.exported ? "exported" : "internal"}`);
+  lines.push("");
+  const inHint = incoming.length === 0 ? "  \u2014 no edges from THIS file (intra-file only; may still be called from other files)" : ":";
+  lines.push(`Incoming (${incoming.length})${inHint}`);
+  for (const [rel, es3] of [...inGrp.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
+    lines.push(`  ${rel} (${es3.length}):`);
+    for (const e6 of es3.slice(0, 20)) {
+      lines.push(`    ${e6.source}`);
+    }
+    if (es3.length > 20)
+      lines.push(`    ... and ${es3.length - 20} more`);
+  }
+  lines.push("");
+  lines.push(`Outgoing (${outgoing.length})${outgoing.length === 0 ? "  \u2014 this node has no edges out" : ":"}`);
+  for (const [rel, es3] of [...outGrp.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
+    lines.push(`  ${rel} (${es3.length}):`);
+    for (const e6 of es3.slice(0, 20)) {
+      lines.push(`    ${e6.target}`);
+    }
+    if (es3.length > 20)
+      lines.push(`    ... and ${es3.length - 20} more`);
+  }
+  return lines.join("\n");
+}
+function rank(n24, needle) {
+  const lbl = n24.label.toLowerCase();
+  const id = n24.id.toLowerCase();
+  if (lbl === needle)
+    return 0;
+  if (lbl.startsWith(needle))
+    return 1;
+  if (lbl.includes(needle))
+    return 2;
+  if (id.includes(needle))
+    return 3;
+  return 4;
+}
+function handlesPath(baseDir, worktreeId) {
+  return join15(baseDir, "worktrees", worktreeId, ".find-handles.json");
+}
+function saveHandles(baseDir, worktreeId, ids, pattern) {
+  const path2 = handlesPath(baseDir, worktreeId);
+  const payload = { pattern, ts: Date.now(), ids };
+  try {
+    mkdirSync8(dirname8(path2), { recursive: true });
+    const tmp = `${path2}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync7(tmp, JSON.stringify(payload));
+    renameSync5(tmp, path2);
+  } catch {
+  }
+}
+function loadHandles(baseDir, worktreeId) {
+  const path2 = handlesPath(baseDir, worktreeId);
+  if (!existsSync8(path2))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
+    if (parsed === null || typeof parsed !== "object")
+      return null;
+    const o14 = parsed;
+    if (typeof o14.pattern !== "string")
+      return null;
+    if (typeof o14.ts !== "number")
+      return null;
+    if (!Array.isArray(o14.ids))
+      return null;
+    if (!o14.ids.every((s10) => typeof s10 === "string"))
+      return null;
+    return { pattern: o14.pattern, ts: o14.ts, ids: o14.ids };
+  } catch {
+    return null;
+  }
+}
+
 // dist/src/shell/deeplake-fs.js
 var BATCH_SIZE = 10;
 var PREFETCH_BATCH_SIZE = 50;
@@ -68530,7 +69007,7 @@ function normalizeSessionMessage(path2, message) {
   return normalizeContent(path2, raw);
 }
 function resolveEmbedDaemonPath() {
-  return join12(dirname5(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
+  return join16(dirname9(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
 }
 function joinSessionMessages(path2, messages) {
   return messages.map((message) => normalizeSessionMessage(path2, message)).join("\n");
@@ -68538,6 +69015,29 @@ function joinSessionMessages(path2, messages) {
 function fsErr(code, msg, path2) {
   return Object.assign(new Error(`${code}: ${msg}, '${path2}'`), { code });
 }
+var GRAPH_ROOT = "/graph";
+var GRAPH_PREFIX = "/graph/";
+var GRAPH_DIRS = /* @__PURE__ */ new Set([GRAPH_ROOT, "/graph/find", "/graph/show"]);
+function isGraphPath(p22) {
+  return p22 === GRAPH_ROOT || p22.startsWith(GRAPH_PREFIX);
+}
+function isGraphDir(p22) {
+  return GRAPH_DIRS.has(p22);
+}
+function graphSubpathOf(p22) {
+  if (p22 === GRAPH_ROOT)
+    return "";
+  return p22.slice(GRAPH_PREFIX.length);
+}
+function readGraphFile(p22, cwd) {
+  const sub = graphSubpathOf(p22);
+  const r10 = handleGraphVfs(sub, cwd);
+  if (r10.kind === "ok")
+    return r10.body;
+  if (r10.kind === "no-graph")
+    return `(no-graph) ${r10.message}`;
+  throw fsErr("ENOENT", `${r10.message}`, p22);
+}
 var DeeplakeFs = class _DeeplakeFs {
   client;
   table;
@@ -68639,7 +69139,7 @@ var DeeplakeFs = class _DeeplakeFs {
     this.pending.delete(filePath);
     this.flushed.delete(filePath);
     const parent = parentOf(filePath);
-    this.dirs.get(parent)?.delete(basename4(filePath));
+    this.dirs.get(parent)?.delete(basename5(filePath));
   }
   // ── flush / write batching ────────────────────────────────────────────────
   scheduleFlush() {
@@ -68813,6 +69313,11 @@ var DeeplakeFs = class _DeeplakeFs {
   }
   async readFile(path2, _opts) {
     const p22 = normPath(path2);
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        throw fsErr("EISDIR", "illegal operation on a directory", p22);
+      return readGraphFile(p22, process.cwd());
+    }
     if (this.dirs.has(p22) && !this.files.has(p22))
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     if (p22 === "/index.md" && !this.files.has(p22)) {
@@ -68860,13 +69365,13 @@ var DeeplakeFs = class _DeeplakeFs {
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     const text = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
     const buf = Buffer.from(text, "utf-8");
-    const mime = guessMime(basename4(p22));
+    const mime = guessMime(basename5(p22));
     this.files.set(p22, buf);
     this.meta.set(p22, { size: buf.length, mime, mtime: /* @__PURE__ */ new Date() });
     this.addToTree(p22);
     this.pending.set(p22, {
       path: p22,
-      filename: basename4(p22),
+      filename: basename5(p22),
       contentText: text,
       mimeType: mime,
       sizeBytes: buf.length,
@@ -68885,13 +69390,13 @@ var DeeplakeFs = class _DeeplakeFs {
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     const text = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
     const buf = Buffer.from(text, "utf-8");
-    const mime = guessMime(basename4(p22));
+    const mime = guessMime(basename5(p22));
     this.files.set(p22, buf);
     this.meta.set(p22, { size: buf.length, mime, mtime: /* @__PURE__ */ new Date() });
     this.addToTree(p22);
     this.pending.set(p22, {
       path: p22,
-      filename: basename4(p22),
+      filename: basename5(p22),
       contentText: text,
       mimeType: mime,
       sizeBytes: buf.length
@@ -68925,10 +69430,33 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     if (p22 === "/index.md")
       return true;
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        return true;
+      const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+      return r10.kind === "ok" || r10.kind === "no-graph";
+    }
     return this.files.has(p22) || this.dirs.has(p22);
   }
   async stat(path2) {
     const p22 = normPath(path2);
+    if (isGraphPath(p22)) {
+      if (!isGraphDir(p22)) {
+        const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+        if (r10.kind === "not-found")
+          throw fsErr("ENOENT", "no such file or directory", p22);
+      }
+      const dir = isGraphDir(p22);
+      return {
+        isFile: !dir,
+        isDirectory: dir,
+        isSymbolicLink: false,
+        mode: dir ? 493 : 420,
+        size: 0,
+        // synthesized; cheaper than computing the body just to size it
+        mtime: /* @__PURE__ */ new Date()
+      };
+    }
     const isFile = this.files.has(p22);
     const isDir = this.dirs.has(p22);
     if (p22 === "/index.md" && !isFile && !isDir) {
@@ -68973,6 +69501,14 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     if (p22 === "/index.md")
       return p22;
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        return p22;
+      const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+      if (r10.kind === "ok" || r10.kind === "no-graph")
+        return p22;
+      throw fsErr("ENOENT", "no such file or directory", p22);
+    }
     if (!this.files.has(p22) && !this.dirs.has(p22))
       throw fsErr("ENOENT", "no such file or directory", p22);
     return p22;
@@ -68996,16 +69532,24 @@ var DeeplakeFs = class _DeeplakeFs {
     const parent = parentOf(p22);
     if (!this.dirs.has(parent))
       this.dirs.set(parent, /* @__PURE__ */ new Set());
-    this.dirs.get(parent).add(basename4(p22));
+    this.dirs.get(parent).add(basename5(p22));
   }
   async readdir(path2) {
     const p22 = normPath(path2);
+    if (p22 === GRAPH_ROOT)
+      return ["index.md", "find", "show"];
+    if (p22 === "/graph/find" || p22 === "/graph/show") {
+      return [];
+    }
     if (!this.dirs.has(p22))
       throw fsErr("ENOTDIR", "not a directory", p22);
     const entries = [...this.dirs.get(p22) ?? []];
     if (p22 === "/" && !entries.includes("index.md")) {
       entries.push("index.md");
     }
+    if (p22 === "/" && !entries.includes("graph")) {
+      entries.push("graph");
+    }
     return entries;
   }
   async readdirWithFileTypes(path2) {
@@ -69013,6 +69557,14 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     return names.map((name) => {
       const child = p22 === "/" ? `/${name}` : `${p22}/${name}`;
+      if (isGraphPath(child)) {
+        return {
+          name,
+          isFile: !isGraphDir(child),
+          isDirectory: isGraphDir(child),
+          isSymbolicLink: false
+        };
+      }
       return {
         name,
         isFile: (this.files.has(child) || child === "/index.md") && !this.dirs.has(child),
@@ -69051,7 +69603,7 @@ var DeeplakeFs = class _DeeplakeFs {
       for (const fp of safeToDelete)
         this.removeFromTree(fp);
       this.dirs.delete(p22);
-      this.dirs.get(parentOf(p22))?.delete(basename4(p22));
+      this.dirs.get(parentOf(p22))?.delete(basename5(p22));
       if (safeToDelete.length > 0) {
         const inList = safeToDelete.map((fp) => `'${sqlStr(fp)}'`).join(", ");
         await this.client.query(`DELETE FROM "${this.table}" WHERE path IN (${inList})`);
@@ -69096,7 +69648,7 @@ var DeeplakeFs = class _DeeplakeFs {
 
 // node_modules/yargs-parser/build/lib/index.js
 import { format } from "util";
-import { normalize, resolve as resolve5 } from "path";
+import { normalize, resolve as resolve6 } from "path";
 
 // node_modules/yargs-parser/build/lib/string-utils.js
 function camelCase2(str) {
@@ -70034,7 +70586,7 @@ function stripQuotes(val) {
 }
 
 // node_modules/yargs-parser/build/lib/index.js
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { createRequire as createRequire2 } from "node:module";
 var _a3;
 var _b;
@@ -70056,12 +70608,12 @@ var parser = new YargsParser({
   },
   format,
   normalize,
-  resolve: resolve5,
+  resolve: resolve6,
   require: (path2) => {
     if (typeof require2 !== "undefined") {
       return require2(path2);
     } else if (path2.match(/\.json$/)) {
-      return JSON.parse(readFileSync7(path2, "utf8"));
+      return JSON.parse(readFileSync10(path2, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -70081,11 +70633,11 @@ var lib_default = yargsParser;
 
 // dist/src/shell/grep-interceptor.js
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname6, join as join13 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 var SEMANTIC_SEARCH_ENABLED = process.env.HIVEMIND_SEMANTIC_SEARCH !== "false" && !embeddingsDisabled();
 var SEMANTIC_EMBED_TIMEOUT_MS = Number(process.env.HIVEMIND_SEMANTIC_EMBED_TIMEOUT_MS ?? "500");
 function resolveGrepEmbedDaemonPath() {
-  return join13(dirname6(fileURLToPath2(import.meta.url)), "..", "embeddings", "embed-daemon.js");
+  return join17(dirname10(fileURLToPath2(import.meta.url)), "..", "embeddings", "embed-daemon.js");
 }
 var sharedGrepEmbedClient = null;
 function getGrepEmbedClient() {