flavor-code 1.4.0-beta.1 → 1.4.0-beta.4

package/dist/astgraph/index.js

@@ -1,301 +0,0 @@
-// astgraph flavor-code plugin — codegraph-style code graph for precise navigation.
-//
-// Registers:
-//   command  /ast            init | sync | status | search | impact | callers | callees | context | help
-//   tools    ast_search / ast_callers / ast_callees / ast_impact / ast_context
-//   hooks    SessionStart (cache workspace), PostToolUse (incremental sync after edits)
-//
-// Heavy lifting is lazy: activation only registers handlers so it stays well
-// inside the host's activation timeout; WASM grammars and the database load on
-// first use.
-
-import { existsSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
-
-import { z } from "./vendor/zod/index.js";
-
-const ALLOW = Object.freeze({ decision: "allow" });
-
-function workspaceFrom(event) {
-  const workspace = event?.payload?.workspace;
-  if (typeof workspace === "string" && workspace.length > 0) return workspace;
-  return undefined;
-}
-
-function dbPath(root) {
-  return join(root, ".flavor", "astgraph", "index.db");
-}
-
-async function mod(name) {
-  return import(new URL(`./${name}`, import.meta.url).href);
-}
-
-/** Open the graph database when it exists; otherwise undefined (not indexed yet). */
-async function openIndex(root) {
-  const path = dbPath(root);
-  if (!existsSync(path)) return undefined;
-  const { openDb } = await mod("db.mjs");
-  return { db: openDb(path), path };
-}
-
-function workspaceRelative(root, path) {
-  if (path === undefined) return undefined;
-  const candidate = isAbsolute(path) ? relative(root, path) : path;
-  return candidate.split("\\").join("/").replace(/^\.\//, "");
-}
-
-async function runIndex(root, options = {}) {
-  const { openDb } = await mod("db.mjs");
-  const { indexProject } = await mod("indexer.mjs");
-  const db = openDb(dbPath(root));
-  try {
-    return await indexProject(root, { db, ...options });
-  } finally {
-    db.close();
-  }
-}
-
-const HELP = {
-  usage: [
-    "/ast init                Build the full code graph (.flavor/astgraph/index.db)",
-    "/ast sync [path...]      Incrementally re-index (defaults to changed files only)",
-    "/ast status              Show graph statistics",
-    "/ast search <query>      Find anchor symbols (FTS + identifier segments)",
-    "/ast callers <node-id>   Who calls this node",
-    "/ast callees <node-id>   What this node calls",
-    "/ast impact <node-id> [--hops N] [--direction up|down|both]  Blast radius",
-    "/ast context <node-id> [--hops N]  Precise file:line read ranges around a node",
-  ],
-  hint: "Node ids look like 'src/order.ts#cancelOrder'. Agent tools: ast_search, ast_callers, ast_callees, ast_impact, ast_context.",
-};
-
-async function commandAst(args, context) {
-  const root = context.workspace;
-  const [sub, ...rest] = args;
-  switch (sub) {
-    case undefined:
-    case "help":
-      return HELP;
-    case "init": {
-      const result = await runIndex(root);
-      return { command: "init", workspace: root, db: dbPath(root), ...result };
-    }
-    case "sync": {
-      const onlyPaths = rest.map((path) => workspaceRelative(root, path)).filter((path) => path !== undefined);
-      const result = await runIndex(root, onlyPaths.length > 0 ? { onlyPaths } : {});
-      return { command: "sync", ...result };
-    }
-    case "status": {
-      const index = await openIndex(root);
-      if (index === undefined) return { command: "status", indexed: false, hint: "Run /ast init first." };
-      try {
-        const { stats, getMetadata } = await mod("db.mjs");
-        const lastIndex = getMetadata(index.db, "last_index");
-        return { command: "status", indexed: true, db: index.path, ...stats(index.db), lastIndex: lastIndex === undefined ? undefined : JSON.parse(lastIndex) };
-      } finally {
-        index.db.close();
-      }
-    }
-    default: {
-      const nodeId = rest[0];
-      if (["search", "callers", "callees", "impact", "context"].includes(sub) && (sub === "search" ? rest.length === 0 : nodeId === undefined)) {
-        return { command: sub, error: `Missing ${sub === "search" ? "query" : "node id"}. See /ast help.` };
-      }
-      const index = await openIndex(root);
-      if (index === undefined) return { command: sub, error: "Graph not built. Run /ast init first." };
-      try {
-        const { search, callers, callees, impact, subgraphContext, getNode } = await mod("query.mjs");
-        if (sub === "search") return { command: sub, query: rest.join(" "), results: search(index.db, rest.join(" ")) };
-        const anchor = getNode(index.db, nodeId);
-        if (anchor === undefined) return { command: sub, error: `Unknown node id "${nodeId}". Use /ast search to find anchors.` };
-        if (sub === "callers") return { command: sub, node: anchor, callers: callers(index.db, nodeId) };
-        if (sub === "callees") return { command: sub, node: anchor, callees: callees(index.db, nodeId) };
-        const hops = Math.min(5, Math.max(1, parseFlag(rest, "--hops", 2)));
-        const direction = parseStringFlag(rest, "--direction", "up");
-        if (sub === "impact") return { command: sub, ...impact(index.db, nodeId, { hops, direction: ["up", "down", "both"].includes(direction) ? direction : "up" }) };
-        return { command: "context", ...subgraphContext(index.db, nodeId, { hops }) };
-      } finally {
-        index.db.close();
-      }
-    }
-  }
-}
-
-function parseFlag(args, name, fallback) {
-  const index = args.indexOf(name);
-  if (index < 0) return fallback;
-  const value = Number(args[index + 1]);
-  return Number.isFinite(value) ? value : fallback;
-}
-
-function parseStringFlag(args, name, fallback) {
-  const index = args.indexOf(name);
-  return index < 0 ? fallback : args[index + 1] ?? fallback;
-}
-
-// Numeric fields use z.coerce so providers that serialize numbers as JSON
-// strings ("10" instead of 10) still validate without a repair round-trip.
-const boundedInt = (min, max) => z.coerce.number().int().min(min).max(max).optional();
-
-function toolSchemas() {
-  const nodeInput = z.object({
-    id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder' (find with ast_search)"),
-  });
-  return {
-    ast_search: z.object({
-      query: z.string().describe("Natural-language or symbol keywords, e.g. '订单 取消' or 'cancelOrder'"),
-      limit: boundedInt(1, 50).describe("Max results (default 10)"),
-    }),
-    ast_callers: nodeInput,
-    ast_callees: nodeInput,
-    ast_impact: z.object({
-      id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder'"),
-      hops: boundedInt(1, 5).describe("Traversal depth (default 2)"),
-      direction: z.enum(["up", "down", "both"]).optional().describe("up=who depends on me, down=what I depend on (default up)"),
-    }),
-    ast_context: z.object({
-      id: z.string().describe("Node id, e.g. 'src/order.ts#cancelOrder'"),
-      hops: boundedInt(1, 3).describe("Subgraph depth (default 1)"),
-    }),
-  };
-}
-
-function createTools(rootRef) {
-  const schemas = toolSchemas();
-  const notIndexed = { ok: false, error: "astgraph index not built. Ask the user to run /ast init." };
-
-  const withDb = async (fn) => {
-    const root = rootRef();
-    const index = await openIndex(root);
-    if (index === undefined) return notIndexed;
-    try {
-      return await fn(index.db, root);
-    } finally {
-      index.db.close();
-    }
-  };
-
-  return [
-    {
-      name: "ast_search",
-      description: "Search the code graph for anchor symbols by keyword (full-text + identifier segments). Use before grep/read when locating where a change belongs.",
-      inputSchema: schemas.ast_search,
-      modelInputSchema: undefined,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.query,
-      execute: async (input) => withDb(async (db) => {
-        const { search } = await mod("query.mjs");
-        return { results: search(db, input.query, { limit: input.limit ?? 10 }) };
-      }),
-    },
-    {
-      name: "ast_callers",
-      description: "List the functions/classes that call or import a node in the code graph (upward dependencies).",
-      inputSchema: schemas.ast_callers,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { callers, getNode } = await mod("query.mjs");
-        const node = getNode(db, input.id);
-        return node === undefined ? { error: `Unknown node id "${input.id}"` } : { node, callers: callers(db, input.id) };
-      }),
-    },
-    {
-      name: "ast_callees",
-      description: "List the functions a node calls or imports (downward dependencies).",
-      inputSchema: schemas.ast_callees,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { callees, getNode } = await mod("query.mjs");
-        const node = getNode(db, input.id);
-        return node === undefined ? { error: `Unknown node id "${input.id}"` } : { node, callees: callees(db, input.id) };
-      }),
-    },
-    {
-      name: "ast_impact",
-      description: "Compute the K-hop blast radius of changing a node: who depends on it (up) or what it depends on (down). Use to scope a modification safely.",
-      inputSchema: schemas.ast_impact,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => `${input.id} ${input.direction ?? "up"}x${input.hops ?? 2}`,
-      execute: async (input) => withDb(async (db) => {
-        const { impact, getNode } = await mod("query.mjs");
-        if (getNode(db, input.id) === undefined) return { error: `Unknown node id "${input.id}"` };
-        return impact(db, input.id, { hops: input.hops ?? 2, direction: input.direction ?? "up" });
-      }),
-    },
-    {
-      name: "ast_context",
-      description: "Assemble the precise subgraph around a node: file paths and line ranges of the anchor, its callers and callees. Read only these ranges instead of grepping.",
-      inputSchema: schemas.ast_context,
-      readOnly: true,
-      paths: () => [],
-      summarize: (input) => input.id,
-      execute: async (input) => withDb(async (db) => {
-        const { subgraphContext } = await mod("query.mjs");
-        return subgraphContext(db, input.id, { hops: input.hops ?? 1 });
-      }),
-    },
-  ];
-}
-
-/** Extract workspace-relative file paths from a PostToolUse event's tool input. */
-function changedPaths(event, root) {
-  const payload = event?.payload;
-  if (payload === undefined) return [];
-  const input = payload.input ?? {};
-  const tool = payload.tool;
-  const paths = [];
-  if (tool === "Edit" || tool === "Write") {
-    if (typeof input.path === "string") paths.push(input.path);
-  } else if (tool === "ApplyPatch" && typeof input.patch === "string") {
-    for (const line of input.patch.split("\n")) {
-      if (!line.startsWith("+++ ")) continue;
-      const target = line.slice(4).trim().replace(/^b\//, "");
-      if (target !== "/dev/null") paths.push(target);
-    }
-  }
-  return paths
-    .map((path) => workspaceRelative(root, path))
-    .filter((path) => path !== undefined && /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/.test(path));
-}
-
-export function activate(context) {
-  // Per-plugin-instance workspace cache, populated by SessionStart; falls back
-  // to the host's command context workspace or the process cwd.
-  let workspaceRoot;
-  const rootRef = () => workspaceRoot ?? process.cwd();
-
-  context.registerCommand("ast", commandAst, "Build and query the code AST graph");
-
-  const disposers = [];
-  for (const tool of createTools(rootRef)) disposers.push(context.registerTool(tool.name, tool));
-
-  disposers.push(context.registerHook("SessionStart", (event) => {
-    workspaceRoot = workspaceFrom(event) ?? workspaceRoot;
-    return ALLOW;
-  }, { failurePolicy: "allow" }));
-
-  // Incremental sync after file-mutating tools. Fire-and-forget semantics:
-  // never block or fail the agent's edit.
-  let syncing = Promise.resolve();
-  disposers.push(context.registerHook("PostToolUse", (event) => {
-    const root = rootRef();
-    const paths = changedPaths(event, root);
-    if (paths.length === 0) return ALLOW;
-    syncing = syncing
-      .then(() => runIndex(root, { onlyPaths: paths }))
-      .catch((error) => context.logger.debug(`astgraph sync skipped: ${error?.message ?? error}`));
-    return ALLOW;
-  }, { failurePolicy: "allow", timeoutMs: 10_000 }));
-
-  return async () => {
-    for (const dispose of disposers.reverse()) {
-      try { await dispose(); } catch { /* ignore */ }
-    }
-  };
-}

package/dist/astgraph/indexer.mjs

@@ -1,175 +0,0 @@
-// astgraph indexer — full and incremental project indexing.
-// Walks the workspace, extracts symbols per file (content-hash incremental),
-// then resolves cross-file references into graph edges.
-
-import { createHash } from "node:crypto";
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { relative, sep } from "node:path";
-
-import {
-  deleteEdgesForFile,
-  deleteFileRecord,
-  deleteUnresolvedRefsForFile,
-  getFileRecord,
-  insertEdge,
-  insertUnresolvedRef,
-  replaceNodes,
-  setMetadata,
-  upsertFileRecord,
-} from "./db.mjs";
-import { extract } from "./extract.mjs";
-import { languageForFile, SUPPORTED_LANGUAGES } from "./grammars.mjs";
-import { resolveImportPath, resolveRefs } from "./resolve.mjs";
-
-/** Directory names never indexed, regardless of depth. */
-const EXCLUDED_DIRS = new Set([
-  "node_modules", "dist", "build", "out", "coverage", "release", ".git",
-  ".flavor", ".claude", ".worktrees", ".cache", ".idea", ".vscode", "vendor",
-]);
-
-function toPosix(path) {
-  return path.split(sep).join("/");
-}
-
-/** Walk the workspace and return code files as workspace-relative posix paths. */
-export function listCodeFiles(workspace) {
-  const files = [];
-  const walk = (dir) => {
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
-    catch { return; }
-    for (const entry of entries) {
-      const full = `${dir}/${entry.name}`;
-      if (entry.isDirectory()) {
-        if (!EXCLUDED_DIRS.has(entry.name)) walk(full);
-      } else if (entry.isFile() && languageForFile(entry.name) !== undefined) {
-        files.push(toPosix(relative(workspace, full)));
-      }
-    }
-  };
-  walk(workspace);
-  return files.sort();
-}
-
-/** SHA-256 content hash used for incremental detection. */
-export function contentHash(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-
-async function indexOneFile(db, workspace, relativePath) {
-  const content = readFileSync(`${workspace}/${relativePath}`, "utf8");
-  const language = languageForFile(relativePath);
-  const { nodes, edges, refs } = await extract(content, relativePath, language);
-
-  deleteEdgesForFile(db, relativePath);
-  deleteUnresolvedRefsForFile(db, relativePath);
-  replaceNodes(db, relativePath, nodes);
-  for (const edge of edges) insertEdge(db, edge);
-  for (const ref of refs) {
-    insertUnresolvedRef(db, {
-      fromNodeId: ref.fromNodeId, referenceName: ref.referenceName,
-      referenceKind: ref.referenceKind, line: ref.line, col: ref.col,
-      filePath: ref.filePath, moduleSpecifier: ref.moduleSpecifier,
-    });
-  }
-  let size;
-  try { size = statSync(`${workspace}/${relativePath}`).size; } catch { size = content.length; }
-  upsertFileRecord(db, {
-    path: relativePath, contentHash: contentHash(content), language, size, nodeCount: nodes.length,
-  });
-  return { nodeCount: nodes.length };
-}
-
-/** Resolve every pending unresolved_ref whose module specifier points at an indexed file. */
-function resolvePass(db, workspace) {
-  const rows = db.prepare(`
-    SELECT id, from_node_id, reference_name, reference_kind, line, col, file_path, module_specifier
-    FROM unresolved_refs WHERE status = 'pending' AND module_specifier IS NOT NULL
-  `).all();
-  if (rows.length === 0) return 0;
-
-  const nodesByFile = new Map();
-  for (const file of db.prepare("SELECT DISTINCT file_path FROM nodes").all()) {
-    nodesByFile.set(file.file_path, db.prepare(
-      "SELECT id, name, is_exported FROM nodes WHERE file_path = ?",
-    ).all(file.file_path).map((row) => ({ id: row.id, name: row.name, isExported: row.is_exported === 1 })));
-  }
-  const exists = (path) => {
-    try { statSync(`${workspace}/${path}`); return true; } catch { return false; }
-  };
-
-  const refs = rows.map((row) => ({
-    id: row.id, fromNodeId: row.from_node_id, referenceName: row.reference_name,
-    referenceKind: row.reference_kind, line: row.line, col: row.col,
-    filePath: row.file_path, moduleSpecifier: row.module_specifier,
-  }));
-  // Import statements live outside any function, so their refs carry no from-node.
-  // Attribute them to a node that actually uses the binding (same file + name);
-  // unused imports resolve silently without an edge.
-  for (const ref of refs) {
-    if (ref.fromNodeId !== null || ref.referenceKind !== "import") continue;
-    const user = refs.find((other) => other.referenceKind !== "import"
-      && other.referenceName === ref.referenceName
-      && other.filePath === ref.filePath
-      && other.fromNodeId !== null);
-    ref.fromNodeId = user?.fromNodeId ?? null;
-  }
-  const { edges, resolvedIds } = resolveRefs(refs.filter((ref) => ref.fromNodeId !== null), nodesByFile, exists);
-  for (const edge of edges) insertEdge(db, edge);
-  if (resolvedIds.length > 0) {
-    db.exec("BEGIN");
-    try {
-      const mark = db.prepare("DELETE FROM unresolved_refs WHERE id = ?");
-      for (const id of resolvedIds) mark.run(id);
-      db.exec("COMMIT");
-    } catch (error) { db.exec("ROLLBACK"); throw error; }
-  }
-  return resolvedIds.length;
-}
-
-/**
- * Index (or re-index) a workspace into the graph database.
- *
- * Options:
- *   onlyPaths — restrict the pass to these workspace-relative paths (hook-driven sync).
- *               Disappeared files are still pruned; everything else is left untouched.
- * Returns { files, indexed, skipped, removed, resolved }.
- */
-export async function indexProject(workspace, { db, onlyPaths } = {}) {
-  const restrict = onlyPaths === undefined ? undefined : new Set(onlyPaths.map(toPosix));
-  const diskFiles = listCodeFiles(workspace).filter((path) => restrict === undefined || restrict.has(path));
-
-  let indexed = 0;
-  let skipped = 0;
-  for (const path of diskFiles) {
-    const current = readFileSync(`${workspace}/${path}`, "utf8");
-    const hash = contentHash(current);
-    const record = getFileRecord(db, path);
-    if (record !== undefined && record.contentHash === hash) { skipped += 1; continue; }
-    await indexOneFile(db, workspace, path);
-    indexed += 1;
-  }
-
-  // Prune files that no longer exist on disk.
-  let removed = 0;
-  const known = db.prepare("SELECT path FROM files").all();
-  const diskSet = new Set(diskFiles);
-  for (const row of known) {
-    if (restrict !== undefined && !restrict.has(row.path)) continue;
-    if (!diskSet.has(row.path)) {
-      deleteEdgesForFile(db, row.path);
-      deleteUnresolvedRefsForFile(db, row.path);
-      replaceNodes(db, row.path, []);
-      deleteFileRecord(db, row.path);
-      removed += 1;
-    }
-  }
-
-  const resolved = resolvePass(db, workspace);
-  setMetadata(db, "last_index", JSON.stringify({ at: Date.now(), files: diskFiles.length, indexed, removed }));
-
-  return { files: diskFiles.length, indexed, skipped, removed, resolved };
-}
-
-/** Exposed for diagnostics. */
-export const INDEXER_LANGUAGES = SUPPORTED_LANGUAGES;

package/dist/astgraph/query.mjs

@@ -1,165 +0,0 @@
-// astgraph query layer — anchor search, K-hop traversal, blast radius and
-// subgraph context assembly. All coordinates are 1-based to match Read/editor use.
-
-const NODE_FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature, docstring, is_exported, is_async";
-
-function mapNode(row) {
-  if (row === undefined) return undefined;
-  return {
-    id: row.id, kind: row.kind, name: row.name, qualifiedName: row.qualified_name,
-    filePath: row.file_path, language: row.language,
-    startLine: row.start_line, endLine: row.end_line,
-    signature: row.signature ?? undefined, docstring: row.docstring ?? undefined,
-    isExported: row.is_exported === 1, isAsync: row.is_async === 1,
-  };
-}
-
-/** Fetch one node by id, or undefined. */
-export function getNode(db, id) {
-  return mapNode(db.prepare(`SELECT ${NODE_FIELDS} FROM nodes WHERE id = ?`).get(id));
-}
-
-/** Split camelCase/PascalCase/snake_case identifiers into lowercase word segments. */
-export function identifierSegments(name) {
-  return name
-    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-    .split(/[^A-Za-z0-9]+/)
-    .filter(Boolean)
-    .map((segment) => segment.toLowerCase());
-}
-
-function queryWords(query) {
-  return query
-    .toLowerCase()
-    .split(/[^a-z0-9]+/)
-    .filter((word) => word.length > 0);
-}
-
-/**
- * Anchor search: FTS5 first (prefix-matched terms), then identifier-segment
- * matching so natural-language words ("order cancel") hit camelCase symbols.
- * Returns scored node records, best first.
- */
-export function search(db, query, { limit = 20 } = {}) {
-  const words = queryWords(query);
-  if (words.length === 0) return [];
-
-  const scored = new Map();
-
-  // FTS pass — each query word as a prefix term.
-  try {
-    const match = words.map((word) => `${word}*`).join(" ");
-    const rows = db.prepare(`
-      SELECT n.${NODE_FIELDS.split(", ").join(", n.")}, rank
-      FROM nodes_fts
-      JOIN nodes n ON n.rowid = nodes_fts.rowid
-      WHERE nodes_fts MATCH ?
-      ORDER BY rank LIMIT ?
-    `).all(match, limit * 2);
-    for (const row of rows) scored.set(row.id, { node: mapNode(row), score: 100 - Math.min(50, Math.max(0, row.rank)) });
-  } catch { /* Invalid MATCH syntax falls through to segment matching. */ }
-
-  // Segment pass — words of the query appear as camelCase segments of node names.
-  const candidates = db.prepare(`SELECT ${NODE_FIELDS} FROM nodes`).all();
-  for (const row of candidates) {
-    const segments = identifierSegments(row.name).concat(identifierSegments(row.qualified_name));
-    const matched = words.filter((word) => segments.some((segment) => segment === word || segment.startsWith(word)));
-    if (matched.length === 0) continue;
-    const score = matched.length * 25 + (matched.length === words.length ? 20 : 0);
-    const existing = scored.get(row.id);
-    if (existing === undefined || existing.score < score) {
-      scored.set(row.id, { node: mapNode(row), score });
-    }
-  }
-
-  return [...scored.values()]
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit)
-    .map((entry) => entry.node);
-}
-
-/** Nodes that call the target (reverse call edges). */
-export function callers(db, id) {
-  return db.prepare(`
-    SELECT DISTINCT n.${NODE_FIELDS.split(", ").join(", n.")}
-    FROM edges e JOIN nodes n ON n.id = e.source
-    WHERE e.target = ? AND e.kind IN ('calls', 'imports')
-  `).all(id).map(mapNode);
-}
-
-/** Nodes the target calls (forward call edges). */
-export function callees(db, id) {
-  return db.prepare(`
-    SELECT DISTINCT n.${NODE_FIELDS.split(", ").join(", n.")}
-    FROM edges e JOIN nodes n ON n.id = e.target
-    WHERE e.source = ? AND e.kind IN ('calls', 'imports')
-  `).all(id).map(mapNode);
-}
-
-/**
- * K-hop blast radius from a node.
- *   direction "up"   — who depends on me (callers chain)
- *   direction "down" — what I depend on (callees chain)
- *   direction "both" — union
- */
-export function impact(db, id, { hops = 2, direction = "up", limit = 200 } = {}) {
-  const visited = new Map();
-  const frontier = [id];
-  for (let hop = 1; hop <= hops && frontier.length > 0; hop += 1) {
-    const next = [];
-    for (const current of frontier) {
-      let rows = [];
-      if (direction === "up" || direction === "both") {
-        rows = rows.concat(db.prepare("SELECT source AS other FROM edges WHERE target = ?").all(current));
-      }
-      if (direction === "down" || direction === "both") {
-        rows = rows.concat(db.prepare("SELECT target AS other FROM edges WHERE source = ?").all(current));
-      }
-      for (const row of rows) {
-        if (row.other === id || visited.has(row.other)) continue;
-        visited.set(row.other, hop);
-        next.push(row.other);
-        if (visited.size >= limit) break;
-      }
-      if (visited.size >= limit) break;
-    }
-    frontier.length = 0;
-    frontier.push(...next);
-  }
-  const nodes = [...visited.entries()]
-    .map(([nodeId, hop]) => ({ ...getNode(db, nodeId), hop }))
-    .filter((node) => node.name !== undefined)
-    .sort((a, b) => a.hop - b.hop);
-  return { origin: getNode(db, id), nodes, hops };
-}
-
-/**
- * Subgraph context assembly: the anchor plus its K-hop callers and callees,
- * rendered as precise file:start-end read ranges for the agent.
- */
-export function subgraphContext(db, id, { hops = 1, limit = 50 } = {}) {
-  const origin = getNode(db, id);
-  if (origin === undefined) return { anchor: undefined, context: [] };
-
-  const result = impact(db, id, { hops, direction: "both", limit });
-  const seen = new Map([[origin.filePath, origin]]);
-  const entries = [origin, ...result.nodes];
-  for (const node of entries) {
-    const existing = seen.get(node.filePath);
-    if (existing === undefined || node.startLine < existing.startLine) {
-      // Prefer the widest node per file only when ranges are identical; otherwise
-      // keep each node individually below.
-      seen.set(node.filePath, node);
-    }
-  }
-
-  const context = entries
-    .map((node) => ({
-      nodeId: node.id, name: node.name, kind: node.kind,
-      filePath: node.filePath, startLine: node.startLine, endLine: node.endLine,
-      signature: node.signature, docstring: node.docstring,
-    }))
-    .sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine);
-
-  return { anchor: origin, context };
-}