@deeplake/hivemind 0.7.75 → 0.7.77

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

@@ -67672,7 +67672,7 @@ var DeeplakeApi = class {
 };
 
 // dist/src/shell/deeplake-fs.js
-import { basename as basename5, posix } from "node:path";
+import { basename as basename5, posix as posix2 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { dirname as dirname9, join as join16 } from "node:path";
@@ -68822,6 +68822,9 @@ import { dirname as dirname7, join as join14 } from "node:path";
 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/resolve/cross-file.js
+import { posix } from "node:path";
+
 // dist/src/graph/snapshot.js
 function graphsRoot() {
   return process.env.HIVEMIND_GRAPHS_HOME ?? join14(homedir8(), ".hivemind", "graphs");
@@ -68877,6 +68880,513 @@ function deriveProjectKey(cwd) {
   return { key, project };
 }
 
+// dist/src/graph/render/neighborhood.js
+var CAP = 25;
+function renderNeighborhood(snap, file) {
+  const allFiles = [...new Set(snap.nodes.map((n24) => n24.source_file))];
+  let resolved = null;
+  if (allFiles.includes(file)) {
+    resolved = file;
+  } else {
+    const matches = allFiles.filter((f11) => f11.endsWith(file) || f11.includes(file));
+    if (matches.length === 1) {
+      resolved = matches[0];
+    } else if (matches.length > 1) {
+      const lines2 = [];
+      lines2.push(`"${file}" matches multiple files \u2014 which did you mean?`);
+      lines2.push("");
+      for (const m26 of matches.slice(0, 10))
+        lines2.push(`  ${m26}`);
+      if (matches.length > 10)
+        lines2.push(`  ... and ${matches.length - 10} more`);
+      return lines2.join("\n");
+    }
+  }
+  if (resolved === null) {
+    const lines2 = [];
+    lines2.push(`No nodes for "${file}".`);
+    const parts = file.split("/").filter((p22) => p22.length > 2);
+    const close = allFiles.filter((f11) => parts.some((p22) => f11.includes(p22))).slice(0, 3);
+    if (close.length > 0) {
+      lines2.push("Did you mean:");
+      for (const c15 of close)
+        lines2.push(`  ${c15}`);
+    }
+    return lines2.join("\n");
+  }
+  const fileNodes = snap.nodes.filter((n24) => n24.source_file === resolved);
+  const fileNodeIds = new Set(fileNodes.map((n24) => n24.id));
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const n24 of snap.nodes)
+    fileOf.set(n24.id, n24.source_file);
+  const sorted = [...fileNodes].sort((a15, b26) => {
+    const la2 = parseLocation(a15.source_location);
+    const lb = parseLocation(b26.source_location);
+    if (la2 !== lb)
+      return la2 - lb;
+    return a15.label.localeCompare(b26.label);
+  });
+  const lines = [];
+  lines.push(`## Symbols in ${resolved}`);
+  lines.push("");
+  if (sorted.length === 0) {
+    lines.push("  (no symbols)");
+  } else {
+    for (const n24 of sorted) {
+      const exp = n24.exported ? "exported" : "internal";
+      lines.push(`  ${n24.label.padEnd(32)} ${n24.kind.padEnd(12)} ${exp.padEnd(10)} ${n24.source_location}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Cross-file neighbors");
+  lines.push("");
+  lines.push("Note: 'calls' edges are intra-file only in the current extractor \u2014 cross-file");
+  lines.push("neighbors here are driven mainly by 'imports' edges.");
+  lines.push("");
+  const outgoing = [];
+  const incoming = [];
+  for (const e6 of snap.links) {
+    const srcIn = fileNodeIds.has(e6.source);
+    const tgtIn = fileNodeIds.has(e6.target);
+    if (srcIn === tgtIn)
+      continue;
+    if (srcIn) {
+      const tgtFile = fileOf.get(e6.target);
+      if (tgtFile !== void 0 && tgtFile !== resolved)
+        outgoing.push(e6);
+    } else {
+      const srcFile = fileOf.get(e6.source);
+      if (srcFile !== void 0 && srcFile !== resolved)
+        incoming.push(e6);
+    }
+  }
+  renderDirectionGroup(lines, outgoing, "Outgoing", "source");
+  renderDirectionGroup(lines, incoming, "Incoming", "target");
+  return lines.join("\n");
+}
+function renderDirectionGroup(lines, edges, label, selfField) {
+  const otherField = selfField === "source" ? "target" : "source";
+  const byRelation = /* @__PURE__ */ new Map();
+  for (const e6 of edges) {
+    const otherId = e6[otherField];
+    const rel = e6.relation;
+    let nodeMap = byRelation.get(rel);
+    if (!nodeMap) {
+      nodeMap = /* @__PURE__ */ new Map();
+      byRelation.set(rel, nodeMap);
+    }
+    nodeMap.set(otherId, (nodeMap.get(otherId) ?? 0) + 1);
+  }
+  if (byRelation.size === 0) {
+    lines.push(`${label}: (none)`);
+    lines.push("");
+    return;
+  }
+  lines.push(`${label}:`);
+  let totalShown = 0;
+  const sortedRels = [...byRelation.entries()].sort(([a15], [b26]) => a15.localeCompare(b26));
+  for (const [rel, nodeMap] of sortedRels) {
+    const entries = [...nodeMap.entries()].sort(([a15], [b26]) => a15.localeCompare(b26));
+    lines.push(`  ${rel} (${entries.length}):`);
+    let shownInRel = 0;
+    for (const [otherId, cnt] of entries) {
+      if (totalShown >= CAP)
+        break;
+      const suffix = cnt > 1 ? ` \xD7${cnt}` : "";
+      lines.push(`    ${otherId}${suffix}`);
+      shownInRel++;
+      totalShown++;
+    }
+    const remaining = entries.length - shownInRel;
+    if (remaining > 0)
+      lines.push(`    ... and ${remaining} more`);
+  }
+  if (totalShown >= CAP) {
+    const total = [...byRelation.values()].reduce((s10, m26) => s10 + m26.size, 0);
+    if (total > CAP)
+      lines.push(`  ... and ${total - CAP} more`);
+  }
+  lines.push("");
+}
+function parseLocation(loc) {
+  const m26 = loc.match(/^L(\d+)/);
+  return m26 ? parseInt(m26[1], 10) : 0;
+}
+
+// dist/src/graph/render/layers.js
+var LAYER_RULES = [
+  { layer: "Tests", test: (p22) => p22.includes("/tests/") || p22.includes(".test.") || p22.includes("/__tests__/") },
+  { layer: "Hooks", test: (p22) => p22.includes("/hooks/") },
+  { layer: "CLI", test: (p22) => p22.includes("/cli/") || p22.includes("/commands/") },
+  { layer: "Graph", test: (p22) => p22.includes("/graph/") },
+  { layer: "Shell/VFS", test: (p22) => p22.includes("/shell/") },
+  { layer: "Embeddings", test: (p22) => p22.includes("/embeddings/") },
+  { layer: "Skillify", test: (p22) => p22.includes("/skillify/") },
+  { layer: "Config", test: (p22) => /(?:^|\/)config\.[^/]+$/.test(p22) || /\.config\.[^/]+$/.test(p22) },
+  { layer: "Utils", test: (p22) => p22.includes("/utils/") }
+];
+function layerOf(sourceFile) {
+  const p22 = sourceFile.startsWith("/") ? sourceFile : `/${sourceFile}`;
+  for (const rule of LAYER_RULES) {
+    if (rule.test(p22))
+      return rule.layer;
+  }
+  return "Core";
+}
+function renderLayers(snap) {
+  try {
+    const layerNodes = /* @__PURE__ */ new Map();
+    const layerFiles = /* @__PURE__ */ new Map();
+    for (const node of snap.nodes) {
+      const layer = layerOf(node.source_file);
+      layerNodes.set(layer, (layerNodes.get(layer) ?? 0) + 1);
+      let fileMap = layerFiles.get(layer);
+      if (!fileMap) {
+        fileMap = /* @__PURE__ */ new Map();
+        layerFiles.set(layer, fileMap);
+      }
+      fileMap.set(node.source_file, (fileMap.get(node.source_file) ?? 0) + 1);
+    }
+    if (layerNodes.size === 0) {
+      return "No nodes in snapshot \u2014 nothing to layer.";
+    }
+    const sorted = [...layerNodes.entries()].sort(([, a15], [, b26]) => b26 - a15);
+    const lines = [];
+    lines.push("## Architectural Layers");
+    lines.push("");
+    for (const [layer, count] of sorted) {
+      lines.push(`${layer.padEnd(14)} ${String(count).padStart(4)} node${count === 1 ? "" : "s"}`);
+      const fileMap = layerFiles.get(layer);
+      const topFiles = [...fileMap.entries()].sort(([, a15], [, b26]) => b26 - a15).slice(0, 5);
+      for (const [file, n24] of topFiles) {
+        lines.push(`  ${String(n24).padStart(3)}  ${file}`);
+      }
+      if (fileMap.size > 5) {
+        lines.push(`       ... and ${fileMap.size - 5} more file${fileMap.size - 5 === 1 ? "" : "s"}`);
+      }
+    }
+    lines.push("");
+    lines.push(`Total: ${snap.nodes.length} node${snap.nodes.length === 1 ? "" : "s"} across ${sorted.length} layer${sorted.length === 1 ? "" : "s"}`);
+    return lines.join("\n");
+  } catch {
+    return "Failed to render layer view.";
+  }
+}
+
+// dist/src/graph/render/tour.js
+var LINE_CAP = 60;
+function renderTour(snap) {
+  if (snap.nodes.length === 0) {
+    return "Graph is empty \u2014 no nodes to tour.";
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n24 of snap.nodes)
+    nodeMap.set(n24.id, n24);
+  const inDegOrig = /* @__PURE__ */ new Map();
+  for (const n24 of snap.nodes)
+    inDegOrig.set(n24.id, 0);
+  for (const e6 of snap.links) {
+    if (nodeMap.has(e6.source) && nodeMap.has(e6.target)) {
+      inDegOrig.set(e6.target, (inDegOrig.get(e6.target) ?? 0) + 1);
+    }
+  }
+  const entryPoints = snap.nodes.filter((n24) => n24.exported && inDegOrig.get(n24.id) === 0).sort((a15, b26) => a15.id.localeCompare(b26.id));
+  const entrySet = new Set(entryPoints.map((n24) => n24.id));
+  const revAdj = /* @__PURE__ */ new Map();
+  const inDegRev = /* @__PURE__ */ new Map();
+  for (const n24 of snap.nodes) {
+    revAdj.set(n24.id, []);
+    inDegRev.set(n24.id, 0);
+  }
+  for (const e6 of snap.links) {
+    if (!nodeMap.has(e6.source) || !nodeMap.has(e6.target))
+      continue;
+    revAdj.get(e6.target).push(e6.source);
+    inDegRev.set(e6.source, (inDegRev.get(e6.source) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const n24 of snap.nodes) {
+    if (inDegRev.get(n24.id) === 0)
+      queue.push(n24.id);
+  }
+  queue.sort();
+  const topoOrder = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    topoOrder.push(id);
+    const newReady = [];
+    for (const dep of revAdj.get(id) ?? []) {
+      const d15 = (inDegRev.get(dep) ?? 0) - 1;
+      inDegRev.set(dep, d15);
+      if (d15 === 0)
+        newReady.push(dep);
+    }
+    if (newReady.length > 0) {
+      for (const x28 of newReady)
+        queue.push(x28);
+      queue.sort();
+    }
+  }
+  const topoSet = new Set(topoOrder);
+  const cyclic = snap.nodes.filter((n24) => !topoSet.has(n24.id)).sort((a15, b26) => a15.id.localeCompare(b26.id));
+  const walkthrough = topoOrder.filter((id) => !entrySet.has(id));
+  const totalNodes = snap.nodes.length;
+  const lines = [];
+  lines.push(`# Code Graph Tour \u2014 ${totalNodes} node${totalNodes !== 1 ? "s" : ""}`);
+  lines.push("");
+  lines.push(`## Entry points (${entryPoints.length})`);
+  if (entryPoints.length === 0) {
+    lines.push("  (none \u2014 all exported nodes have at least one incoming edge)");
+  } else {
+    lines.push("  Exported symbols with no incoming edges \u2014 likely top-level public API.");
+    lines.push("");
+    for (let i11 = 0; i11 < entryPoints.length; i11++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${entryPoints.length - i11} more`);
+        break;
+      }
+      lines.push(`  ${i11 + 1}. ${entryPoints[i11].id}  [${entryPoints[i11].kind}]`);
+    }
+  }
+  lines.push("");
+  lines.push(`## Walkthrough \u2014 dependency order (${walkthrough.length})`);
+  if (walkthrough.length === 0) {
+    lines.push("  (all non-entry nodes are cyclic)");
+  } else {
+    lines.push("  Dependencies before dependents (bottom-up).");
+    lines.push("");
+    for (let i11 = 0; i11 < walkthrough.length; i11++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${walkthrough.length - i11} more`);
+        break;
+      }
+      const n24 = nodeMap.get(walkthrough[i11]);
+      lines.push(`  ${i11 + 1}. ${n24.id}  [${n24.kind}]`);
+    }
+  }
+  lines.push("");
+  if (cyclic.length > 0) {
+    lines.push(`## Cyclic / remaining (${cyclic.length})`);
+    lines.push("  These nodes form cycles and were not reached by topological sort.");
+    lines.push("");
+    for (let i11 = 0; i11 < cyclic.length; i11++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${cyclic.length - i11} more`);
+        break;
+      }
+      lines.push(`  ${i11 + 1}. ${cyclic[i11].id}  [${cyclic[i11].kind}]`);
+    }
+    lines.push("");
+  }
+  lines.push(`Total: ${entryPoints.length} entry + ${walkthrough.length} walkthrough` + (cyclic.length > 0 ? ` + ${cyclic.length} cyclic` : "") + ` = ${totalNodes} nodes`);
+  return lines.join("\n");
+}
+
+// dist/src/graph/render/path.js
+function resolvePattern(snap, pattern) {
+  const needle = pattern.toLowerCase();
+  return snap.nodes.filter((n24) => n24.id.toLowerCase().includes(needle) || n24.label.toLowerCase().includes(needle)).map((n24) => n24.id).sort();
+}
+function buildAdjacency(snap, undirected) {
+  const adj = /* @__PURE__ */ new Map();
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const n24 of snap.nodes) {
+    adj.set(n24.id, []);
+    nodeIds.add(n24.id);
+  }
+  for (const edge of snap.links) {
+    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target))
+      continue;
+    adj.get(edge.source).push({ neighborId: edge.target, edge, reversed: false });
+    if (undirected) {
+      adj.get(edge.target).push({ neighborId: edge.source, edge, reversed: true });
+    }
+  }
+  for (const neighbors of adj.values()) {
+    neighbors.sort((a15, b26) => a15.neighborId.localeCompare(b26.neighborId) || a15.edge.relation.localeCompare(b26.edge.relation) || (a15.reversed === b26.reversed ? 0 : a15.reversed ? 1 : -1));
+  }
+  return adj;
+}
+function bfs(adj, fromId, toId) {
+  if (fromId === toId)
+    return [];
+  const parent = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  const queue = [fromId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const { neighborId, edge, reversed } of adj.get(current) ?? []) {
+      if (visited.has(neighborId))
+        continue;
+      visited.add(neighborId);
+      parent.set(neighborId, { parentId: current, hop: { edge, reversed } });
+      if (neighborId === toId) {
+        const hops = [];
+        let cur = toId;
+        while (cur !== fromId) {
+          const p22 = parent.get(cur);
+          hops.unshift(p22.hop);
+          cur = p22.parentId;
+        }
+        return hops;
+      }
+      queue.push(neighborId);
+    }
+  }
+  return null;
+}
+function renderHops(fromId, hops, undirected) {
+  const lines = [];
+  lines.push(`${undirected ? "Undirected path" : "Directed path"}  (${hops.length} hop${hops.length === 1 ? "" : "s"}):`);
+  lines.push("");
+  lines.push(`  ${fromId}`);
+  for (const { edge, reversed } of hops) {
+    if (reversed) {
+      lines.push(`    <--${edge.relation}--  ${edge.source}  [real edge: ${edge.source} \u2192 ${edge.target}]`);
+    } else {
+      lines.push(`    --${edge.relation}-->  ${edge.target}`);
+    }
+  }
+  if (undirected) {
+    lines.push("");
+    lines.push("Note: no directed path exists. Arrows with <-- are traversed against their declared direction.");
+  }
+  return lines.join("\n");
+}
+function candidateList(pattern, ids) {
+  const lines = [`"${pattern}" matches ${ids.length} nodes \u2014 be more specific:`];
+  lines.push("");
+  const shown = ids.slice(0, 20);
+  for (let i11 = 0; i11 < shown.length; i11++)
+    lines.push(`  [${i11 + 1}]  ${shown[i11]}`);
+  if (ids.length > 20)
+    lines.push(`  ... and ${ids.length - 20} more`);
+  return lines.join("\n");
+}
+function renderPath(snap, fromPattern, toPattern) {
+  const fromIds = resolvePattern(snap, fromPattern);
+  const toIds = resolvePattern(snap, toPattern);
+  if (fromIds.length === 0) {
+    return `No node matches "${fromPattern}". Try cat memory/graph/find/<pattern> to explore.`;
+  }
+  if (toIds.length === 0) {
+    return `No node matches "${toPattern}". Try cat memory/graph/find/<pattern> to explore.`;
+  }
+  if (fromIds.length > 1)
+    return candidateList(fromPattern, fromIds);
+  if (toIds.length > 1)
+    return candidateList(toPattern, toIds);
+  const fromId = fromIds[0];
+  const toId = toIds[0];
+  if (fromId === toId) {
+    return `"${fromId}" is the same node on both ends \u2014 path length 0.`;
+  }
+  const dirPath = bfs(buildAdjacency(snap, false), fromId, toId);
+  if (dirPath !== null)
+    return renderHops(fromId, dirPath, false);
+  const undirPath = bfs(buildAdjacency(snap, true), fromId, toId);
+  if (undirPath !== null)
+    return renderHops(fromId, undirPath, true);
+  const fromNode = snap.nodes.find((n24) => n24.id === fromId);
+  const toNode = snap.nodes.find((n24) => n24.id === toId);
+  const sameFile = fromNode && toNode && fromNode.source_file === toNode.source_file;
+  const context = sameFile ? `Both are in ${fromNode.source_file} \u2014 same file but no connecting edges.` : `Sources: ${fromNode?.source_file ?? "?"} vs ${toNode?.source_file ?? "?"} \u2014 they appear disconnected.`;
+  return [`No path found between:`, `  from: ${fromId}`, `  to:   ${toId}`, ``, context].join("\n");
+}
+
+// dist/src/graph/render/impact.js
+var IMPACT_CAP = 80;
+var MAX_DEPTH = 25;
+function renderImpact(snap, pattern) {
+  const needle = pattern.toLowerCase();
+  const matches = snap.nodes.filter((n24) => n24.id.toLowerCase().includes(needle));
+  if (matches.length === 0) {
+    return `No node matches "${pattern}". Try cat memory/graph/find/${pattern} to explore.`;
+  }
+  if (matches.length > 1) {
+    const lines2 = [`"${pattern}" matches ${matches.length} nodes \u2014 be more specific:`, ""];
+    for (const m26 of matches.slice(0, 20))
+      lines2.push(`  ${m26.id}`);
+    if (matches.length > 20)
+      lines2.push(`  ... and ${matches.length - 20} more`);
+    return lines2.join("\n");
+  }
+  const target = matches[0];
+  const nodeIds = new Set(snap.nodes.map((n24) => n24.id));
+  const incoming = /* @__PURE__ */ new Map();
+  for (const e6 of snap.links) {
+    if (!nodeIds.has(e6.source))
+      continue;
+    const list = incoming.get(e6.target);
+    if (list)
+      list.push(e6);
+    else
+      incoming.set(e6.target, [e6]);
+  }
+  const depthOf = /* @__PURE__ */ new Map();
+  const viaOf = /* @__PURE__ */ new Map();
+  depthOf.set(target.id, 0);
+  let frontier = [target.id];
+  let depth = 0;
+  while (frontier.length > 0 && depth < MAX_DEPTH) {
+    depth++;
+    const next = [];
+    for (const id of frontier) {
+      const edges = (incoming.get(id) ?? []).slice().sort((a15, b26) => a15.source.localeCompare(b26.source) || a15.relation.localeCompare(b26.relation));
+      for (const e6 of edges) {
+        if (depthOf.has(e6.source))
+          continue;
+        depthOf.set(e6.source, depth);
+        viaOf.set(e6.source, { rel: e6.relation, from: id });
+        next.push(e6.source);
+      }
+    }
+    next.sort();
+    frontier = next;
+  }
+  const dependents = [...depthOf.entries()].filter(([id]) => id !== target.id);
+  const total = dependents.length;
+  const lines = [];
+  lines.push(`Impact of ${target.id}`);
+  if (target.signature)
+    lines.push(`  ${target.signature}`);
+  lines.push("");
+  if (total === 0) {
+    lines.push("No resolved dependents \u2014 nothing in the graph reaches this symbol.");
+    lines.push("(Cross-file resolution is partial; this is a lower bound, not proof it's unused.)");
+    return lines.join("\n");
+  }
+  lines.push(`${total} dependent${total === 1 ? "" : "s"} (transitive), by depth:`);
+  lines.push("");
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const [id, d15] of dependents) {
+    const list = byDepth.get(d15) ?? [];
+    list.push(id);
+    byDepth.set(d15, list);
+  }
+  let shown = 0;
+  for (const d15 of [...byDepth.keys()].sort((a15, b26) => a15 - b26)) {
+    const ids = byDepth.get(d15).sort();
+    lines.push(`  depth ${d15} (${ids.length}):`);
+    for (const id of ids) {
+      if (shown >= IMPACT_CAP)
+        break;
+      const via = viaOf.get(id);
+      const tag = via ? `  [${via.rel} \u2192 ${via.from}]` : "";
+      lines.push(`    ${id}${tag}`);
+      shown++;
+    }
+    if (shown >= IMPACT_CAP)
+      break;
+  }
+  if (total > shown)
+    lines.push(`  ... and ${total - shown} more`);
+  lines.push("");
+  lines.push("Note: only RESOLVED edges are traversed (cross-file resolution is partial),");
+  lines.push("so this is a lower bound on impact, not a completeness guarantee.");
+  return lines.join("\n");
+}
+
 // dist/src/graph/vfs-handler.js
 function workTreeIdFor(cwd) {
   return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
@@ -68912,10 +69422,50 @@ function handleGraphVfs(subpath, cwd) {
       body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
     }));
   }
+  if (path2.startsWith("query/")) {
+    const pattern = path2.slice("query/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "query/ requires a pattern: cat memory/graph/query/<keyword>" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderQuery(snap, pattern, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path2.startsWith("impact/")) {
+    const pattern = path2.slice("impact/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "impact/ requires a pattern: cat memory/graph/impact/<symbol>" };
+    }
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderImpact(snap, pattern) }));
+  }
+  if (path2.startsWith("neighborhood/")) {
+    const file = path2.slice("neighborhood/".length);
+    if (file === "") {
+      return { kind: "not-found", message: "neighborhood/ requires a file path: cat memory/graph/neighborhood/<file>" };
+    }
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderNeighborhood(snap, file) }));
+  }
+  if (path2 === "layers" || path2 === "layers/" || path2 === "layers/index.md") {
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderLayers(snap) }));
+  }
+  if (path2 === "tour" || path2 === "tour/" || path2 === "tour/index.md") {
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderTour(snap) }));
+  }
+  if (path2.startsWith("path/")) {
+    const rest = path2.slice("path/".length);
+    const slash = rest.indexOf("/");
+    if (slash <= 0 || slash === rest.length - 1) {
+      return { kind: "not-found", message: "path/ needs two patterns: cat memory/graph/path/<from>/<to> (each a symbol-name substring, no slash)" };
+    }
+    const fromPattern = rest.slice(0, slash);
+    const toPattern = rest.slice(slash + 1);
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderPath(snap, fromPattern, toPattern) }));
+  }
   return {
     kind: "not-found",
     message: `Unknown endpoint: graph/${path2}
-Available: index.md, find/<pattern>, show/<handle-or-pattern>`
+Available: index.md, find/<pattern>, query/<pattern>, show/<handle-or-pattern>, impact/<pattern>, neighborhood/<file>, layers, tour, path/<from>/<to>`
   };
 }
 function loadSnapshotOrError(cwd, fn4) {
@@ -68959,7 +69509,13 @@ function dirListing() {
   return [
     "index.md",
     "find/",
-    "show/"
+    "query/",
+    "show/",
+    "impact/",
+    "neighborhood/",
+    "layers",
+    "tour",
+    "path/"
   ].join("\n");
 }
 function renderIndex(snap, baseDir, cwd) {
@@ -68987,16 +69543,23 @@ function renderIndex(snap, baseDir, cwd) {
   lines.push(`Nodes:   ${totalNodes}    Edges: ${totalEdges}`);
   lines.push("");
   lines.push("## How to query");
+  lines.push("  cat ~/.deeplake/memory/graph/query/<pattern>");
+  lines.push("    2-in-1: search + expand the top matches with their 1-hop");
+  lines.push("    neighbors (callers/callees/imports/heritage). Start here.");
+  lines.push("    Multi-token AND: query/<a>+<b> requires both tokens.");
+  lines.push("");
   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("    <handle>: a digit from a prior `find/`/`query/` (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("  Also: neighborhood/<file> \xB7 layers \xB7 tour \xB7 path/<from>/<to>");
+  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}`);
@@ -69013,31 +69576,92 @@ function renderIndex(snap, baseDir, cwd) {
   }
   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(`  - TypeScript / JavaScript / Python. AST-based, no semantic similarity edges yet.`);
+  lines.push(`  - Cross-file 'calls'/'imports'/'extends' ARE resolved for relative named/namespace`);
+  lines.push(`    imports; bare (npm)/aliased/barrel/dynamic imports stay unresolved. So a node`);
+  lines.push(`    with "Incoming (0)" is not proof of dead code \u2014 a caller may reach it via an`);
+  lines.push(`    unresolved import path. (Python cross-file resolution is a follow-up; Python is`);
+  lines.push(`    intra-file + structure only for now.)`);
   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();
+function findMatches(snap, pattern) {
+  const tokens = pattern.toLowerCase().split(/[\s+]+/).filter((t6) => t6.length > 0);
+  if (tokens.length === 0)
+    return [];
+  if (tokens.length === 1) {
+    const needle = tokens[0];
+    const matches2 = [];
+    for (const n24 of snap.nodes) {
+      if (n24.id.toLowerCase().includes(needle) || n24.label.toLowerCase().includes(needle))
+        matches2.push(n24);
+    }
+    matches2.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);
+    });
+    if (matches2.length === 0)
+      return fuzzyMatches(snap, needle);
+    return matches2;
+  }
   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))
+    if (tokens.every((t6) => id.includes(t6) || lbl.includes(t6)))
       matches.push(n24);
   }
+  const score = (n24) => tokens.reduce((s10, t6) => s10 + rank(n24, t6), 0);
   matches.sort((a15, b26) => {
-    const ra2 = rank(a15, needle);
-    const rb = rank(b26, needle);
-    if (ra2 !== rb)
-      return ra2 - rb;
+    const sa2 = score(a15);
+    const sb = score(b26);
+    if (sa2 !== sb)
+      return sa2 - sb;
     return a15.id.localeCompare(b26.id);
   });
+  return matches;
+}
+function fuzzyMatches(snap, needle) {
+  if (needle.length < 3)
+    return [];
+  const maxDist = Math.max(1, Math.floor(needle.length / 4));
+  const scored = [];
+  for (const n24 of snap.nodes) {
+    const d15 = editDistance(needle, n24.label.toLowerCase(), maxDist);
+    if (d15 <= maxDist)
+      scored.push({ n: n24, d: d15 });
+  }
+  scored.sort((a15, b26) => a15.d !== b26.d ? a15.d - b26.d : a15.n.id.localeCompare(b26.n.id));
+  return scored.slice(0, 25).map((s10) => s10.n);
+}
+function editDistance(a15, b26, cap) {
+  if (Math.abs(a15.length - b26.length) > cap)
+    return cap + 1;
+  let prev = new Array(b26.length + 1);
+  let cur = new Array(b26.length + 1);
+  for (let j14 = 0; j14 <= b26.length; j14++)
+    prev[j14] = j14;
+  for (let i11 = 1; i11 <= a15.length; i11++) {
+    cur[0] = i11;
+    let rowMin = cur[0];
+    for (let j14 = 1; j14 <= b26.length; j14++) {
+      const cost = a15[i11 - 1] === b26[j14 - 1] ? 0 : 1;
+      cur[j14] = Math.min(prev[j14] + 1, cur[j14 - 1] + 1, prev[j14 - 1] + cost);
+      if (cur[j14] < rowMin)
+        rowMin = cur[j14];
+    }
+    if (rowMin > cap)
+      return cap + 1;
+    [prev, cur] = [cur, prev];
+  }
+  return prev[b26.length];
+}
+function renderFind(snap, pattern, baseDir, worktreeId) {
+  const matches = findMatches(snap, pattern);
   const capped = matches.slice(0, 50);
   if (capped.length === 0) {
     return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
@@ -69056,6 +69680,76 @@ Try a shorter or different substring.`;
   lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> to see node + 1-hop neighbors");
   return lines.join("\n");
 }
+var QUERY_TOP_N = 5;
+var QUERY_NEIGHBOR_CAP = 8;
+function renderQuery(snap, pattern, baseDir, worktreeId) {
+  const matches = findMatches(snap, pattern);
+  if (matches.length === 0) {
+    return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
+Try a shorter or different substring, or cat memory/graph/find/<pattern>.`;
+  }
+  const top = matches.slice(0, QUERY_TOP_N);
+  saveHandles(baseDir, worktreeId, top.map((n24) => n24.id), pattern);
+  const topIds = new Set(top.map((n24) => n24.id));
+  const outByNode = /* @__PURE__ */ new Map();
+  const inByNode = /* @__PURE__ */ new Map();
+  for (const e6 of snap.links) {
+    if (topIds.has(e6.source))
+      (outByNode.get(e6.source) ?? setGet(outByNode, e6.source)).push(e6);
+    if (topIds.has(e6.target))
+      (inByNode.get(e6.target) ?? setGet(inByNode, e6.target)).push(e6);
+  }
+  const lines = [];
+  lines.push(`Query "${pattern}" \u2014 ${matches.length} match${matches.length === 1 ? "" : "es"}, expanded top ${top.length} (1 hop)`);
+  lines.push("");
+  for (let i11 = 0; i11 < top.length; i11++) {
+    const n24 = top[i11];
+    const tags = [n24.exported ? "exported" : "internal"];
+    if (n24.is_entrypoint)
+      tags.push("entrypoint");
+    if (n24.fan_in !== void 0)
+      tags.push(`fan_in=${n24.fan_in}`);
+    if (n24.fan_out !== void 0)
+      tags.push(`fan_out=${n24.fan_out}`);
+    lines.push(`[${i11 + 1}] ${n24.id}  ${n24.kind} (${tags.join(", ")})`);
+    if (n24.signature)
+      lines.push(`      ${n24.signature}`);
+    renderHopGroup(lines, outByNode.get(n24.id) ?? [], "OUT", "target");
+    renderHopGroup(lines, inByNode.get(n24.id) ?? [], "IN", "source");
+    lines.push("");
+  }
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> for full detail on a match.");
+  return lines.join("\n");
+}
+function setGet(m26, key) {
+  const list = [];
+  m26.set(key, list);
+  return list;
+}
+function renderHopGroup(lines, edges, dir, otherField) {
+  if (edges.length === 0)
+    return;
+  const byRel = /* @__PURE__ */ new Map();
+  for (const e6 of edges) {
+    let counts = byRel.get(e6.relation);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      byRel.set(e6.relation, counts);
+    }
+    const id = e6[otherField];
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  for (const [rel, counts] of [...byRel.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
+    const arrow = dir === "OUT" ? `--${rel}-->` : `<--${rel}--`;
+    const ids = [...counts.keys()].sort();
+    const shown = ids.slice(0, QUERY_NEIGHBOR_CAP).map((id) => {
+      const c15 = counts.get(id);
+      return c15 > 1 ? `${id} \xD7${c15}` : id;
+    });
+    const more = ids.length > shown.length ? `  (+${ids.length - shown.length} more)` : "";
+    lines.push(`      ${arrow} ${shown.join(", ")}${more}`);
+  }
+}
 function renderShow(snap, key, baseDir, worktreeId) {
   if (/^\d+$/.test(key)) {
     const idx = parseInt(key, 10);
@@ -69117,9 +69811,20 @@ function renderNodeDetail(snap, node) {
   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"}`);
+  if (node.signature)
+    lines.push(`  sig:    ${node.signature}`);
+  if (node.doc)
+    lines.push(`  doc:    ${node.doc}`);
+  const tags = [node.exported ? "exported" : "internal"];
+  if (node.is_entrypoint)
+    tags.push("entrypoint");
+  if (node.fan_in !== void 0)
+    tags.push(`fan_in=${node.fan_in}`);
+  if (node.fan_out !== void 0)
+    tags.push(`fan_out=${node.fan_out}`);
+  lines.push(`  ${tags.join("  ")}`);
   lines.push("");
-  const inHint = incoming.length === 0 ? "  \u2014 no edges from THIS file (intra-file only; may still be called from other files)" : ":";
+  const inHint = incoming.length === 0 ? "  \u2014 no resolved callers (cross-file resolution is partial; not proof of dead code)" : ":";
   lines.push(`Incoming (${incoming.length})${inHint}`);
   for (const [rel, es3] of [...inGrp.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
     lines.push(`  ${rel} (${es3.length}):`);
@@ -69196,7 +69901,7 @@ var BATCH_SIZE = 10;
 var PREFETCH_BATCH_SIZE = 50;
 var FLUSH_DEBOUNCE_MS = 200;
 function normPath(p22) {
-  const r10 = posix.normalize(p22.startsWith("/") ? p22 : "/" + p22);
+  const r10 = posix2.normalize(p22.startsWith("/") ? p22 : "/" + p22);
   return r10 === "/" ? r10 : r10.replace(/\/$/, "");
 }
 function parentOf(p22) {
@@ -70045,7 +70750,7 @@ var DeeplakeFs = class _DeeplakeFs {
   resolvePath(base, path2) {
     if (path2.startsWith("/"))
       return normPath(path2);
-    return normPath(posix.join(base, path2));
+    return normPath(posix2.join(base, path2));
   }
   getAllPaths() {
     return [.../* @__PURE__ */ new Set([...this.files.keys(), ...this.dirs.keys()])];