clast-ai 0.1.1 → 0.2.0

package/src/db/queries.ts

@@ -1,332 +0,0 @@
-import type { Database } from 'sql.js';
-import type { FileRow, AstNodeRow, CallEdgeRow, CommentRow, StatusRow } from './types.js';
-
-export class Queries {
-  private db: Database;
-
-  constructor(db: Database) {
-    this.db = db;
-  }
-
-  private run(sql: string, params: unknown[] = []): void {
-    this.db.run(sql, params as (string | number | null | Uint8Array)[]);
-  }
-
-  private get<T>(sql: string, params: unknown[] = []): T | undefined {
-    const result = this.db.exec(sql, params as (string | number | null | Uint8Array)[]);
-    if (result.length === 0 || result[0]!.values.length === 0) return undefined;
-    const columns = result[0]!.columns;
-    const values = result[0]!.values[0]!;
-    const obj: Record<string, unknown> = {};
-    for (let i = 0; i < columns.length; i++) {
-      obj[columns[i]!] = values[i];
-    }
-    return obj as T;
-  }
-
-  private all<T>(sql: string, params: unknown[] = []): T[] {
-    const result = this.db.exec(sql, params as (string | number | null | Uint8Array)[]);
-    if (result.length === 0) return [];
-    const columns = result[0]!.columns;
-    return result[0]!.values.map(values => {
-      const obj: Record<string, unknown> = {};
-      for (let i = 0; i < columns.length; i++) {
-        obj[columns[i]!] = values[i];
-      }
-      return obj as T;
-    });
-  }
-
-  private getLastInsertId(): number {
-    const result = this.db.exec('SELECT last_insert_rowid() as id');
-    if (result.length > 0 && result[0]!.values.length > 0) {
-      return Number(result[0]!.values[0]![0]);
-    }
-    return 0;
-  }
-
-  // --- File operations ---
-
-  upsertFile(filePath: string, hash: string, language: string, nodeCount: number): void {
-    this.run(
-      `INSERT OR REPLACE INTO files (file_path, hash, language, last_indexed, node_count)
-       VALUES (?, ?, ?, ?, ?)`,
-      [filePath, hash, language, Date.now(), nodeCount]
-    );
-  }
-
-  deleteFile(filePath: string): void {
-    // Manually cascade since sql.js foreign key cascade can be unreliable
-    this.run(`DELETE FROM comments WHERE node_id IN (SELECT id FROM ast_nodes WHERE file_path = ?)`, [filePath]);
-    this.run(`DELETE FROM call_edges WHERE caller_id IN (SELECT id FROM ast_nodes WHERE file_path = ?)`, [filePath]);
-    this.run(`DELETE FROM call_edges WHERE callee_id IN (SELECT id FROM ast_nodes WHERE file_path = ?)`, [filePath]);
-    this.run(`DELETE FROM ast_nodes WHERE file_path = ?`, [filePath]);
-    this.run(`DELETE FROM files WHERE file_path = ?`, [filePath]);
-  }
-
-  getFileHash(filePath: string): string | null {
-    const row = this.get<{ hash: string }>(`SELECT hash FROM files WHERE file_path = ?`, [filePath]);
-    return row?.hash ?? null;
-  }
-
-  getAllFiles(): FileRow[] {
-    return this.all<FileRow>(`SELECT * FROM files`);
-  }
-
-  // --- Node operations ---
-
-  insertNode(node: Omit<AstNodeRow, 'id'>): number {
-    this.run(
-      `INSERT INTO ast_nodes (file_path, name, type, signature, start_line, end_line, start_col, end_col, parent_id, language, body_text)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        node.file_path, node.name, node.type, node.signature,
-        node.start_line, node.end_line, node.start_col, node.end_col,
-        node.parent_id, node.language, node.body_text,
-      ]
-    );
-    return this.getLastInsertId();
-  }
-
-  insertNodes(nodes: Omit<AstNodeRow, 'id'>[]): number[] {
-    const ids: number[] = [];
-    this.run('BEGIN TRANSACTION');
-    try {
-      for (const node of nodes) {
-        ids.push(this.insertNode(node));
-      }
-      this.run('COMMIT');
-    } catch (err) {
-      this.run('ROLLBACK');
-      throw err;
-    }
-    return ids;
-  }
-
-  getNodeById(id: number): AstNodeRow | undefined {
-    return this.get<AstNodeRow>(`SELECT * FROM ast_nodes WHERE id = ?`, [id]);
-  }
-
-  getNodeByName(name: string): AstNodeRow[] {
-    return this.all<AstNodeRow>(
-      `SELECT * FROM ast_nodes WHERE name = ? ORDER BY file_path, start_line`,
-      [name]
-    );
-  }
-
-  getNodesByFile(filePath: string): AstNodeRow[] {
-    return this.all<AstNodeRow>(
-      `SELECT * FROM ast_nodes WHERE file_path = ? ORDER BY start_line`,
-      [filePath]
-    );
-  }
-
-  searchNodes(query: string, type?: string, limit: number = 20): AstNodeRow[] {
-    const pattern = `%${query}%`;
-    if (type) {
-      return this.all<AstNodeRow>(
-        `SELECT * FROM ast_nodes WHERE name LIKE ? AND type = ? LIMIT ?`,
-        [pattern, type, limit]
-      );
-    }
-    return this.all<AstNodeRow>(
-      `SELECT * FROM ast_nodes WHERE name LIKE ? LIMIT ?`,
-      [pattern, limit]
-    );
-  }
-
-  // --- Edge operations ---
-
-  insertEdge(edge: Omit<CallEdgeRow, 'id'>): number {
-    this.run(
-      `INSERT INTO call_edges (caller_id, callee_id, callee_name, file_path, line)
-       VALUES (?, ?, ?, ?, ?)`,
-      [edge.caller_id, edge.callee_id, edge.callee_name, edge.file_path, edge.line]
-    );
-    return this.getLastInsertId();
-  }
-
-  insertEdges(edges: Omit<CallEdgeRow, 'id'>[]): void {
-    this.run('BEGIN TRANSACTION');
-    try {
-      for (const edge of edges) {
-        this.insertEdge(edge);
-      }
-      this.run('COMMIT');
-    } catch (err) {
-      this.run('ROLLBACK');
-      throw err;
-    }
-  }
-
-  getCallersOf(nameOrId: string | number, depth: number = 2): AstNodeRow[] {
-    const whereClause = typeof nameOrId === 'number'
-      ? 'callee_id = ?'
-      : 'callee_name = ?';
-
-    const sql = `
-      WITH RECURSIVE caller_chain(id, depth) AS (
-        SELECT caller_id, 1
-        FROM call_edges
-        WHERE ${whereClause}
-        UNION
-        SELECT ce.caller_id, cc.depth + 1
-        FROM call_edges ce
-        JOIN caller_chain cc ON ce.callee_id = cc.id
-        WHERE cc.depth < ?
-      )
-      SELECT DISTINCT an.* FROM ast_nodes an
-      JOIN caller_chain cc ON an.id = cc.id
-      ORDER BY an.file_path, an.start_line
-    `;
-    return this.all<AstNodeRow>(sql, [nameOrId, depth]);
-  }
-
-  getCalleesOf(nameOrId: string | number, depth: number = 2): AstNodeRow[] {
-    const whereClause = typeof nameOrId === 'number'
-      ? 'an.id = ?'
-      : 'an.name = ?';
-
-    const sql = `
-      WITH RECURSIVE callee_chain(id, name, depth) AS (
-        SELECT ce.callee_id, ce.callee_name, 1
-        FROM call_edges ce
-        JOIN ast_nodes an ON ce.caller_id = an.id
-        WHERE ${whereClause}
-        UNION
-        SELECT ce2.callee_id, ce2.callee_name, cc.depth + 1
-        FROM call_edges ce2
-        JOIN callee_chain cc ON ce2.caller_id = cc.id
-        WHERE cc.depth < ? AND cc.id IS NOT NULL
-      )
-      SELECT DISTINCT an.* FROM ast_nodes an
-      JOIN callee_chain cc ON an.id = cc.id
-      WHERE cc.id IS NOT NULL
-      ORDER BY an.file_path, an.start_line
-    `;
-    return this.all<AstNodeRow>(sql, [nameOrId, depth]);
-  }
-
-  getCallEdgesForNode(nodeId: number): { outgoing: CallEdgeRow[]; incoming: CallEdgeRow[] } {
-    const outgoing = this.all<CallEdgeRow>(
-      `SELECT * FROM call_edges WHERE caller_id = ?`,
-      [nodeId]
-    );
-    const incoming = this.all<CallEdgeRow>(
-      `SELECT * FROM call_edges WHERE callee_id = ?`,
-      [nodeId]
-    );
-    return { outgoing, incoming };
-  }
-
-  // --- Comment operations ---
-
-  insertComment(nodeId: number, text: string, source: 'original' | 'generated'): number {
-    this.run(
-      `INSERT INTO comments (node_id, text, source, generated_at)
-       VALUES (?, ?, ?, ?)`,
-      [nodeId, text, source, source === 'generated' ? Date.now() : null]
-    );
-    return this.getLastInsertId();
-  }
-
-  getCommentsForNode(nodeId: number): CommentRow[] {
-    return this.all<CommentRow>(`SELECT * FROM comments WHERE node_id = ?`, [nodeId]);
-  }
-
-  deleteCommentsBySource(nodeId: number, source: 'original' | 'generated'): void {
-    this.run(`DELETE FROM comments WHERE node_id = ? AND source = ?`, [nodeId, source]);
-  }
-
-  // --- Context (combined) ---
-
-  getNodeWithContext(name: string): {
-    nodes: AstNodeRow[];
-    comments: CommentRow[];
-    callers: AstNodeRow[];
-    callees: AstNodeRow[];
-  } {
-    const nodes = this.getNodeByName(name);
-    if (nodes.length === 0) {
-      return { nodes: [], comments: [], callers: [], callees: [] };
-    }
-
-    const allComments: CommentRow[] = [];
-    for (const node of nodes) {
-      allComments.push(...this.getCommentsForNode(node.id));
-    }
-
-    const callers = this.getCallersOf(name, 1);
-    const callees = this.getCalleesOf(name, 1);
-
-    return { nodes, comments: allComments, callers, callees };
-  }
-
-  // --- Status ---
-
-  getStatus(): StatusRow {
-    const result = this.get<StatusRow>(`
-      SELECT
-        (SELECT COUNT(*) FROM files) as files_indexed,
-        (SELECT COUNT(*) FROM ast_nodes) as total_nodes,
-        (SELECT COUNT(*) FROM call_edges) as total_edges,
-        (SELECT COUNT(*) FROM comments) as total_comments,
-        (SELECT MAX(last_indexed) FROM files) as last_indexed
-    `);
-    return result ?? {
-      files_indexed: 0,
-      total_nodes: 0,
-      total_edges: 0,
-      total_comments: 0,
-      last_indexed: null,
-    };
-  }
-
-  // --- Bulk operations ---
-
-  deleteNodesForFile(filePath: string): void {
-    this.run(`DELETE FROM comments WHERE node_id IN (SELECT id FROM ast_nodes WHERE file_path = ?)`, [filePath]);
-    this.run(`DELETE FROM call_edges WHERE caller_id IN (SELECT id FROM ast_nodes WHERE file_path = ?)`, [filePath]);
-    this.run(`DELETE FROM ast_nodes WHERE file_path = ?`, [filePath]);
-  }
-
-  resolveEdges(): number {
-    // Count unresolved before
-    const before = this.get<{ cnt: number }>(
-      `SELECT COUNT(*) as cnt FROM call_edges WHERE callee_id IS NULL`
-    );
-    const beforeCount = before?.cnt ?? 0;
-
-    this.run(`
-      UPDATE call_edges
-      SET callee_id = (
-        SELECT an.id FROM ast_nodes an
-        WHERE an.name = call_edges.callee_name
-        LIMIT 1
-      )
-      WHERE callee_id IS NULL
-    `);
-
-    const after = this.get<{ cnt: number }>(
-      `SELECT COUNT(*) as cnt FROM call_edges WHERE callee_id IS NULL`
-    );
-    const afterCount = after?.cnt ?? 0;
-
-    return beforeCount - afterCount;
-  }
-
-  getNodesWithoutComments(limit: number = 100): AstNodeRow[] {
-    return this.all<AstNodeRow>(`
-      SELECT an.* FROM ast_nodes an
-      LEFT JOIN comments c ON an.id = c.node_id
-      WHERE c.id IS NULL
-        AND an.type IN ('function', 'method', 'class', 'interface', 'struct', 'trait')
-      LIMIT ?
-    `, [limit]);
-  }
-
-  /** Flush the in-memory database to a Uint8Array for saving to disk. */
-  export(): Uint8Array {
-    return this.db.export();
-  }
-}

package/src/db/schema.ts

@@ -1,106 +0,0 @@
-import type { Database } from 'sql.js';
-
-const SCHEMA_VERSION = 1;
-
-const CREATE_TABLES = `
-  CREATE TABLE IF NOT EXISTS _clast_meta (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS files (
-    file_path TEXT PRIMARY KEY,
-    hash TEXT NOT NULL,
-    language TEXT NOT NULL,
-    last_indexed INTEGER NOT NULL,
-    node_count INTEGER NOT NULL DEFAULT 0
-  );
-
-  CREATE TABLE IF NOT EXISTS ast_nodes (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    file_path TEXT NOT NULL,
-    name TEXT NOT NULL,
-    type TEXT NOT NULL,
-    signature TEXT NOT NULL DEFAULT '',
-    start_line INTEGER NOT NULL,
-    end_line INTEGER NOT NULL,
-    start_col INTEGER NOT NULL,
-    end_col INTEGER NOT NULL,
-    parent_id INTEGER,
-    language TEXT NOT NULL,
-    body_text TEXT NOT NULL DEFAULT '',
-    FOREIGN KEY (file_path) REFERENCES files(file_path) ON DELETE CASCADE,
-    FOREIGN KEY (parent_id) REFERENCES ast_nodes(id) ON DELETE CASCADE
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_nodes_name ON ast_nodes(name);
-  CREATE INDEX IF NOT EXISTS idx_nodes_type ON ast_nodes(type);
-  CREATE INDEX IF NOT EXISTS idx_nodes_file ON ast_nodes(file_path);
-  CREATE INDEX IF NOT EXISTS idx_nodes_name_type ON ast_nodes(name, type);
-
-  CREATE TABLE IF NOT EXISTS call_edges (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    caller_id INTEGER NOT NULL,
-    callee_id INTEGER,
-    callee_name TEXT NOT NULL,
-    file_path TEXT NOT NULL,
-    line INTEGER NOT NULL,
-    FOREIGN KEY (caller_id) REFERENCES ast_nodes(id) ON DELETE CASCADE,
-    FOREIGN KEY (callee_id) REFERENCES ast_nodes(id) ON DELETE SET NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_edges_caller ON call_edges(caller_id);
-  CREATE INDEX IF NOT EXISTS idx_edges_callee ON call_edges(callee_id);
-  CREATE INDEX IF NOT EXISTS idx_edges_callee_name ON call_edges(callee_name);
-
-  CREATE TABLE IF NOT EXISTS comments (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    node_id INTEGER NOT NULL,
-    text TEXT NOT NULL,
-    source TEXT NOT NULL CHECK(source IN ('original', 'generated')),
-    generated_at INTEGER,
-    FOREIGN KEY (node_id) REFERENCES ast_nodes(id) ON DELETE CASCADE
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_comments_node ON comments(node_id);
-`;
-
-export function initializeSchema(db: Database): void {
-  db.run('PRAGMA foreign_keys = ON');
-
-  const currentVersion = getSchemaVersion(db);
-
-  if (currentVersion < SCHEMA_VERSION) {
-    // sql.js doesn't support multi-statement exec with CREATE TABLE IF NOT EXISTS well,
-    // so we split and execute each statement
-    const statements = CREATE_TABLES.split(';')
-      .map(s => s.trim())
-      .filter(s => s.length > 0);
-
-    for (const stmt of statements) {
-      db.run(stmt);
-    }
-    setSchemaVersion(db, SCHEMA_VERSION);
-  }
-}
-
-function getSchemaVersion(db: Database): number {
-  try {
-    const result = db.exec(
-      `SELECT value FROM _clast_meta WHERE key = 'schema_version'`
-    );
-    if (result.length > 0 && result[0]!.values.length > 0) {
-      return parseInt(String(result[0]!.values[0]![0]), 10);
-    }
-    return 0;
-  } catch {
-    return 0;
-  }
-}
-
-function setSchemaVersion(db: Database, version: number): void {
-  db.run(
-    `INSERT OR REPLACE INTO _clast_meta (key, value) VALUES ('schema_version', ?)`,
-    [String(version)]
-  );
-}

package/src/db/types.ts

@@ -1,47 +0,0 @@
-export interface FileRow {
-  file_path: string;
-  hash: string;
-  language: string;
-  last_indexed: number;
-  node_count: number;
-}
-
-export interface AstNodeRow {
-  id: number;
-  file_path: string;
-  name: string;
-  type: string;
-  signature: string;
-  start_line: number;
-  end_line: number;
-  start_col: number;
-  end_col: number;
-  parent_id: number | null;
-  language: string;
-  body_text: string;
-}
-
-export interface CallEdgeRow {
-  id: number;
-  caller_id: number;
-  callee_id: number | null;
-  callee_name: string;
-  file_path: string;
-  line: number;
-}
-
-export interface CommentRow {
-  id: number;
-  node_id: number;
-  text: string;
-  source: 'original' | 'generated';
-  generated_at: number | null;
-}
-
-export interface StatusRow {
-  files_indexed: number;
-  total_nodes: number;
-  total_edges: number;
-  total_comments: number;
-  last_indexed: number | null;
-}

package/src/parser/call-resolver.ts

@@ -1,17 +0,0 @@
-import type { Queries } from '../db/queries.js';
-
-/**
- * Resolves unresolved call edges in the database.
- *
- * After all files are parsed and nodes inserted, call edges may have
- * callee_id = null because the callee wasn't inserted yet. This resolver
- * attempts to match callee_name to ast_nodes.name.
- *
- * Resolution strategy (best-effort):
- * 1. Exact name match within the same file
- * 2. Exact name match across all files
- * 3. Leave unresolved if no match
- */
-export function resolveCallEdges(queries: Queries): number {
-  return queries.resolveEdges();
-}

package/src/parser/languages.ts

@@ -1,86 +0,0 @@
-import { join, dirname } from 'node:path';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-
-interface LanguageEntry {
-  name: string;
-  extensions: string[];
-  wasmFile: string;
-}
-
-const LANGUAGES: LanguageEntry[] = [
-  { name: 'typescript', extensions: ['.ts'], wasmFile: 'tree-sitter-typescript.wasm' },
-  { name: 'tsx', extensions: ['.tsx'], wasmFile: 'tree-sitter-tsx.wasm' },
-  { name: 'javascript', extensions: ['.js', '.jsx', '.mjs', '.cjs'], wasmFile: 'tree-sitter-javascript.wasm' },
-  { name: 'python', extensions: ['.py', '.pyw'], wasmFile: 'tree-sitter-python.wasm' },
-  { name: 'java', extensions: ['.java'], wasmFile: 'tree-sitter-java.wasm' },
-  { name: 'csharp', extensions: ['.cs'], wasmFile: 'tree-sitter-c_sharp.wasm' },
-  { name: 'go', extensions: ['.go'], wasmFile: 'tree-sitter-go.wasm' },
-  { name: 'rust', extensions: ['.rs'], wasmFile: 'tree-sitter-rust.wasm' },
-  { name: 'c', extensions: ['.c', '.h'], wasmFile: 'tree-sitter-c.wasm' },
-  { name: 'cpp', extensions: ['.cpp', '.hpp', '.cc', '.hh', '.cxx', '.hxx'], wasmFile: 'tree-sitter-cpp.wasm' },
-  { name: 'ruby', extensions: ['.rb'], wasmFile: 'tree-sitter-ruby.wasm' },
-  { name: 'php', extensions: ['.php'], wasmFile: 'tree-sitter-php.wasm' },
-];
-
-// Extension → language entry mapping
-const EXT_MAP = new Map<string, LanguageEntry>();
-for (const lang of LANGUAGES) {
-  for (const ext of lang.extensions) {
-    EXT_MAP.set(ext, lang);
-  }
-}
-
-export function getLanguageForExtension(ext: string): LanguageEntry | undefined {
-  return EXT_MAP.get(ext.toLowerCase());
-}
-
-export function getGrammarWasmPath(langName: string): string | null {
-  const entry = LANGUAGES.find(l => l.name === langName);
-  if (!entry) return null;
-
-  // Try to resolve from tree-sitter-wasms npm package first
-  const require = createRequire(import.meta.url);
-  try {
-    const wasmsDir = dirname(require.resolve('tree-sitter-wasms/package.json'));
-    const npmPath = join(wasmsDir, 'out', entry.wasmFile);
-    if (existsSync(npmPath)) return npmPath;
-  } catch {
-    // tree-sitter-wasms not installed, try fallbacks
-  }
-
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-
-  // Check grammars/ directory relative to project
-  const candidates = [
-    // Custom grammars dir (env override)
-    process.env.CLAST_GRAMMARS_DIR ? join(process.env.CLAST_GRAMMARS_DIR, entry.wasmFile) : null,
-    // Plugin root
-    process.env.CLAUDE_PLUGIN_ROOT ? join(process.env.CLAUDE_PLUGIN_ROOT, 'grammars', entry.wasmFile) : null,
-    // Relative to dist/
-    join(__dirname, '..', '..', 'grammars', entry.wasmFile),
-    // CWD
-    join(process.cwd(), 'grammars', entry.wasmFile),
-  ].filter(Boolean) as string[];
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-
-  return null;
-}
-
-export function getSupportedExtensions(enabledLanguages?: string[]): string[] {
-  const result: string[] = [];
-  for (const lang of LANGUAGES) {
-    if (!enabledLanguages || enabledLanguages.includes(lang.name)) {
-      result.push(...lang.extensions);
-    }
-  }
-  return result;
-}
-
-export function getAllLanguageNames(): string[] {
-  return LANGUAGES.map(l => l.name);
-}

package/src/server/register-tools.ts

@@ -1,30 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ClastDatabase } from '../db/index.js';
-import type { ParserManager } from '../parser/index.js';
-import type { FileWatcher } from '../watcher/index.js';
-import type { CommentGenerator } from '../llm/comment-generator.js';
-
-import { registerSearchTool } from './tools/clast-search.js';
-import { registerCallGraphTool } from './tools/clast-call-graph.js';
-import { registerFileSummaryTool } from './tools/clast-file-summary.js';
-import { registerGetContextTool } from './tools/clast-get-context.js';
-import { registerStatusTool } from './tools/clast-status.js';
-import { registerReindexTool } from './tools/clast-reindex.js';
-import { registerCommentTool } from './tools/clast-comment.js';
-
-export function registerAllTools(
-  server: McpServer,
-  db: ClastDatabase,
-  parser: ParserManager,
-  watcher: FileWatcher,
-  commentGen: CommentGenerator,
-  projectRoot: string
-): void {
-  registerSearchTool(server, db);
-  registerCallGraphTool(server, db);
-  registerFileSummaryTool(server, db);
-  registerGetContextTool(server, db);
-  registerStatusTool(server, db, watcher);
-  registerReindexTool(server, db, parser, projectRoot);
-  registerCommentTool(server, db, commentGen);
-}

package/src/server/tools/clast-call-graph.ts

@@ -1,82 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ClastDatabase } from '../../db/index.js';
-
-export function registerCallGraphTool(server: McpServer, db: ClastDatabase): void {
-  server.tool(
-    'clast_call_graph',
-    'Get the call graph for a function or method: what it calls (callees) and what calls it (callers). Use this BEFORE refactoring to understand impact — shows the full dependency chain with file paths and line numbers. Supports depth 1-5.',
-    {
-      name: z.string().describe('Function or method name to trace'),
-      depth: z.number().int().min(1).max(5).default(2).describe('How many levels deep to traverse'),
-      direction: z.enum(['callers', 'callees', 'both']).default('both').describe('Direction to traverse'),
-    },
-    async ({ name, depth, direction }) => {
-      const node = db.queries.getNodeByName(name);
-      if (node.length === 0) {
-        return {
-          content: [{
-            type: 'text' as const,
-            text: JSON.stringify({ error: `No symbol found with name "${name}"` }),
-          }],
-        };
-      }
-
-      const result: Record<string, unknown> = {
-        symbol: {
-          name: node[0]!.name,
-          type: node[0]!.type,
-          filePath: node[0]!.file_path,
-          startLine: node[0]!.start_line,
-          endLine: node[0]!.end_line,
-          signature: node[0]!.signature,
-        },
-      };
-
-      if (direction === 'callers' || direction === 'both') {
-        const callers = db.queries.getCallersOf(name, depth);
-        result.callers = callers.map(n => ({
-          name: n.name,
-          type: n.type,
-          filePath: n.file_path,
-          startLine: n.start_line,
-          signature: n.signature,
-        }));
-      }
-
-      if (direction === 'callees' || direction === 'both') {
-        const callees = db.queries.getCalleesOf(name, depth);
-        result.callees = callees.map(n => ({
-          name: n.name,
-          type: n.type,
-          filePath: n.file_path,
-          startLine: n.start_line,
-          signature: n.signature,
-        }));
-      }
-
-      // Also include direct call edge details for the primary node
-      if (node[0]) {
-        const edges = db.queries.getCallEdgesForNode(node[0].id);
-        result.directCalls = {
-          outgoing: edges.outgoing.map(e => ({
-            calleeName: e.callee_name,
-            line: e.line,
-            resolved: e.callee_id !== null,
-          })),
-          incoming: edges.incoming.map(e => ({
-            callerId: e.caller_id,
-            line: e.line,
-          })),
-        };
-      }
-
-      return {
-        content: [{
-          type: 'text' as const,
-          text: JSON.stringify(result, null, 2),
-        }],
-      };
-    }
-  );
-}