@wrongstack/tools 0.298.2 → 0.299.0

package/dist/tool-tier.js

@@ -7082,6 +7082,10 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
   const start = Date.now();
   const pidStr = String(process.pid);
   const hostStr = os2.hostname();
+  try {
+    await fs6.mkdir(path9.dirname(lockfilePath), { recursive: true });
+  } catch {
+  }
   while (Date.now() - start < timeoutMs) {
     try {
       await fs6.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });
@@ -7747,6 +7751,16 @@ function parseKillCommand(command) {
   if (pgrepMatch) {
     return null;
   }
+  const posixScriptMatch = normalized.match(SCRIPT_KILL_RE_POSIX);
+  if (posixScriptMatch) {
+    return {
+      name: "kill-script",
+      signal: "FORCE",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
   return null;
 }
 async function getProtectedEntries() {
@@ -10538,6 +10552,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 = ?)"
@@ -11773,6 +11917,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?).
    */
@@ -13155,6 +13313,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
 var DEFAULT_FULL_INDEX_TIMEOUT_MS = 24e4;
@@ -13366,6 +13540,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)}`);
     }
@@ -13461,6 +13639,12 @@ async function codebaseIndexStats(args, opts = {}) {
     signal: opts.signal
   });
 }
+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 });
+}
 
 // src/codebase-index/codebase-index-tool.ts
 var codebaseIndexTool = {
@@ -13525,6 +13709,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",
@@ -24896,6 +25288,8 @@ var TIER1_TOOLS = [
   editTool,
   codebaseStatsTool,
   codebaseSearchTool,
+  codebaseIncomingCallsTool,
+  codebaseOutgoingCallsTool,
   codebaseIndexTool,
   bashTool,
   grepTool,
@@ -24946,6 +25340,8 @@ var builtinTools = [
   editTool,
   codebaseStatsTool,
   codebaseSearchTool,
+  codebaseIncomingCallsTool,
+  codebaseOutgoingCallsTool,
   codebaseIndexTool,
   deadCodeScanTool,
   replaceTool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/tools",
-  "version": "0.298.2",
+  "version": "0.299.0",
   "license": "MIT",
   "description": "WrongStack built-in tools: read/write/edit, bash/exec, grep/glob, git, fetch, test, lint, and more.",
   "repository": {
@@ -250,8 +250,8 @@
     "@typescript/typescript6": "^6.0.2",
     "turndown": "^7.2.4",
     "undici": "^8.9.0",
-    "@wrongstack/core": "0.298.2",
-    "@wrongstack/kanban": "0.298.2"
+    "@wrongstack/core": "0.299.0",
+    "@wrongstack/kanban": "0.299.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",