@wrongstack/tools 0.298.2 → 0.299.0

package/dist/codebase-index/worker-protocol.d.ts

@@ -5,6 +5,7 @@
  * Errors cross the boundary as strings and are re-wrapped by the host.
  */
 import type { CodeMapGraph, IndexResult, IndexStats, SearchResult } from './schema.js';
+import type { IncomingCallsResult, OutgoingCallsResult } from './index-service.js';
 export interface IndexOpArgs {
     projectRoot: string;
     indexDir?: string | undefined;
@@ -33,6 +34,11 @@ export interface FileGraphOpArgs extends StatsOpArgs {
 export interface SymbolGraphOpArgs extends StatsOpArgs {
     fileFilter: string;
 }
+export interface CallRefsOpArgs extends StatsOpArgs {
+    symbol: string;
+    file?: string | undefined;
+    limit?: number | undefined;
+}
 export interface SearchOpResult {
     results: SearchResult[];
     total: number;
@@ -63,6 +69,14 @@ export interface OpShapes {
         args: SymbolGraphOpArgs;
         result: CodeMapGraph;
     };
+    incomingCalls: {
+        args: CallRefsOpArgs;
+        result: IncomingCallsResult;
+    };
+    outgoingCalls: {
+        args: CallRefsOpArgs;
+        result: OutgoingCallsResult;
+    };
 }
 export type OpName = keyof OpShapes;
 export type HostToWorker = {

package/dist/codebase-index/worker.js

@@ -2658,6 +2658,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 = ?)"
@@ -3889,6 +4019,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?).
    */
@@ -4473,6 +4617,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/worker.ts
 if (!parentPort) throw new Error("codebase-index worker must be started as a worker thread");
@@ -4505,6 +4665,10 @@ async function dispatch(msg) {
       return fileGraphService(msg.args);
     case "symbolGraph":
       return symbolGraphService(msg.args);
+    case "incomingCalls":
+      return incomingCallsService(msg.args);
+    case "outgoingCalls":
+      return outgoingCallsService(msg.args);
     default:
       throw new Error(`unknown index op: ${msg.op}`);
   }

package/dist/codebase-index/writer-graph-reader.d.ts

@@ -1,7 +1,30 @@
 import type { DatabaseSync } from 'node:sqlite';
-import type { CodeMapGraph, Ref } from './schema.js';
+import type { CallSite, CodeMapGraph, Ref } from './schema.js';
 type Statement = ReturnType<DatabaseSync['prepare']>;
 type PrepareStatement = (sql: string) => Statement;
+/**
+ * Find all symbols that CALL/USE the named target symbol (incoming callers).
+ *
+ * Returns one `CallSite` per ref edge, with the caller's full metadata so the
+ * agent sees file, line, kind, and signature without a second lookup.
+ */
+export declare function findIncomingCallsByName(stmt: PrepareStatement, symbolName: string, file: string | undefined, limit: number): {
+    calls: CallSite[];
+    symbolFound: boolean;
+    ambiguous: boolean;
+    totalMatches: number;
+};
+/**
+ * Find all symbols that the named source symbol CALLS/USES (outgoing callees).
+ *
+ * Returns one `CallSite` per ref edge, with the callee's full metadata.
+ */
+export declare function findOutgoingCallsByName(stmt: PrepareStatement, symbolName: string, file: string | undefined, limit: number): {
+    calls: CallSite[];
+    symbolFound: boolean;
+    unresolvedCount: number;
+    totalMatches: number;
+};
 export declare function findRefsToWithStatement(stmt: PrepareStatement, symbolId: number): Ref[];
 export declare function findRefsFromWithStatement(stmt: PrepareStatement, symbolId: number): Ref[];
 export declare function getPackageGraphWithStatement(stmt: PrepareStatement): CodeMapGraph;

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

@@ -1,4 +1,4 @@
-import type { CodeMapGraph, FileMeta, IndexStats, Symbol as IndexSymbol, Ref, SearchResult, SymbolKind, SymbolLang } from './schema.js';
+import type { CallSite, CodeMapGraph, FileMeta, IndexStats, Symbol as IndexSymbol, Ref, SearchResult, SymbolKind, SymbolLang } from './schema.js';
 import { type WriterSearchFilter } from './writer-search-helpers.js';
 import { StorePool } from './writer-store-pool.js';
 export { codebaseIndexDirOverride, resolveIndexDir } from './writer-helpers.js';
@@ -252,6 +252,26 @@ export declare class IndexStore {
         minBytes?: number;
         minFreeRatio?: number;
     }): boolean;
+    /**
+     * 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: string, file?: string, limit?: number): {
+        calls: CallSite[];
+        symbolFound: boolean;
+        ambiguous: boolean;
+        totalMatches: number;
+    };
+    /**
+     * 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: string, file?: string, limit?: number): {
+        calls: CallSite[];
+        symbolFound: boolean;
+        unresolvedCount: number;
+        totalMatches: number;
+    };
     /**
      * Find all references TO a given symbol (who calls / uses this symbol?).
      */

package/dist/exec.js

@@ -1284,6 +1284,10 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
   const start = Date.now();
   const pidStr = String(process.pid);
   const hostStr = os2.hostname();
+  try {
+    await fs2.mkdir(path4.dirname(lockfilePath), { recursive: true });
+  } catch {
+  }
   while (Date.now() - start < timeoutMs) {
     try {
       await fs2.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });