@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-TEBQ4VPZ.js

@@ -0,0 +1,163 @@
+// src/codebase-index/languages.ts
+import * as path from "node:path";
+var EXT_TO_LANG = {
+  // TypeScript / JavaScript (first-class TS compiler API)
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx",
+  // First-class native/spawn parsers (+ regex fallback)
+  ".go": "go",
+  ".py": "py",
+  ".pyi": "py",
+  ".pyw": "py",
+  ".rs": "rs",
+  ".json": "json",
+  ".jsonc": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // C family
+  ".c": "c",
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".hh": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  // JVM / .NET
+  ".java": "java",
+  ".cs": "csharp",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".sc": "scala",
+  // Scripting
+  ".php": "php",
+  ".rb": "ruby",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".pl": "other",
+  ".pm": "other",
+  // Systems / functional
+  ".zig": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  // Shell / data / docs / web
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".ps1": "shell",
+  ".sql": "sql",
+  ".md": "md",
+  ".mdx": "md",
+  ".toml": "toml",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "css",
+  ".less": "css",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".proto": "proto",
+  ".graphql": "graphql",
+  ".gql": "graphql"
+};
+var INDEXABLE_EXTENSIONS = Object.freeze(
+  [...new Set(Object.keys(EXT_TO_LANG).map((e) => e.toLowerCase()))].sort()
+);
+var SPECIAL_FILENAMES = {
+  makefile: "other",
+  gnumakefile: "other",
+  dockerfile: "other",
+  "docker-compose.yml": "yaml",
+  "docker-compose.yaml": "yaml",
+  "cmakelists.txt": "other",
+  gemfile: "ruby",
+  rakefile: "ruby",
+  procfile: "other",
+  justfile: "other"
+};
+function detectLang(file) {
+  const base = path.basename(file);
+  const lowerBase = base.toLowerCase();
+  if (lowerBase.endsWith(".d.ts") || lowerBase.endsWith(".d.mts") || lowerBase.endsWith(".d.cts")) {
+    return "ts";
+  }
+  const special = SPECIAL_FILENAMES[lowerBase];
+  if (special) return special;
+  const ext = path.extname(base).toLowerCase();
+  if (!ext) return null;
+  return EXT_TO_LANG[ext] ?? null;
+}
+function isIndexablePath(file) {
+  return detectLang(file) !== null;
+}
+var LANG_FAMILY = {
+  // Single-compilation-unit family: a .vue/.svelte script block is JS/TS and
+  // imports from — and is imported by — plain .ts files.
+  ts: "js",
+  tsx: "js",
+  js: "js",
+  jsx: "js",
+  vue: "js",
+  svelte: "js",
+  go: "go",
+  py: "py",
+  rs: "rs",
+  // The JVM resolves across languages: Kotlin and Scala call Java directly.
+  java: "jvm",
+  kotlin: "jvm",
+  scala: "jvm",
+  csharp: "dotnet",
+  // A .h header is consumed by both C and C++ translation units.
+  c: "c",
+  cpp: "c",
+  ruby: "ruby",
+  php: "php",
+  swift: "swift",
+  dart: "dart",
+  elixir: "elixir",
+  haskell: "haskell",
+  zig: "zig",
+  lua: "lua",
+  r: "r",
+  shell: "shell",
+  sql: "sql",
+  json: "data",
+  yaml: "data",
+  toml: "data",
+  html: "web",
+  css: "web",
+  proto: "proto",
+  graphql: "graphql",
+  md: "other",
+  other: "other"
+};
+var LANG_FAMILY_ENTRIES = Object.freeze(
+  Object.entries(LANG_FAMILY).map(
+    ([lang, family]) => Object.freeze([lang, family])
+  )
+);
+function languageFamily(lang) {
+  return LANG_FAMILY[lang] ?? "other";
+}
+
+export {
+  EXT_TO_LANG,
+  INDEXABLE_EXTENSIONS,
+  detectLang,
+  isIndexablePath,
+  LANG_FAMILY_ENTRIES,
+  languageFamily
+};
+//# sourceMappingURL=chunk-TEBQ4VPZ.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-UCYQTZ7F.js

@@ -0,0 +1,113 @@
+// src/codebase-index/parser-output.ts
+var CALL_TYPES = /* @__PURE__ */ new Set([
+  "call",
+  "type_ref",
+  "inherit",
+  "implement",
+  "import"
+]);
+function coerceSymbols(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const candidate = entry;
+    if (typeof candidate.name !== "string" || typeof candidate.kind !== "string") return [];
+    return [
+      {
+        name: candidate.name,
+        kind: candidate.kind,
+        line: typeof candidate.line === "number" ? candidate.line : 1,
+        col: typeof candidate.col === "number" ? candidate.col : 0,
+        signature: typeof candidate.signature === "string" ? candidate.signature : "",
+        scope: typeof candidate.scope === "string" ? candidate.scope : ""
+      }
+    ];
+  });
+}
+function coerceRefs(value, lang) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const candidate = entry;
+    if (typeof candidate.toName !== "string" || !candidate.toName) return [];
+    if (typeof candidate.callType !== "string" || !CALL_TYPES.has(candidate.callType)) return [];
+    const module = typeof candidate.module === "string" && candidate.module ? candidate.module : void 0;
+    return [
+      {
+        fromId: 0,
+        toName: candidate.toName,
+        callType: candidate.callType,
+        line: typeof candidate.line === "number" ? candidate.line : 1,
+        lang,
+        module
+      }
+    ];
+  });
+}
+function parseParserOutput(stdout, lang) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { symbols: [], refs: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { symbols: [], refs: [] };
+  }
+  if (Array.isArray(parsed)) return { symbols: coerceSymbols(parsed), refs: [] };
+  const record = parsed;
+  return {
+    symbols: coerceSymbols(record.symbols),
+    refs: dedupeRefs(coerceRefs(record.refs, lang))
+  };
+}
+function parseParserBatchOutput(stdout, lang) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const results = parsed.results;
+  if (!Array.isArray(results)) return [];
+  return results.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
+    const candidate = entry;
+    if (typeof candidate.file !== "string" || !candidate.file) return [];
+    return [
+      {
+        file: candidate.file,
+        error: typeof candidate.error === "string" && candidate.error ? candidate.error : void 0,
+        symbols: coerceSymbols(candidate.symbols),
+        refs: dedupeRefs(coerceRefs(candidate.refs, lang))
+      }
+    ];
+  });
+}
+function dedupeRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((ref) => {
+    const key = `${ref.toName}:${ref.callType}:${ref.line}:${ref.module ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/codebase-index/spawn-gate.ts
+var chain = Promise.resolve();
+function withSpawnGate(fn) {
+  const run = chain.then(fn, fn);
+  chain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+
+export {
+  parseParserOutput,
+  parseParserBatchOutput,
+  withSpawnGate
+};
+//# sourceMappingURL=chunk-UCYQTZ7F.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