@monoes/monograph 1.5.6 → 1.5.8

package/src/mcp-tools/api-impact.ts

@@ -1,181 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-// ── Row → MonographNode mapper ─────────────────────────────────────────────────
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row.id as string,
-    label: row.label as MonographNode['label'],
-    name: row.name as string,
-    normLabel: row.norm_label as string,
-    filePath: row.file_path as string | undefined,
-    startLine: row.start_line as number | undefined,
-    endLine: row.end_line as number | undefined,
-    communityId: row.community_id as number | undefined,
-    isExported: (row.is_exported as number) === 1,
-    language: row.language as string | undefined,
-    properties: row.properties ? JSON.parse(row.properties as string) : undefined,
-  };
-}
-
-// ── Output types ───────────────────────────────────────────────────────────────
-
-export interface MonographApiImpactResult {
-  route: { method: string; path: string; nodeId: string } | null;
-  handler: MonographNode | null;
-  callees: Array<{ depth: number; node: MonographNode }>;
-  affectedProcesses: Array<{ id: string; name: string }>;
-  riskScore: number;
-}
-
-// ── Forward BFS on CALLS edges ─────────────────────────────────────────────────
-
-function forwardBfs(
-  startId: string,
-  db: Database.Database,
-  maxDepth: number,
-): Array<{ depth: number; nodeId: string }> {
-  const visited = new Map<string, number>([[startId, 0]]);
-  const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }];
-  const result: Array<{ depth: number; nodeId: string }> = [];
-
-  const stmt = db.prepare(
-    `SELECT target_id FROM edges WHERE source_id = ? AND relation = 'CALLS'`,
-  );
-
-  while (queue.length > 0) {
-    const { id, depth } = queue.shift()!;
-    if (depth >= maxDepth) continue;
-
-    const callees = stmt.all(id) as Array<{ target_id: string }>;
-    for (const { target_id } of callees) {
-      if (!visited.has(target_id)) {
-        visited.set(target_id, depth + 1);
-        result.push({ depth: depth + 1, nodeId: target_id });
-        queue.push({ id: target_id, depth: depth + 1 });
-      }
-    }
-  }
-
-  return result;
-}
-
-// ── Implementation ─────────────────────────────────────────────────────────────
-
-export function getMonographApiImpact(
-  db: Database.Database,
-  input: { routePath: string; method?: string },
-): MonographApiImpactResult {
-  const MAX_DEPTH = 5;
-
-  // 1. Find the Route node matching routePath
-  const likePattern = '%' + input.routePath + '%';
-  let routeRows = db
-    .prepare("SELECT * FROM nodes WHERE label = 'Route' AND name LIKE ?")
-    .all(likePattern) as Record<string, unknown>[];
-
-  // If method provided, narrow down by method prefix
-  if (input.method && routeRows.length > 0) {
-    const methodUpper = input.method.toUpperCase();
-    const filtered = routeRows.filter((row) => {
-      const name = row.name as string;
-      return name.startsWith(methodUpper + ' ');
-    });
-    // Only apply filter if it returns results; otherwise keep all matches
-    if (filtered.length > 0) {
-      routeRows = filtered;
-    }
-  }
-
-  if (routeRows.length === 0) {
-    return {
-      route: null,
-      handler: null,
-      callees: [],
-      affectedProcesses: [],
-      riskScore: 0,
-    };
-  }
-
-  const routeRow = routeRows[0];
-  const routeNodeId = routeRow.id as string;
-  const routeName = routeRow.name as string;
-
-  // Parse method and path from name (format: "METHOD /path")
-  const spaceIdx = routeName.indexOf(' ');
-  const method = spaceIdx >= 0 ? routeName.slice(0, spaceIdx) : 'ANY';
-  const path = spaceIdx >= 0 ? routeName.slice(spaceIdx + 1) : routeName;
-
-  const route = { method, path, nodeId: routeNodeId };
-
-  // 2. Find handler via HANDLES_ROUTE edge
-  const handlerRow = db
-    .prepare(
-      `SELECT n.* FROM nodes n
-       JOIN edges e ON n.id = e.target_id
-       WHERE e.source_id = ? AND e.relation = 'HANDLES_ROUTE'
-       LIMIT 1`,
-    )
-    .get(routeNodeId) as Record<string, unknown> | undefined;
-
-  const handler = handlerRow ? rowToNode(handlerRow) : null;
-
-  if (!handler) {
-    return {
-      route,
-      handler: null,
-      callees: [],
-      affectedProcesses: [],
-      riskScore: Math.log2(2),
-    };
-  }
-
-  // 3. Forward BFS on CALLS edges from handler
-  const bfsResults = forwardBfs(handler.id, db, MAX_DEPTH);
-
-  // 4. Resolve node details for all callees in a single batch query (avoids N+1).
-  const callees: Array<{ depth: number; node: MonographNode }> = [];
-  if (bfsResults.length > 0) {
-    const calleeIds = bfsResults.map((b) => b.nodeId);
-    const depthByNodeId = new Map(bfsResults.map((b) => [b.nodeId, b.depth]));
-    const placeholders = calleeIds.map(() => '?').join(',');
-    const nodeRows = db
-      .prepare(`SELECT * FROM nodes WHERE id IN (${placeholders})`)
-      .all(...calleeIds) as Record<string, unknown>[];
-    for (const nodeRow of nodeRows) {
-      const nodeId = nodeRow.id as string;
-      const depth = depthByNodeId.get(nodeId) ?? 0;
-      callees.push({ depth, node: rowToNode(nodeRow) });
-    }
-    // Restore BFS order (sort by depth ascending)
-    callees.sort((a, b) => a.depth - b.depth);
-  }
-
-  // 5. Find processes that include the handler or any callee via STEP_IN_PROCESS
-  const allNodeIds = [handler.id, ...bfsResults.map((b) => b.nodeId)];
-  const affectedProcesses: Array<{ id: string; name: string }> = [];
-
-  if (allNodeIds.length > 0) {
-    const placeholders = allNodeIds.map(() => '?').join(',');
-    const processRows = db
-      .prepare(
-        `SELECT DISTINCT n.id, n.name FROM nodes n
-         JOIN edges e ON n.id = e.source_id
-         WHERE e.target_id IN (${placeholders}) AND e.relation = 'STEP_IN_PROCESS'`,
-      )
-      .all(...allNodeIds) as Array<{ id: string; name: string }>;
-    affectedProcesses.push(...processRows);
-  }
-
-  // 6. Risk score: log2(callees.length + 2) capped at 10
-  const riskScore = Math.min(Math.log2(callees.length + 2), 10);
-
-  return {
-    route,
-    handler,
-    callees,
-    affectedProcesses,
-    riskScore,
-  };
-}

package/src/mcp-tools/context.ts

@@ -1,111 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-// ── Row → MonographNode mapper ─────────────────────────────────────────────────
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row.id as string,
-    label: row.label as MonographNode['label'],
-    name: row.name as string,
-    normLabel: row.norm_label as string,
-    filePath: row.file_path as string | undefined,
-    startLine: row.start_line as number | undefined,
-    endLine: row.end_line as number | undefined,
-    communityId: row.community_id as number | undefined,
-    isExported: (row.is_exported as number) === 1,
-    language: row.language as string | undefined,
-    properties: row.properties ? JSON.parse(row.properties as string) : undefined,
-  };
-}
-
-// ── Output type ────────────────────────────────────────────────────────────────
-
-export interface MonographContextResult {
-  node: MonographNode | null;
-  callers: MonographNode[];
-  callees: MonographNode[];
-  imports: MonographNode[];
-  importedBy: MonographNode[];
-  community: { id: number; label?: string } | null;
-  inProcesses: Array<{ id: string; name: string }>;
-}
-
-// ── Shared helper: query related nodes by edge relation and direction ──────────
-
-function queryRelated(
-  db: Database.Database,
-  nodeId: string,
-  relation: string,
-  inbound: boolean,
-  limit = 50,
-): MonographNode[] {
-  // inbound=true  → this node is the target; source nodes are the result
-  // inbound=false → this node is the source; target nodes are the result
-  const [filterCol, joinCol] = inbound
-    ? ['target_id', 'source_id']
-    : ['source_id', 'target_id'];
-
-  const rows = db
-    .prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.${joinCol}
-       WHERE e.${filterCol} = ? AND e.relation = ? LIMIT ?`,
-    )
-    .all(nodeId, relation, limit) as Record<string, unknown>[];
-
-  return rows.map(rowToNode);
-}
-
-// ── Implementation ─────────────────────────────────────────────────────────────
-
-export function getMonographContext(
-  db: Database.Database,
-  input: { name: string; filePath?: string },
-): MonographContextResult {
-  const LIMIT = 50;
-
-  // 1. Find the node
-  let nodeRow: Record<string, unknown> | undefined;
-  if (input.filePath) {
-    nodeRow = db
-      .prepare('SELECT * FROM nodes WHERE name = ? AND file_path = ? LIMIT 1')
-      .get(input.name, input.filePath) as Record<string, unknown> | undefined;
-  } else {
-    nodeRow = db
-      .prepare('SELECT * FROM nodes WHERE name = ? LIMIT 1')
-      .get(input.name) as Record<string, unknown> | undefined;
-  }
-
-  if (!nodeRow) {
-    return { node: null, callers: [], callees: [], imports: [], importedBy: [], community: null, inProcesses: [] };
-  }
-
-  const node = rowToNode(nodeRow);
-  const nodeId = node.id;
-
-  // 2–5. Callers / callees / imports / importedBy via shared helper
-  const callers    = queryRelated(db, nodeId, 'CALLS',   true,  LIMIT);
-  const callees    = queryRelated(db, nodeId, 'CALLS',   false, LIMIT);
-  const imports    = queryRelated(db, nodeId, 'IMPORTS', false, LIMIT);
-  const importedBy = queryRelated(db, nodeId, 'IMPORTS', true,  LIMIT);
-
-  // 6. Community: from node's community_id field
-  let community: { id: number; label?: string } | null = null;
-  if (node.communityId != null) {
-    const commRow = db
-      .prepare('SELECT id, label FROM communities WHERE id = ?')
-      .get(node.communityId) as { id: number; label?: string } | undefined;
-    community = commRow ?? { id: node.communityId };
-  }
-
-  // 7. inProcesses: processes that contain this node as a step
-  // STEP_IN_PROCESS edge goes: process → step_symbol
-  const processRows = db
-    .prepare(
-      `SELECT n.id, n.name FROM nodes n JOIN edges e ON n.id = e.source_id
-       WHERE e.target_id = ? AND e.relation = 'STEP_IN_PROCESS' LIMIT ?`,
-    )
-    .all(nodeId, LIMIT) as Array<{ id: string; name: string }>;
-
-  return { node, callers, callees, imports, importedBy, community, inProcesses: processRows };
-}

package/src/mcp-tools/cypher.ts

@@ -1,29 +0,0 @@
-import type Database from 'better-sqlite3';
-import { executeCypherQuery, formatCypherResult } from '../query/cypher-parser.js';
-import type { CypherResult } from '../query/cypher-parser.js';
-
-export type { CypherResult };
-export { formatCypherResult };
-
-/**
- * Execute a restricted read-only Cypher-style query against the Monograph graph.
- *
- * @param db - Open better-sqlite3 database handle
- * @param query - Cypher MATCH query string
- * @returns CypherResult with rows, queryTime, and optional error
- */
-export function getMonographCypher(db: Database.Database, query: string): CypherResult {
-  return executeCypherQuery(db, query);
-}
-
-/**
- * Execute a Cypher-style query and return structured text for LLM consumption.
- * Rows with filePath + startLine fields are rendered as "file:line" navigation hints.
- *
- * @param db - Open better-sqlite3 database handle
- * @param query - Cypher MATCH query string
- * @returns Formatted string suitable for direct injection into LLM context
- */
-export function getMonographCypherText(db: Database.Database, query: string): string {
-  return formatCypherResult(executeCypherQuery(db, query));
-}

package/src/mcp-tools/detect-changes.ts

@@ -1,116 +0,0 @@
-import { spawnSync } from 'child_process';
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-// ── Output type ────────────────────────────────────────────────────────────────
-
-export interface MonographDetectChangesResult {
-  changedFiles: string[];
-  affectedSymbols: Array<{ name: string; filePath: string; label: string }>;
-  affectedProcesses: Array<{ id: string; name: string }>;
-  error?: string;
-}
-
-// ── Implementation ─────────────────────────────────────────────────────────────
-
-const MAX_FILES = 200;    // cap on changed-file count to prevent unbounded IN clauses
-const MAX_STDOUT = 1_048_576; // 1 MiB stdout cap for git output
-
-export function detectMonographChanges(
-  db: Database.Database,
-  input: { baseBranch?: string; includeTests?: boolean },
-  repoPath: string,
-): MonographDetectChangesResult {
-  const rawBranch = input.baseBranch ?? 'main';
-  // Reject branch names that could be shell-injected or path-traversed
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._\-/]*$/.test(rawBranch)) {
-    return { changedFiles: [], affectedSymbols: [], affectedProcesses: [], error: `Invalid branch name: ${rawBranch}` };
-  }
-  const baseBranch = rawBranch;
-  const includeTests = input.includeTests ?? true;
-
-  let changedFiles: string[];
-
-  try {
-    // Use spawnSync with argument array to eliminate shell injection entirely
-    const result = spawnSync('git', ['diff', '--name-only', `${baseBranch}...HEAD`], {
-      cwd: repoPath,
-      encoding: 'utf-8',
-      maxBuffer: MAX_STDOUT,
-    });
-    if (result.error) throw result.error;
-    if (result.status !== 0) throw new Error(result.stderr ?? `git exited ${result.status}`);
-    const output = (result.stdout ?? '').slice(0, MAX_STDOUT).trim();
-
-    changedFiles = output
-      .split('\n')
-      .map(f => f.trim())
-      .filter(f => f.length > 0)
-      .slice(0, MAX_FILES); // cap to prevent unbounded IN clauses
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { changedFiles: [], affectedSymbols: [], affectedProcesses: [], error: message };
-  }
-
-  // Filter out test files if requested
-  if (!includeTests) {
-    changedFiles = changedFiles.filter(f => !(/\.(test|spec)\./.test(f)));
-  }
-
-  if (changedFiles.length === 0) {
-    return { changedFiles: [], affectedSymbols: [], affectedProcesses: [] };
-  }
-
-  // Query DB for symbols in changed files (batch if needed)
-  let affectedSymbols: Array<{ name: string; filePath: string; label: string }> = [];
-  let affectedSymbolIds: string[] = [];
-
-  try {
-    // Process in batches of 50 to keep SQLite IN clause size bounded
-    const BATCH = 50;
-    const allRows: Array<{ id: string; name: string; file_path: string; label: string }> = [];
-    for (let i = 0; i < changedFiles.length; i += BATCH) {
-      const batch = changedFiles.slice(i, i + BATCH);
-      const placeholders = batch.map(() => '?').join(',');
-      const rows = db
-        .prepare(`SELECT id, name, file_path, label FROM nodes WHERE file_path IN (${placeholders})`)
-        .all(...batch) as Array<{ id: string; name: string; file_path: string; label: string }>;
-      allRows.push(...rows);
-    }
-
-    affectedSymbols = allRows.map(r => ({ name: r.name, filePath: r.file_path, label: r.label }));
-    affectedSymbolIds = allRows.map(r => r.id);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { changedFiles, affectedSymbols: [], affectedProcesses: [], error: message };
-  }
-
-  // Find processes that contain any of the affected symbols as steps
-  // STEP_IN_PROCESS: process → step_symbol
-  let affectedProcesses: Array<{ id: string; name: string }> = [];
-
-  if (affectedSymbolIds.length > 0) {
-    try {
-      // Also batch symbol IDs to keep IN clause bounded
-      const BATCH = 50;
-      const processSet = new Map<string, string>();
-      for (let i = 0; i < affectedSymbolIds.length; i += BATCH) {
-        const batch = affectedSymbolIds.slice(i, i + BATCH);
-        const placeholders = batch.map(() => '?').join(',');
-        const processRows = db
-          .prepare(
-            `SELECT DISTINCT n.id, n.name
-             FROM nodes n JOIN edges e ON n.id = e.source_id
-             WHERE e.relation = 'STEP_IN_PROCESS' AND e.target_id IN (${placeholders})`,
-          )
-          .all(...batch) as Array<{ id: string; name: string }>;
-        for (const row of processRows) processSet.set(row.id, row.name);
-      }
-      affectedProcesses = Array.from(processSet.entries()).map(([id, name]) => ({ id, name }));
-    } catch {
-      // Non-fatal: return what we have
-    }
-  }
-
-  return { changedFiles, affectedSymbols, affectedProcesses };
-}

package/src/mcp-tools/explain.ts

@@ -1,65 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row['id'] as string,
-    label: row['label'] as MonographNode['label'],
-    name: row['name'] as string,
-    normLabel: (row['norm_label'] as string) ?? '',
-    filePath: row['file_path'] as string | undefined,
-    startLine: row['start_line'] as number | undefined,
-    endLine: row['end_line'] as number | undefined,
-    communityId: row['community_id'] as number | undefined,
-    isExported: (row['is_exported'] as number) === 1,
-    language: row['language'] as string | undefined,
-    properties: row['properties'] ? JSON.parse(row['properties'] as string) : undefined,
-  };
-}
-
-export interface ExplainResult {
-  node: MonographNode | null;
-  explanation: string | null;
-  connectionCount: number;
-}
-
-export function explainNode(db: Database.Database, name: string): ExplainResult {
-  const nodeRow = db.prepare('SELECT * FROM nodes WHERE name = ? LIMIT 1').get(name) as Record<string, unknown> | undefined;
-  if (!nodeRow) return { node: null, explanation: null, connectionCount: 0 };
-
-  const node = rowToNode(nodeRow);
-
-  // Get outbound connections
-  const outRows = db.prepare(
-    `SELECT n.name, e.relation FROM nodes n JOIN edges e ON n.id = e.target_id WHERE e.source_id = ? LIMIT 10`
-  ).all(node.id) as { name: string; relation: string }[];
-
-  // Get inbound connections
-  const inRows = db.prepare(
-    `SELECT n.name, e.relation FROM nodes n JOIN edges e ON n.id = e.source_id WHERE e.target_id = ? LIMIT 10`
-  ).all(node.id) as { name: string; relation: string }[];
-
-  const connectionCount = outRows.length + inRows.length;
-  const fileRef = node.filePath
-    ? (node.startLine != null ? `${node.filePath}:${node.startLine}` : node.filePath)
-    : null;
-  const fileLine = fileRef ? ` defined in \`${fileRef}\`` : '';
-
-  let explanation = `**${node.name}** is a ${node.label}${fileLine}.`;
-
-  if (outRows.length > 0) {
-    const outList = outRows.map(r => `\`${r.name}\` (${r.relation})`).join(', ');
-    explanation += ` It connects to: ${outList}.`;
-  }
-
-  if (inRows.length > 0) {
-    const inList = inRows.map(r => `\`${r.name}\``).slice(0, 5).join(', ');
-    explanation += ` Referenced by: ${inList}.`;
-  }
-
-  if (node.communityId != null) {
-    explanation += ` Part of community ${node.communityId}.`;
-  }
-
-  return { node, explanation, connectionCount };
-}

package/src/mcp-tools/graph-query.ts

@@ -1,128 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row['id'] as string,
-    label: row['label'] as MonographNode['label'],
-    name: row['name'] as string,
-    normLabel: (row['norm_label'] as string) ?? '',
-    filePath: row['file_path'] as string | undefined,
-    startLine: row['start_line'] as number | undefined,
-    endLine: row['end_line'] as number | undefined,
-    communityId: row['community_id'] as number | undefined,
-    isExported: (row['is_exported'] as number) === 1,
-    language: row['language'] as string | undefined,
-    properties: row['properties'] ? JSON.parse(row['properties'] as string) : undefined,
-  };
-}
-
-export interface GraphQueryInput {
-  query: string;
-  mode?: 'bfs' | 'dfs';
-  /** Direction of edge traversal. 'both' includes incoming edges (callers) and outgoing (callees). Default: 'out' */
-  direction?: 'out' | 'in' | 'both';
-  tokenBudget?: number;
-  depth?: number;
-}
-
-export interface GraphQueryResult {
-  nodes: MonographNode[];
-  mode: 'bfs' | 'dfs';
-  truncated: boolean;
-  tokenEstimate: number;
-}
-
-function estimateTokens(nodes: MonographNode[]): number {
-  return nodes.reduce((acc, n) => acc + n.name.length + (n.filePath?.length ?? 0) + 20, 0);
-}
-
-export function queryGraph(
-  db: Database.Database,
-  input: GraphQueryInput,
-): GraphQueryResult {
-  const mode = input.mode ?? 'bfs';
-  const direction = input.direction ?? 'out';
-  const tokenBudget = input.tokenBudget ?? 2000;
-  const maxDepth = input.depth ?? 3;
-
-  // Find seed nodes matching the query
-  const seedRows = db.prepare(
-    `SELECT * FROM nodes WHERE name LIKE ? OR label LIKE ? LIMIT 20`
-  ).all(`%${input.query}%`, `%${input.query}%`) as Record<string, unknown>[];
-
-  const seeds = seedRows.map(rowToNode);
-  const visited = new Map<string, MonographNode>();
-  const result: MonographNode[] = [];
-  let tokenEstimate = 0;
-  let truncated = false;
-
-  for (const seed of seeds) {
-    visited.set(seed.id, seed);
-    result.push(seed);
-    tokenEstimate += estimateTokens([seed]);
-    if (tokenEstimate > tokenBudget) { truncated = true; break; }
-  }
-
-  if (!truncated) {
-    // BFS or DFS expansion
-    const frontier: Array<{ id: string; depth: number }> = seeds.map(s => ({ id: s.id, depth: 0 }));
-
-    // Prepare edge traversal statements for each direction.
-    // 'out' follows outgoing edges (what this node calls/imports/uses).
-    // 'in' follows incoming edges (what calls/imports/uses this node).
-    // 'both' follows both directions — needed for full context (callers + callees).
-    const outEdgeStmt = db.prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.target_id WHERE e.source_id = ? LIMIT 20`
-    );
-    const inEdgeStmt = db.prepare(
-      `SELECT n.* FROM nodes n JOIN edges e ON n.id = e.source_id WHERE e.target_id = ? LIMIT 20`
-    );
-    const getNeighbors = (id: string): Record<string, unknown>[] => {
-      if (direction === 'out') return outEdgeStmt.all(id) as Record<string, unknown>[];
-      if (direction === 'in') return inEdgeStmt.all(id) as Record<string, unknown>[];
-      // 'both': union of outgoing and incoming, deduplicated by id
-      const outRows = outEdgeStmt.all(id) as Record<string, unknown>[];
-      const inRows = inEdgeStmt.all(id) as Record<string, unknown>[];
-      const seen = new Set(outRows.map(r => r['id'] as string));
-      return [...outRows, ...inRows.filter(r => !seen.has(r['id'] as string))];
-    };
-
-
-    if (mode === 'bfs') {
-      while (frontier.length > 0 && !truncated) {
-        const { id, depth } = frontier.shift()!;
-        if (depth >= maxDepth) continue;
-        const neighbors = getNeighbors(id);
-        for (const row of neighbors) {
-          const node = rowToNode(row);
-          if (visited.has(node.id)) continue;
-          visited.set(node.id, node);
-          result.push(node);
-          tokenEstimate += estimateTokens([node]);
-          if (tokenEstimate > tokenBudget) { truncated = true; break; }
-          frontier.push({ id: node.id, depth: depth + 1 });
-        }
-      }
-    } else {
-      // DFS: use stack
-      const stack = [...frontier].reverse();
-      while (stack.length > 0 && !truncated) {
-        const { id, depth } = stack.pop()!;
-        if (depth >= maxDepth) continue;
-        const neighbors = getNeighbors(id);
-        for (let i = neighbors.length - 1; i >= 0; i--) {
-          const node = rowToNode(neighbors[i]!);
-          if (visited.has(node.id)) continue;
-          visited.set(node.id, node);
-          result.push(node);
-          tokenEstimate += estimateTokens([node]);
-          if (tokenEstimate > tokenBudget) { truncated = true; break; }
-          stack.push({ id: node.id, depth: depth + 1 });
-        }
-      }
-    }
-  }
-
-  return { nodes: result, mode, truncated, tokenEstimate };
-}