@wrongstack/tools 0.298.3 → 0.299.0

package/dist/codebase-index/index.js

@@ -2602,6 +2602,136 @@ function mapWriterRefRow(row) {
 }
 
 // src/codebase-index/writer-graph-reader.ts
+var MAX_SQL_VARS = 900;
+function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
+  const results = [];
+  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
+    const chunk = ids.slice(start, start + MAX_SQL_VARS);
+    const placeholders = chunk.map(() => "?").join(",");
+    const sql = buildSql(placeholders);
+    results.push(...stmt(sql).all(...chunk, ...extraArgs));
+  }
+  return results;
+}
+function chunkedIdScalar(stmt, ids, buildSql, extraArgs = []) {
+  let total = 0;
+  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
+    const chunk = ids.slice(start, start + MAX_SQL_VARS);
+    const placeholders = chunk.map(() => "?").join(",");
+    const sql = buildSql(placeholders);
+    const rows = stmt(sql).all(...chunk, ...extraArgs);
+    total += rows[0]?.n ?? 0;
+  }
+  return total;
+}
+function mapCallSiteRow(row) {
+  return {
+    symbol: {
+      id: row.sym_id,
+      name: row.sym_name,
+      kind: row.sym_kind,
+      lang: row.sym_lang,
+      file: row.sym_file,
+      line: row.sym_line,
+      signature: row.sym_signature
+    },
+    callType: row.call_type,
+    line: row.ref_line
+  };
+}
+function resolveSymbolIds(stmt, symbolName, file) {
+  const baseSql = file ? `SELECT id FROM symbols WHERE name = ? AND file = ? ORDER BY id` : `SELECT id FROM symbols WHERE name = ? ORDER BY id`;
+  const args = file ? [symbolName, file] : [symbolName];
+  const rows = stmt(baseSql).all(...args);
+  return rows.map((r) => r.id);
+}
+function findIncomingCallsByName(stmt, symbolName, file, limit) {
+  const targetIds = resolveSymbolIds(stmt, symbolName, file);
+  if (targetIds.length === 0) return { calls: [], symbolFound: false, ambiguous: false, totalMatches: 0 };
+  let matchIds = targetIds;
+  let ambiguous = false;
+  if (file !== void 0) {
+    const allNamedIds = resolveSymbolIds(stmt, symbolName, void 0);
+    if (allNamedIds.length > targetIds.length) {
+      matchIds = allNamedIds;
+      ambiguous = true;
+    }
+  }
+  const useFallback = !file;
+  const rows = chunkedIdQuery(
+    stmt,
+    matchIds,
+    (ph) => `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.from_id
+       WHERE r.to_id IN (${ph})
+       ORDER BY r.line, r.id`,
+    []
+  );
+  if (useFallback) {
+    const fallbackRows = stmt(
+      `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.from_id
+       WHERE r.to_id IS NULL AND r.to_name = ?
+       ORDER BY r.line, r.id`
+    ).all(symbolName);
+    rows.push(...fallbackRows);
+  }
+  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  const allCalls = rows.map(mapCallSiteRow);
+  return { calls: allCalls.slice(0, limit), symbolFound: true, ambiguous, totalMatches: allCalls.length };
+}
+function findOutgoingCallsByName(stmt, symbolName, file, limit) {
+  const sourceIds = resolveSymbolIds(stmt, symbolName, file);
+  if (sourceIds.length === 0) return { calls: [], symbolFound: false, unresolvedCount: 0, totalMatches: 0 };
+  const unresolvedCount = chunkedIdScalar(
+    stmt,
+    sourceIds,
+    (ph) => `SELECT COUNT(*) AS n FROM refs WHERE from_id IN (${ph}) AND to_id IS NULL`
+  );
+  const rows = chunkedIdQuery(
+    stmt,
+    sourceIds,
+    (ph) => `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.to_id
+       WHERE r.from_id IN (${ph})
+         AND r.to_id IS NOT NULL  -- INNER JOIN already excludes NULL to_id; this is defensive belt-and-suspenders
+       ORDER BY r.line, r.id`,
+    []
+  );
+  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  const calls = rows.map(mapCallSiteRow).slice(0, limit);
+  return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
+}
 function findRefsToWithStatement(stmt, symbolId) {
   return stmt(
     "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE to_id = ? OR to_name = (SELECT name FROM symbols WHERE id = ?)"
@@ -3837,6 +3967,20 @@ var IndexStore = class _IndexStore {
       return false;
     }
   }
+  /**
+   * Find all symbols that reference the named target symbol (incoming callers).
+   * Accepts a name instead of an id so the agent doesn't need a prior lookup.
+   */
+  findIncomingCallsByName(symbolName, file, limit = 100) {
+    return findIncomingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
+  /**
+   * Find all symbols that the named source symbol references (outgoing callees).
+   * Accepts a name instead of an id so the agent doesn't need a prior lookup.
+   */
+  findOutgoingCallsByName(symbolName, file, limit = 100) {
+    return findOutgoingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
   /**
    * Find all references TO a given symbol (who calls / uses this symbol?).
    */
@@ -5264,6 +5408,22 @@ function symbolGraphService(args) {
     indexStorePool.release(store);
   }
 }
+function incomingCallsService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.findIncomingCallsByName(args.symbol, args.file, args.limit ?? 100);
+  } finally {
+    indexStorePool.release(store);
+  }
+}
+function outgoingCallsService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.findOutgoingCallsByName(args.symbol, args.file, args.limit ?? 100);
+  } finally {
+    indexStorePool.release(store);
+  }
+}
 
 // src/codebase-index/background-indexer.ts
 init_languages();
@@ -5501,6 +5661,10 @@ async function callInline(op, args, opts) {
         return fileGraphService(args);
       case "symbolGraph":
         return symbolGraphService(args);
+      case "incomingCalls":
+        return incomingCallsService(args);
+      case "outgoingCalls":
+        return outgoingCallsService(args);
       default:
         throw new Error(`unknown index op: ${String(op)}`);
     }
@@ -5694,6 +5858,12 @@ async function fileGraphService2(args) {
 async function symbolGraphService2(args) {
   return callIndexOp("symbolGraph", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
 }
+async function incomingCallsService2(args) {
+  return callIndexOp("incomingCalls", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
+async function outgoingCallsService2(args) {
+  return callIndexOp("outgoingCalls", args, { timeoutMs: DEFAULT_QUERY_TIMEOUT_MS });
+}
 function shutdownCodebaseIndexServer(projectRoot, indexDir, reason) {
   return shutdownProjectIndexServer(projectRoot, indexDir, reason);
 }
@@ -5777,6 +5947,214 @@ var codebaseIndexTool = {
   }
 };
 
+// src/codebase-index/codebase-incoming-calls-tool.ts
+var codebaseIncomingCallsTool = {
+  name: "codebase-incoming-calls",
+  category: "Project",
+  icon: "index",
+  description: "Find all callers of a function, method, or symbol \u2014 who invokes or references it. Uses the codebase index ref graph for instant, exact results. Always use this instead of grep when checking impact of a change.",
+  usageHint: 'CALL THIS BEFORE REFACTORING OR CHANGING ANY FUNCTION:\n\n- NEVER use grep or manual line reading to check where a function is called.\n- ALWAYS call codebase-incoming-calls({ symbol: "funcName" }) first.\n- Returns exact files, line numbers, caller signatures, and call types in milliseconds.\n- Use `file` to disambiguate when multiple symbols share a name.\n- Combine with codebase-outgoing-calls to see what the symbol itself calls.\nIf the index is not built, run codebase-index first.',
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "The function/method/type name to find callers for"
+      },
+      file: {
+        type: "string",
+        description: "Scope to a specific file when multiple symbols share the same name"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum call sites to return (default 50, max 200)",
+        minimum: 1,
+        maximum: 200
+      }
+    },
+    required: ["symbol"]
+  },
+  async execute(input, ctx) {
+    const state = getIndexState();
+    if (state.indexing && !state.ready) {
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Indexing in progress (${state.currentFile}/${state.totalFiles} files) \u2014 retry in a moment.`
+      };
+    }
+    if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s).` : "Try /codebase-reindex.";
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
+      };
+    }
+    const limit = Math.max(1, Math.min(Math.trunc(input.limit ?? 50), 200));
+    const { calls, symbolFound, ambiguous, totalMatches } = await incomingCallsService2(
+      {
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        symbol: input.symbol,
+        file: input.file,
+        limit
+      }
+    );
+    if (!symbolFound) {
+      let hasPersistedIndex = state.ready;
+      if (!hasPersistedIndex) {
+        try {
+          const stats = await codebaseIndexStats({
+            projectRoot: ctx.projectRoot,
+            indexDir: codebaseIndexDirOverride(ctx)
+          });
+          hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+        } catch {
+        }
+      }
+      if (!hasPersistedIndex) {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: "No persisted index data found. Run codebase-index to build it."
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        note: `Symbol "${input.symbol}" not found in the index. Use codebase-search to verify the name.`
+      };
+    }
+    const notes = [];
+    if (totalMatches > limit) {
+      notes.push(`Results capped at ${limit} of ${totalMatches} call sites. Increase \`limit\` or use \`file\` to narrow.`);
+    }
+    if (ambiguous) {
+      notes.push(`Symbol "${input.symbol}" exists in multiple files. Results include callers of all same-named symbols. Use codebase-search to find the exact file and pass it as \`file\`.`);
+    }
+    return {
+      symbol: input.symbol,
+      calls,
+      total: calls.length,
+      ...notes.length > 0 ? { note: notes.join(" ") } : {}
+    };
+  }
+};
+
+// src/codebase-index/codebase-outgoing-calls-tool.ts
+var codebaseOutgoingCallsTool = {
+  name: "codebase-outgoing-calls",
+  category: "Project",
+  icon: "index",
+  description: "Find all functions/methods/symbols that a given symbol calls or depends on \u2014 its callees. Uses the codebase index ref graph for instant, exact results. Use this to understand a function's dependencies before modifying it.",
+  usageHint: 'USE THIS TO UNDERSTAND A FUNCTION\'S DEPENDENCIES:\n\n- Call codebase-outgoing-calls({ symbol: "funcName" }) to see everything it calls.\n- Returns exact files, line numbers, callee signatures, and call types in milliseconds.\n- Use `file` to disambiguate when multiple symbols share a name.\n- Pair with codebase-incoming-calls for a complete impact picture: incoming = who calls you, outgoing = what you call.\nIf the index is not built, run codebase-index first.',
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  timeoutMs: 35e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      symbol: {
+        type: "string",
+        description: "The function/method/type name to find callees for"
+      },
+      file: {
+        type: "string",
+        description: "Scope to a specific file when multiple symbols share the same name"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum call sites to return (default 50, max 200)",
+        minimum: 1,
+        maximum: 200
+      }
+    },
+    required: ["symbol"]
+  },
+  async execute(input, ctx) {
+    const state = getIndexState();
+    if (state.indexing && !state.ready) {
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Indexing in progress (${state.currentFile}/${state.totalFiles} files) \u2014 retry in a moment.`
+      };
+    }
+    if (state.lastError) {
+      const circuit = state.circuit;
+      const retryHint = circuit.state === "open" ? `Indexing is paused (circuit open, retry in ${Math.ceil(circuit.cooldownRemainingMs / 1e3)}s).` : "Try /codebase-reindex.";
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        indexStatus: `Index build failed: ${state.lastError}. ${retryHint}`
+      };
+    }
+    const limit = Math.max(1, Math.min(Math.trunc(input.limit ?? 50), 200));
+    const { calls, symbolFound, unresolvedCount, totalMatches } = await outgoingCallsService2(
+      {
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        symbol: input.symbol,
+        file: input.file,
+        limit
+      }
+    );
+    if (!symbolFound) {
+      let hasPersistedIndex = state.ready;
+      if (!hasPersistedIndex) {
+        try {
+          const stats = await codebaseIndexStats({
+            projectRoot: ctx.projectRoot,
+            indexDir: codebaseIndexDirOverride(ctx)
+          });
+          hasPersistedIndex = stats.totalFiles > 0 || stats.lastIndexed !== null;
+        } catch {
+        }
+      }
+      if (!hasPersistedIndex) {
+        return {
+          symbol: input.symbol,
+          calls: [],
+          total: 0,
+          indexStatus: "No persisted index data found. Run codebase-index to build it."
+        };
+      }
+      return {
+        symbol: input.symbol,
+        calls: [],
+        total: 0,
+        note: `Symbol "${input.symbol}" not found in the index. Use codebase-search to verify the name.`
+      };
+    }
+    const notes = [];
+    if (totalMatches > limit) {
+      notes.push(`Results capped at ${limit} of ${totalMatches} call sites. Increase \`limit\` or use \`file\` to narrow.`);
+    }
+    if (unresolvedCount > 0) {
+      notes.push(`${unresolvedCount} unresolved reference(s) not shown \u2014 their targets could not be resolved during indexing.`);
+    }
+    return {
+      symbol: input.symbol,
+      calls,
+      total: calls.length,
+      ...notes.length > 0 ? { note: notes.join(" ") } : {}
+    };
+  }
+};
+
 // src/codebase-index/codebase-search-tool.ts
 var codebaseSearchTool = {
   name: "codebase-search",
@@ -6492,9 +6870,11 @@ export {
   buildIndexableText,
   cancelPendingReindexes,
   checkCodebaseIndexServerHealth,
+  codebaseIncomingCallsTool,
   codebaseIndexDirOverride,
   codebaseIndexStats,
   codebaseIndexTool,
+  codebaseOutgoingCallsTool,
   codebaseSearchTool,
   codebaseStatsTool,
   deadCodeScanTool,
@@ -6503,6 +6883,7 @@ export {
   ensureCodebaseIndexServer,
   fileGraphService2 as fileGraphService,
   getIndexState,
+  incomingCallsService2 as incomingCallsService,
   indexCircuitBreaker,
   internalKindToLspKind,
   isIndexReady,
@@ -6511,6 +6892,7 @@ export {
   isIndexing,
   lspKindToInternalKind,
   onIndexStateChange,
+  outgoingCallsService2 as outgoingCallsService,
   packageGraphService2 as packageGraphService,
   resetIndexCircuitBreaker,
   resolveIndexDir,

package/dist/codebase-index/project-server.js

@@ -2671,6 +2671,136 @@ function mapWriterRefRow(row) {
 }
 
 // src/codebase-index/writer-graph-reader.ts
+var MAX_SQL_VARS = 900;
+function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
+  const results = [];
+  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
+    const chunk = ids.slice(start, start + MAX_SQL_VARS);
+    const placeholders = chunk.map(() => "?").join(",");
+    const sql = buildSql(placeholders);
+    results.push(...stmt(sql).all(...chunk, ...extraArgs));
+  }
+  return results;
+}
+function chunkedIdScalar(stmt, ids, buildSql, extraArgs = []) {
+  let total = 0;
+  for (let start = 0; start < ids.length; start += MAX_SQL_VARS) {
+    const chunk = ids.slice(start, start + MAX_SQL_VARS);
+    const placeholders = chunk.map(() => "?").join(",");
+    const sql = buildSql(placeholders);
+    const rows = stmt(sql).all(...chunk, ...extraArgs);
+    total += rows[0]?.n ?? 0;
+  }
+  return total;
+}
+function mapCallSiteRow(row) {
+  return {
+    symbol: {
+      id: row.sym_id,
+      name: row.sym_name,
+      kind: row.sym_kind,
+      lang: row.sym_lang,
+      file: row.sym_file,
+      line: row.sym_line,
+      signature: row.sym_signature
+    },
+    callType: row.call_type,
+    line: row.ref_line
+  };
+}
+function resolveSymbolIds(stmt, symbolName, file) {
+  const baseSql = file ? `SELECT id FROM symbols WHERE name = ? AND file = ? ORDER BY id` : `SELECT id FROM symbols WHERE name = ? ORDER BY id`;
+  const args = file ? [symbolName, file] : [symbolName];
+  const rows = stmt(baseSql).all(...args);
+  return rows.map((r) => r.id);
+}
+function findIncomingCallsByName(stmt, symbolName, file, limit) {
+  const targetIds = resolveSymbolIds(stmt, symbolName, file);
+  if (targetIds.length === 0) return { calls: [], symbolFound: false, ambiguous: false, totalMatches: 0 };
+  let matchIds = targetIds;
+  let ambiguous = false;
+  if (file !== void 0) {
+    const allNamedIds = resolveSymbolIds(stmt, symbolName, void 0);
+    if (allNamedIds.length > targetIds.length) {
+      matchIds = allNamedIds;
+      ambiguous = true;
+    }
+  }
+  const useFallback = !file;
+  const rows = chunkedIdQuery(
+    stmt,
+    matchIds,
+    (ph) => `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.from_id
+       WHERE r.to_id IN (${ph})
+       ORDER BY r.line, r.id`,
+    []
+  );
+  if (useFallback) {
+    const fallbackRows = stmt(
+      `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.from_id
+       WHERE r.to_id IS NULL AND r.to_name = ?
+       ORDER BY r.line, r.id`
+    ).all(symbolName);
+    rows.push(...fallbackRows);
+  }
+  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  const allCalls = rows.map(mapCallSiteRow);
+  return { calls: allCalls.slice(0, limit), symbolFound: true, ambiguous, totalMatches: allCalls.length };
+}
+function findOutgoingCallsByName(stmt, symbolName, file, limit) {
+  const sourceIds = resolveSymbolIds(stmt, symbolName, file);
+  if (sourceIds.length === 0) return { calls: [], symbolFound: false, unresolvedCount: 0, totalMatches: 0 };
+  const unresolvedCount = chunkedIdScalar(
+    stmt,
+    sourceIds,
+    (ph) => `SELECT COUNT(*) AS n FROM refs WHERE from_id IN (${ph}) AND to_id IS NULL`
+  );
+  const rows = chunkedIdQuery(
+    stmt,
+    sourceIds,
+    (ph) => `SELECT
+         s.id   AS sym_id,
+         s.name AS sym_name,
+         s.kind AS sym_kind,
+         s.lang AS sym_lang,
+         s.file AS sym_file,
+         s.line AS sym_line,
+         s.signature AS sym_signature,
+         r.call_type,
+         r.line AS ref_line
+       FROM refs r
+       JOIN symbols s ON s.id = r.to_id
+       WHERE r.from_id IN (${ph})
+         AND r.to_id IS NOT NULL  -- INNER JOIN already excludes NULL to_id; this is defensive belt-and-suspenders
+       ORDER BY r.line, r.id`,
+    []
+  );
+  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  const calls = rows.map(mapCallSiteRow).slice(0, limit);
+  return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
+}
 function findRefsToWithStatement(stmt, symbolId) {
   return stmt(
     "SELECT id, from_id, to_name, to_id, call_type, line FROM refs WHERE to_id = ? OR to_name = (SELECT name FROM symbols WHERE id = ?)"
@@ -3902,6 +4032,20 @@ var IndexStore = class _IndexStore {
       return false;
     }
   }
+  /**
+   * Find all symbols that reference the named target symbol (incoming callers).
+   * Accepts a name instead of an id so the agent doesn't need a prior lookup.
+   */
+  findIncomingCallsByName(symbolName, file, limit = 100) {
+    return findIncomingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
+  /**
+   * Find all symbols that the named source symbol references (outgoing callees).
+   * Accepts a name instead of an id so the agent doesn't need a prior lookup.
+   */
+  findOutgoingCallsByName(symbolName, file, limit = 100) {
+    return findOutgoingCallsByName((sql) => this.stmt(sql), symbolName, file, limit);
+  }
   /**
    * Find all references TO a given symbol (who calls / uses this symbol?).
    */
@@ -4486,6 +4630,22 @@ function symbolGraphService(args) {
     indexStorePool.release(store);
   }
 }
+function incomingCallsService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.findIncomingCallsByName(args.symbol, args.file, args.limit ?? 100);
+  } finally {
+    indexStorePool.release(store);
+  }
+}
+function outgoingCallsService(args) {
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
+  try {
+    return store.findOutgoingCallsByName(args.symbol, args.file, args.limit ?? 100);
+  } finally {
+    indexStorePool.release(store);
+  }
+}
 
 // src/codebase-index/project-server.ts
 init_languages();
@@ -4639,6 +4799,8 @@ var statsCache = new GenerationLruCache(1);
 var packageGraphCache = new GenerationLruCache(1);
 var fileGraphCache = new GenerationLruCache(32);
 var symbolGraphCache = new GenerationLruCache(64);
+var incomingCallsCache = new GenerationLruCache(128);
+var outgoingCallsCache = new GenerationLruCache(128);
 var indexActivity = {
   indexing: false,
   currentFile: 0,
@@ -4658,7 +4820,9 @@ var stopMemoryWatchdog = startSharedHeapWatchdog({
     statsCache: statsCache.size,
     packageGraphCache: packageGraphCache.size,
     fileGraphCache: fileGraphCache.size,
-    symbolGraphCache: symbolGraphCache.size
+    symbolGraphCache: symbolGraphCache.size,
+    incomingCallsCache: incomingCallsCache.size,
+    outgoingCallsCache: outgoingCallsCache.size
   })
 });
 var lastProgressBroadcastAt = 0;
@@ -4674,6 +4838,8 @@ function clearQueryCaches() {
   packageGraphCache.clear();
   fileGraphCache.clear();
   symbolGraphCache.clear();
+  incomingCallsCache.clear();
+  outgoingCallsCache.clear();
 }
 function cachedRead(cache, key, load) {
   const generation = indexActivity.generation;
@@ -4881,6 +5047,16 @@ async function dispatchOperation(state, message) {
         message.args.fileFilter,
         () => symbolGraphService(fixedArgs(message.args))
       );
+    case "incomingCalls": {
+      const callArgs = fixedArgs(message.args);
+      const cacheKey = JSON.stringify([callArgs.symbol, callArgs.file ?? "", callArgs.limit ?? 100]);
+      return cachedRead(incomingCallsCache, cacheKey, () => incomingCallsService(callArgs));
+    }
+    case "outgoingCalls": {
+      const callArgs = fixedArgs(message.args);
+      const cacheKey = JSON.stringify([callArgs.symbol, callArgs.file ?? "", callArgs.limit ?? 100]);
+      return cachedRead(outgoingCallsCache, cacheKey, () => outgoingCallsService(callArgs));
+    }
     default:
       throw new Error(`unknown index operation: ${String(op)}`);
   }

package/dist/codebase-index/schema.d.ts

@@ -96,6 +96,29 @@ export interface Ref {
     callType: CallType;
     line: number;
 }
+/**
+ * A call site — the enriched result of an incoming/outgoing calls query.
+ *
+ * Unlike the raw `Ref` type, this carries the full caller/callee symbol
+ * metadata (name, kind, file, line, signature) so the agent gets a
+ * self-contained answer without a second lookup.
+ */
+export interface CallSite {
+    /** The symbol that makes or receives the call. */
+    symbol: {
+        id: number;
+        name: string;
+        kind: SymbolKind;
+        lang: SymbolLang;
+        file: string;
+        line: number;
+        signature: string;
+    };
+    /** Kind of reference: call, type_ref, inherit, implement, import. */
+    callType: CallType;
+    /** Source line where the reference occurs. */
+    line: number;
+}
 /** A node in the code-map dependency graph. */
 export interface GraphNode {
     id: string;