@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-S5CCLZL3.js

@@ -0,0 +1,99 @@
+// src/tool-use.ts
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "@wrongstack/core/types";
+var toolUseTool = {
+  name: "tool_use",
+  category: "Meta",
+  description: "Directly execute any registered tool by its exact name, bypassing normal discovery. This is a powerful meta-tool intended for cases where the agent has a clear plan and knows precisely which tool to invoke.",
+  usageHint: "ADVANCED META TOOL \u2014 USE WITH CARE:\n\n- Only use when you are certain of the exact tool name and its expected input shape.\n- Prefer using the normal tool calling mechanism when possible.\n- Very useful in batch-tool-use or when orchestrating complex workflows programmatically.\n- The call still goes through full permission checks and capability validation.",
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The tool being invoked through this indirection — the whole point of a
+  // permission decision here is WHICH tool is being reached.
+  subjectKey: "tool",
+  mutating: true,
+  timeoutMs: 6e4,
+  capabilities: ["tool.mutate.any"],
+  icon: "meta",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool: {
+        type: "string",
+        description: 'The exact registered name of the tool to invoke (e.g. "bash", "read", "codebase-search").'
+      },
+      input: {
+        type: "object",
+        description: "The input object matching the target tool's inputSchema."
+      }
+    },
+    required: ["tool"]
+  },
+  async execute(input, ctx) {
+    const start = Date.now();
+    if (!input?.tool) {
+      return {
+        tool: "unknown",
+        success: false,
+        error: "tool_use: tool name is required",
+        executionMs: 0
+      };
+    }
+    const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
+    if (!tool) {
+      return {
+        tool: input.tool,
+        success: false,
+        error: `tool_use: tool "${input.tool}" not found`,
+        executionMs: Date.now() - start
+      };
+    }
+    if (tool.name === toolUseTool.name) {
+      return {
+        tool: input.tool,
+        success: false,
+        error: "tool_use: recursive meta-tool execution is not allowed",
+        executionMs: Date.now() - start
+      };
+    }
+    if (tool.permission === "deny") {
+      return {
+        tool: input.tool,
+        success: false,
+        error: `tool_use: tool "${input.tool}" is denied by policy`,
+        executionMs: Date.now() - start
+      };
+    }
+    const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+    if (typeof governedExecute !== "function") {
+      return {
+        tool: input.tool,
+        success: false,
+        error: "tool_use: governed nested execution is unavailable; call the tool directly",
+        executionMs: Date.now() - start
+      };
+    }
+    try {
+      const result = await governedExecute(input.tool, input.input ?? {});
+      return {
+        tool: input.tool,
+        success: result.success,
+        ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
+        executionMs: Date.now() - start
+      };
+    } catch (e) {
+      return {
+        tool: input.tool,
+        success: false,
+        error: e instanceof Error ? e.message : String(e),
+        executionMs: Date.now() - start
+      };
+    }
+  }
+};
+
+export {
+  toolUseTool
+};
+//# sourceMappingURL=chunk-S5CCLZL3.js.map

package/dist/chunk-TVTCSBJF.js

@@ -0,0 +1,122 @@
+import {
+  resolveIndexDir
+} from "./chunk-OA6YJIWL.js";
+
+// src/codebase-index/binary-frame.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BINARY_FRAME_MAGIC = 87;
+var MAX_BINARY_FRAME_BYTES = 256 * 1024 * 1024;
+var MAX_INBOUND_BINARY_FRAME_BYTES = 64 * 1024 * 1024;
+function isBinaryFrame(firstByte) {
+  return firstByte === BINARY_FRAME_MAGIC;
+}
+function encodeBinaryFrame(message) {
+  const payload = encode(normalizeUndefined(message));
+  const header = Buffer.allocUnsafe(5);
+  header[0] = BINARY_FRAME_MAGIC;
+  header.writeUInt32BE(payload.length, 1);
+  return Buffer.concat([header, payload], 5 + payload.length);
+}
+function normalizeUndefined(value) {
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? null : value.toISOString();
+  }
+  if (value instanceof Map) return normalizeUndefined(Object.fromEntries(value));
+  if (value instanceof Set) return normalizeUndefined([...value]);
+  if (value instanceof Error) {
+    return normalizeUndefined({ name: value.name, message: value.message, stack: value.stack });
+  }
+  if (value instanceof RegExp) return String(value);
+  if (value instanceof URL) return value.toJSON();
+  if (Buffer.isBuffer(value)) return { type: "Buffer", data: [...value] };
+  if (Array.isArray(value)) return value.map((entry) => normalizeUndefined(entry));
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === void 0) continue;
+    out[key] = normalizeUndefined(entry);
+  }
+  return out;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function decodeBinaryFrame(payload) {
+  return decode(payload);
+}
+function encodeJsonFrame(message) {
+  return `${JSON.stringify(normalizeUndefined(message))}
+`;
+}
+
+// src/codebase-index/project-server-endpoint.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var PROJECT_INDEX_SERVER_PROTOCOL_VERSION = 1;
+var PROJECT_INDEX_SERVER_METADATA_FILE = "server.json";
+var PROJECT_INDEX_SERVER_SOCKET_DIR = `wsci-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}`;
+var buildIdCache;
+function projectIndexServerBuildId(entrypoint) {
+  const href = entrypoint instanceof URL ? entrypoint.href : entrypoint;
+  const cleanHref = href.split(/[?#]/, 1)[0] ?? href;
+  const file = cleanHref.startsWith("file:") ? fileURLToPath(cleanHref) : path.resolve(cleanHref);
+  try {
+    const stat = fs.statSync(file);
+    if (buildIdCache?.file === file && buildIdCache.mtimeMs === stat.mtimeMs && buildIdCache.size === stat.size) {
+      return buildIdCache.buildId;
+    }
+    const buildId = createHash("sha256").update(fs.readFileSync(file)).digest("hex").slice(0, 24);
+    buildIdCache = { file, mtimeMs: stat.mtimeMs, size: stat.size, buildId };
+    return buildId;
+  } catch {
+    return `unreadable:${path.basename(file)}`;
+  }
+}
+function normalizeLocalPath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function projectIndexServerKey(projectRoot, indexDir) {
+  const resolvedIndexDir = normalizeLocalPath(resolveIndexDir(projectRoot, indexDir));
+  return createHash("sha256").update(resolvedIndexDir).digest("hex").slice(0, 24);
+}
+function projectIndexServerEndpoint(projectRoot, indexDir) {
+  const key = projectIndexServerKey(projectRoot, indexDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-codebase-index-v${PROJECT_INDEX_SERVER_PROTOCOL_VERSION}-${key}`;
+  }
+  return path.join(os.tmpdir(), PROJECT_INDEX_SERVER_SOCKET_DIR, `${key}.sock`);
+}
+function projectIndexServerMetadataPath(projectRoot, indexDir) {
+  return path.join(
+    path.resolve(resolveIndexDir(projectRoot, indexDir)),
+    PROJECT_INDEX_SERVER_METADATA_FILE
+  );
+}
+
+// src/codebase-index/project-server-protocol.ts
+var PROJECT_INDEX_SERVER_MAX_FRAME_CHARS = 64 * 1024 * 1024;
+function encodeProjectServerMessage(message) {
+  return encodeJsonFrame(message);
+}
+
+export {
+  MAX_BINARY_FRAME_BYTES,
+  MAX_INBOUND_BINARY_FRAME_BYTES,
+  isBinaryFrame,
+  encodeBinaryFrame,
+  decodeBinaryFrame,
+  PROJECT_INDEX_SERVER_PROTOCOL_VERSION,
+  projectIndexServerBuildId,
+  projectIndexServerEndpoint,
+  projectIndexServerMetadataPath,
+  PROJECT_INDEX_SERVER_MAX_FRAME_CHARS,
+  encodeProjectServerMessage
+};
+//# sourceMappingURL=chunk-TVTCSBJF.js.map

package/dist/chunk-U4D5S3VQ.js

@@ -0,0 +1,21 @@
+// src/_concurrency.ts
+async function mapWithConcurrency(items, limit, fn) {
+  if (items.length === 0) return [];
+  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (true) {
+      const i = nextIndex++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: effectiveLimit }, worker));
+  return results;
+}
+
+export {
+  mapWithConcurrency
+};
+//# sourceMappingURL=chunk-U4D5S3VQ.js.map

package/dist/chunk-U4VAATKP.js

@@ -0,0 +1,193 @@
+// src/batch-tool-use.ts
+import {
+  GOVERNED_TOOL_EXECUTOR_META_KEY
+} from "@wrongstack/core/types";
+var BATCHABLE_TOOL_NAMES = [
+  "read",
+  "glob",
+  "grep",
+  "tree",
+  "codebase-stats",
+  "codebase-search",
+  "language_info",
+  "tool_search",
+  "memory_for_file",
+  "memory_for_path",
+  "memory_search"
+];
+var BATCHABLE_TOOLS = new Set(BATCHABLE_TOOL_NAMES);
+var MAX_BATCH_CALLS = 8;
+var MAX_PARALLEL_BATCH_CALLS = 3;
+var batchToolUseTool = {
+  name: "batch_tool_use",
+  category: "Meta",
+  description: "Execute a small batch of independent, read-only discovery calls. Process, mutation, browser-action, MCP, delegation, and nested meta tools are not eligible.",
+  usageHint: `BOUNDED READ-ONLY BATCHING:
+
+- Use only for a small set of independent reads or searches that are all needed now.
+- Do not wrap normal sequential reasoning or every tool call in a batch.
+- \`parallel: true\` (default) runs at most three eligible calls concurrently.
+- \`stop_on_error: true\` makes it fail fast on the first error.
+- Eligible tools: ${BATCHABLE_TOOL_NAMES.join(", ")}.`,
+  permission: "confirm",
+  // Scheduling barrier: keep the outer meta-call out of ToolExecutor's
+  // non-mutating fan-out even though every eligible inner tool is read-only.
+  mutating: true,
+  timeoutMs: 12e4,
+  capabilities: ["tool.meta"],
+  icon: "meta",
+  inputSchema: {
+    type: "object",
+    properties: {
+      calls: {
+        type: "array",
+        maxItems: MAX_BATCH_CALLS,
+        items: {
+          type: "object",
+          properties: {
+            tool: {
+              type: "string",
+              enum: [...BATCHABLE_TOOL_NAMES],
+              description: "An explicitly batch-safe, read-only discovery tool."
+            },
+            input: { type: "object" }
+          },
+          required: ["tool"]
+        },
+        description: `Up to ${MAX_BATCH_CALLS} independent, batch-safe read calls.`
+      },
+      stop_on_error: {
+        type: "boolean",
+        description: "Stop execution on first error (default: false)"
+      },
+      parallel: {
+        type: "boolean",
+        description: "Execute calls in parallel (default: true)"
+      }
+    },
+    required: ["calls"]
+  },
+  async execute(input, ctx, _opts) {
+    if (!input?.calls || input.calls.length === 0) {
+      return {
+        results: [],
+        total: 0,
+        succeeded: 0,
+        failed: 0,
+        stop_on_error: false
+      };
+    }
+    if (input.calls.length > MAX_BATCH_CALLS) {
+      throw new Error(`batch_tool_use: calls must contain at most ${MAX_BATCH_CALLS} items`);
+    }
+    const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
+    if (typeof governedExecute !== "function") {
+      return {
+        results: input.calls.map((call) => ({
+          tool: call.tool,
+          success: false,
+          error: "governed nested execution is unavailable; call the tool directly",
+          executionMs: 0
+        })),
+        total: input.calls.length,
+        succeeded: 0,
+        failed: input.calls.length,
+        stop_on_error: input.stop_on_error ?? false
+      };
+    }
+    const results = [];
+    let succeeded = 0;
+    let failed = 0;
+    if (input.parallel !== false) {
+      const allResults = await mapWithConcurrency(
+        input.calls,
+        MAX_PARALLEL_BATCH_CALLS,
+        (call) => executeSingle(call, ctx, governedExecute)
+      );
+      results.push(...allResults);
+      succeeded = allResults.filter((r) => r.success).length;
+      failed = allResults.filter((r) => !r.success).length;
+    } else {
+      for (const call of input.calls) {
+        const result = await executeSingle(call, ctx, governedExecute);
+        results.push(result);
+        if (result.success) {
+          succeeded++;
+        } else {
+          failed++;
+          if (input.stop_on_error) break;
+        }
+      }
+    }
+    return {
+      results,
+      total: input.calls.length,
+      succeeded,
+      failed,
+      stop_on_error: input.stop_on_error ?? false
+    };
+  }
+};
+async function mapWithConcurrency(items, limit, run) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await run(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
+async function executeSingle(call, ctx, governedExecute) {
+  const start = Date.now();
+  if (call.tool === batchToolUseTool.name) {
+    return {
+      tool: call.tool,
+      success: false,
+      error: "recursive batch_tool_use execution is not allowed",
+      executionMs: Date.now() - start
+    };
+  }
+  const tool = (ctx.catalogTools ?? ctx.tools).find(
+    (candidate) => candidate.name === call.tool
+  );
+  if (!tool) {
+    return {
+      tool: call.tool,
+      success: false,
+      error: `tool "${call.tool}" not found`,
+      executionMs: Date.now() - start
+    };
+  }
+  if (!BATCHABLE_TOOLS.has(tool.name) || tool.mutating) {
+    return {
+      tool: call.tool,
+      success: false,
+      error: `tool "${call.tool}" is not eligible for batch execution; call it directly. Allowed: ${BATCHABLE_TOOL_NAMES.join(", ")}`,
+      executionMs: Date.now() - start
+    };
+  }
+  try {
+    const result = await governedExecute(call.tool, call.input);
+    return {
+      tool: call.tool,
+      success: result.success,
+      ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
+      executionMs: Date.now() - start
+    };
+  } catch (e) {
+    return {
+      tool: call.tool,
+      success: false,
+      error: e instanceof Error ? e.message : String(e),
+      executionMs: Date.now() - start
+    };
+  }
+}
+
+export {
+  batchToolUseTool
+};
+//# sourceMappingURL=chunk-U4VAATKP.js.map

package/dist/chunk-UKU2ZX4C.js

@@ -0,0 +1,203 @@
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/diff.ts
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { buildChildEnv } from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
+var MAX_FILE_DUMP_BYTES = 5 * 1024 * 1024;
+var MAX_GIT_DIFF_CHARS = 1e5;
+var diffTool = {
+  name: "diff",
+  category: "Filesystem",
+  description: "Show file content with line numbers, staged/working-tree diffs via git, or commit/branch diffs. A safer and more structured alternative to raw `git diff` via shell.",
+  usageHint: 'USE FOR CODE REVIEW AND CHANGE INSPECTION:\n\n- `files` + no `a`/`b` \u2192 show file content with line numbers (NOT a unified diff; no +/- prefixes). Result `mode` is "dump".\n- `a` and/or `b` \u2192 git-style commit/branch diff (unified format, real +/- prefixes).\n- `staged: true` \u2192 only show staged changes.\n- `mode` only affects the git-diff path: "stat" runs `git diff --stat`; "side-by-side" is not supported and falls back to unified (result `mode` reports what was produced).\n- `context` sets the unified-diff context line count on the git path (`-U<n>`); the dump path has no context notion.\n\nNOTE: For a true file-vs-file unified diff, supply `a` and `b` so the tool delegates to `git diff`. The `files`-only path is a line-numbered dump, not a diff.\n\nThis tool has important safety guards against flag injection (see previous security findings).',
+  permission: "auto",
+  mutating: false,
+  maxOutputBytes: 262144,
+  capabilities: ["fs.read"],
+  icon: "diff",
+  timeoutMs: 1e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Working directory for the diff operation (defaults to project root)."
+      },
+      files: {
+        type: "string",
+        description: 'Files or globs to diff (e.g. "src/**/*.ts" or comma-separated list).'
+      },
+      a: {
+        type: "string",
+        description: "First ref/commit/branch for git diff (e.g. HEAD, main, a commit hash)."
+      },
+      b: {
+        type: "string",
+        description: "Second ref/commit/branch for git diff."
+      },
+      staged: {
+        type: "boolean",
+        description: "If true, only show changes that are staged in git."
+      },
+      mode: {
+        type: "string",
+        enum: ["unified", "side-by-side", "stat"],
+        description: 'Output format for the git-diff path. "unified" is default; "stat" shows a summary only; "side-by-side" is not supported and falls back to unified. The `files`-only dump path ignores this.'
+      },
+      context: {
+        type: "integer",
+        minimum: 0,
+        description: "Number of context lines for git unified diffs (default: 3, passed as -U<n>). Ignored by the `files`-only dump path."
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    if (input.a !== void 0 || input.b !== void 0) {
+      return await gitDiff(input, ctx, opts.signal);
+    }
+    return await fileDiff(input, ctx, opts.signal);
+  }
+};
+async function gitDiff(input, ctx, signal) {
+  if (input.a?.startsWith("-")) {
+    throw new ToolValidationError({
+      message: `diff: unsafe ref "${input.a}" \u2014 refs may not begin with '-' (flag injection)`,
+      field: "a"
+    });
+  }
+  if (input.b?.startsWith("-")) {
+    throw new ToolValidationError({
+      message: `diff: unsafe ref "${input.b}" \u2014 refs may not begin with '-' (flag injection)`,
+      field: "b"
+    });
+  }
+  const requestedMode = input.mode ?? "unified";
+  const statMode = requestedMode === "stat";
+  const effectiveMode = statMode ? "stat" : "unified";
+  const sideBySideNote = requestedMode === "side-by-side" ? "side-by-side output is not supported; a unified diff was produced instead." : void 0;
+  const gitDir = findGitDir(ctx.cwd);
+  if (!gitDir) {
+    return { diff: "", files: [], truncated: false, mode: effectiveMode };
+  }
+  const args = ["diff", "--no-color"];
+  if (statMode) args.push("--stat");
+  if (!statMode && input.context !== void 0) {
+    const contextLines = Math.max(0, Math.floor(input.context));
+    if (Number.isFinite(contextLines)) args.push(`-U${contextLines}`);
+  }
+  if (input.staged) args.push("--staged");
+  if (input.a) args.push(input.a);
+  if (input.b) args.push(input.b);
+  if (input.files) {
+    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+    args.push("--", ...files.map((f) => f.trim()));
+  }
+  const result = await runGit(args, gitDir, signal);
+  let diff = result.stdout;
+  let truncated = false;
+  if (diff.length > MAX_GIT_DIFF_CHARS) {
+    let clipped = diff.slice(0, MAX_GIT_DIFF_CHARS);
+    const nl = clipped.lastIndexOf("\n");
+    if (nl > 0) clipped = clipped.slice(0, nl);
+    diff = `${clipped}
+\u2026[git diff truncated: ${result.stdout.length - clipped.length} of ${result.stdout.length} characters omitted]`;
+    truncated = true;
+  }
+  return {
+    diff,
+    files: [],
+    truncated,
+    mode: effectiveMode,
+    note: sideBySideNote
+  };
+}
+function findGitDir(cwd) {
+  let dir = cwd;
+  for (let i = 0; i < 20; i++) {
+    try {
+      const stat2 = statSync(path.join(dir, ".git"));
+      if (stat2.isDirectory()) return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function runGit(args, cwd, signal) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn("git", args, {
+      cwd,
+      signal,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    child.stdout?.on("data", (c) => {
+      stdout += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      stderr += c.toString();
+    });
+    child.on("close", (code) => resolve({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve({ stdout: "", stderr: e.message, exitCode: 1 }));
+  });
+}
+async function fileDiff(input, ctx, _signal) {
+  void input.context;
+  const files = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((f) => f.trim()).filter(Boolean) : [];
+  if (files.length === 0) {
+    return {
+      diff: "No files specified",
+      files: [],
+      truncated: false,
+      mode: "dump"
+    };
+  }
+  const results = [];
+  let truncated = false;
+  for (const file of files) {
+    const absPath = await safeResolveReal(file, ctx);
+    const stat2 = await fs.stat(absPath).catch(() => null);
+    if (!stat2?.isFile()) continue;
+    if (stat2.size > MAX_FILE_DUMP_BYTES) {
+      truncated = true;
+      results.push(
+        `--- ${file} (skipped: ${stat2.size} bytes exceeds the ${MAX_FILE_DUMP_BYTES} limit; use the read tool with offset/limit) ---`
+      );
+      continue;
+    }
+    const content = await fs.readFile(absPath, "utf8");
+    const lines = content.split(/\r?\n/);
+    results.push(formatWithLineNumbers(file, lines));
+  }
+  return {
+    diff: results.join("\n\n"),
+    files,
+    truncated,
+    // Honest mode: this path always produces a line-numbered dump — it never
+    // honors `mode`, so it must not echo the requested value back.
+    mode: "dump",
+    note: input.mode !== void 0 ? "The `files`-only path is a line-numbered dump; `mode` only affects the git-diff path (`a`/`b`)." : void 0
+  };
+}
+function formatWithLineNumbers(file, lines) {
+  const width = String(lines.length).length;
+  const numbered = lines.map((line, i) => `${String(i + 1).padStart(width)} | ${line}`).join("\n");
+  return `--- ${file} (line-numbered dump, not a unified diff) ---
+${numbered}`;
+}
+
+export {
+  diffTool
+};
+//# sourceMappingURL=chunk-UKU2ZX4C.js.map