@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-553IQUMO.js

@@ -0,0 +1,478 @@
+import {
+  capSubject,
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  mapWithConcurrency
+} from "./chunk-U4D5S3VQ.js";
+import {
+  loadGitignoreMatcher
+} from "./chunk-LIJQMYYX.js";
+import {
+  isBinaryBuffer,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/grep.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
+import {
+  buildChildEnv,
+  compileGlob,
+  DEFAULT_WALK_IGNORE_DIRS,
+  expectDefined
+} from "@wrongstack/core/utils";
+var DEFAULT_IGNORE = new Set(DEFAULT_WALK_IGNORE_DIRS);
+var NATIVE_SCAN_CONCURRENCY = 32;
+var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
+var NATIVE_MAX_FILE_BYTES = 1e6;
+var RG_MAX_QUEUE_CHUNKS = 128;
+var RG_MAX_QUEUE_CHARS = 8 * 1024 * 1024;
+var grepTool = {
+  name: "grep",
+  category: "Search",
+  description: "Search exact file contents using a regular expression. Use index-backed `codebase-search` first for symbol or concept discovery when it is live. Prefers ripgrep for speed and features when available.",
+  usageHint: 'EXACT-TEXT AND REGEX SEARCH:\n\n- When `codebase-search` is live, use it first for symbols and concepts; use `grep` for exact text, regexes, unsupported content, and concrete usage sites.\n- `pattern` is a regular expression.\n- Use `output_mode: "content"` (default) to get matching lines with context.\n- Use `"files_with_matches"` when you only need the list of files.\n- Use `"count"` for quick statistics.\n- `glob` and `path` let you narrow the search scope significantly.\n- Always prefer this over `bash grep` when searching code.',
+  selection: {
+    doNotUseWhen: "you only need to locate files by name or path pattern.",
+    useInstead: ["glob"]
+  },
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  icon: "search",
+  maxOutputBytes: 131072,
+  timeoutMs: 1e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for in file contents."
+      },
+      path: {
+        type: "string",
+        description: "Limit search to this directory or file (relative to project root)."
+      },
+      glob: {
+        type: "string",
+        description: 'Glob filter for which files to include (e.g. "**/*.ts", "src/**").'
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: "Return style: detailed matches, just file list, or count only."
+      },
+      context_lines: {
+        type: "integer",
+        description: "How many lines of surrounding context to include with each match."
+      },
+      case_insensitive: {
+        type: "boolean",
+        description: "Ignore case when matching."
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum number of matches to return."
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = grepTool.executeStream;
+    if (!executeStream) throw new Error("grepTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("grep: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    if (!input?.pattern) {
+      throw new ToolValidationError({
+        message: "grep: pattern is required",
+        field: "pattern"
+      });
+    }
+    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    const mode = input.output_mode ?? "content";
+    const limit = Math.max(1, Math.min(input.limit ?? 200, 2e3));
+    const validation = compileUserRegex(input.pattern, input.case_insensitive ? "i" : "");
+    if (!validation.ok) {
+      throw new ToolValidationError({
+        message: `grep: ${validation.reason}`,
+        field: "pattern"
+      });
+    }
+    const rgAvailable = await detectRg();
+    if (rgAvailable) {
+      try {
+        yield* runRgStream(input, base, mode, limit, opts.signal);
+        return;
+      } catch {
+      }
+    }
+    yield { type: "log", text: "Falling back to native grep\u2026" };
+    const out = await runNative(input, base, mode, limit, opts.signal);
+    yield { type: "final", output: out };
+  }
+};
+var rgAvailabilityCache;
+function __resetRgDetectionForTests() {
+  rgAvailabilityCache = void 0;
+}
+function detectRg() {
+  rgAvailabilityCache ??= new Promise((resolve) => {
+    try {
+      const p = spawn("rg", ["--version"], {
+        env: buildChildEnv(),
+        stdio: "ignore",
+        signal: AbortSignal.timeout(1e4),
+        windowsHide: true
+      });
+      p.on("error", () => resolve(false));
+      p.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
+  return rgAvailabilityCache;
+}
+async function* runRgStream(input, base, mode, limit, signal) {
+  const args = ["--no-heading"];
+  if (input.case_insensitive) args.push("-i");
+  if (mode === "files_with_matches") args.push("-l");
+  if (mode === "count") args.push("-c");
+  if (mode === "content") {
+    args.push("-n");
+    if (input.context_lines) args.push("-C", String(input.context_lines));
+  }
+  for (const ignored of DEFAULT_IGNORE) {
+    args.push("--glob", `!${ignored}/**`, "--glob", `!**/${ignored}/**`);
+  }
+  const gitignorePath = path.join(base, ".gitignore");
+  if (await fs.access(gitignorePath).then(
+    () => true,
+    () => false
+  )) {
+    args.push("--ignore-file", gitignorePath);
+  }
+  if (input.glob) args.push("--glob", input.glob);
+  args.push("--", input.pattern, base);
+  const matches = [];
+  let buf = "";
+  let totalLines = 0;
+  let totalCount = 0;
+  let batchSinceFlush = 0;
+  const FLUSH_AT = 16;
+  const MAX_BUF_BYTES = 1e6;
+  let bufOverflow = false;
+  const child = spawn("rg", args, {
+    signal,
+    env: buildChildEnv(),
+    // rg diagnostics are not part of the tool result. Ignoring stderr avoids
+    // an unread pipe filling up and pinning the child when rg reports many
+    // filesystem errors.
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  const queue = [];
+  let queuedChars = 0;
+  let waiter;
+  let paused = false;
+  const wake = () => {
+    if (waiter) {
+      const w = waiter;
+      waiter = void 0;
+      w();
+    }
+  };
+  const pauseIfFlooded = () => {
+    if (paused || queue.length < RG_MAX_QUEUE_CHUNKS && queuedChars < RG_MAX_QUEUE_CHARS) return;
+    paused = true;
+    child.stdout?.pause();
+  };
+  const resumeIfDrained = () => {
+    if (!paused || queue.length >= RG_MAX_QUEUE_CHUNKS || queuedChars >= RG_MAX_QUEUE_CHARS) return;
+    paused = false;
+    child.stdout?.resume();
+  };
+  const onStdoutData = (c) => {
+    const data = c.toString();
+    queue.push({ kind: "out", data });
+    queuedChars += data.length;
+    wake();
+    pauseIfFlooded();
+  };
+  const onError = (e) => {
+    queue.push({ kind: "error", data: e.message });
+    wake();
+  };
+  const onClose = () => {
+    queue.push({ kind: "close", data: "" });
+    wake();
+  };
+  child.stdout?.on("data", onStdoutData);
+  child.on("error", onError);
+  child.on("close", onClose);
+  let pendingBatch = [];
+  let errored = false;
+  let closed = false;
+  try {
+    for (; ; ) {
+      while (queue.length === 0) {
+        await new Promise((r) => {
+          waiter = r;
+        });
+      }
+      const c = expectDefined(queue.shift());
+      queuedChars = Math.max(0, queuedChars - c.data.length);
+      resumeIfDrained();
+      if (c.kind === "error") {
+        errored = true;
+        continue;
+      }
+      if (c.kind === "close") {
+        closed = true;
+        break;
+      }
+      buf += c.data;
+      if (buf.length > MAX_BUF_BYTES && !bufOverflow) {
+        bufOverflow = true;
+        buf = buf.slice(-MAX_BUF_BYTES);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+      const idx = buf.lastIndexOf("\n");
+      if (idx === -1) continue;
+      const ready = buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+      for (const line of ready.split("\n")) {
+        if (!line) continue;
+        totalLines++;
+        if (mode === "count") totalCount += parseRgCountLine(line);
+        if (matches.length < limit) {
+          matches.push(line);
+          pendingBatch.push(line);
+          batchSinceFlush++;
+        }
+      }
+      if (batchSinceFlush >= FLUSH_AT) {
+        yield {
+          type: "partial_output",
+          text: pendingBatch.join("\n"),
+          data: { matches_so_far: matches.length }
+        };
+        pendingBatch = [];
+        batchSinceFlush = 0;
+      }
+    }
+    if (buf.trim()) {
+      for (const line of buf.split("\n")) {
+        if (!line) continue;
+        totalLines++;
+        if (mode === "count") totalCount += parseRgCountLine(line);
+        if (matches.length < limit) {
+          matches.push(line);
+          pendingBatch.push(line);
+        }
+      }
+    }
+    if (pendingBatch.length > 0) {
+      yield {
+        type: "partial_output",
+        text: pendingBatch.join("\n"),
+        data: { matches_so_far: matches.length }
+      };
+    }
+    if (errored) throw new Error("rg: spawn error");
+    yield {
+      type: "final",
+      output: {
+        matches,
+        count: mode === "count" ? totalCount : totalLines,
+        truncated: totalLines > limit || bufOverflow,
+        used: "rg"
+      }
+    };
+  } finally {
+    child.stdout?.off("data", onStdoutData);
+    child.off("error", onError);
+    child.off("close", onClose);
+    child.stdout?.destroy();
+    queue.length = 0;
+    queuedChars = 0;
+    waiter = void 0;
+    if (!closed && child.exitCode === null) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+}
+function parseRgCountLine(line) {
+  const idx = line.lastIndexOf(":");
+  if (idx === -1) return 0;
+  const n = Number.parseInt(line.slice(idx + 1), 10);
+  return Number.isFinite(n) ? n : 0;
+}
+async function runNative(input, base, mode, limit, signal) {
+  const flags = input.case_insensitive ? "i" : "";
+  const compiled = compileUserRegex(input.pattern, flags);
+  if (!compiled.ok) {
+    throw new ToolValidationError({
+      message: `grep: ${compiled.reason}`,
+      field: "pattern"
+    });
+  }
+  const re = compiled.regex;
+  const globRe = input.glob ? compileGlob(input.glob) : null;
+  const isGitIgnored = await loadGitignoreMatcher(base);
+  const matches = [];
+  const countOnlyFirstHit = mode === "count" && limit === 1;
+  const maxBytes = mode === "content" ? NATIVE_MAX_FILE_BYTES : Math.min(NATIVE_MAX_FILE_BYTES, 256 * 1024);
+  let total = 0;
+  let stopped = false;
+  const scanFile = async (full, name) => {
+    if (stopped || signal.aborted) return;
+    if (globRe && !globRe.test(name) && !globRe.test(full)) return;
+    if (globRe) globRe.lastIndex = 0;
+    try {
+      const stat2 = await fs.stat(full);
+      if (!stat2.isFile() || stat2.size > maxBytes || stopped || signal.aborted) return;
+      const file = await fs.open(full, "r");
+      try {
+        let bytesReadTotal = 0;
+        let lineNumber = 0;
+        let fileHits = 0;
+        let leftover = "";
+        let binaryChecked = false;
+        const buffer = Buffer.allocUnsafe(Math.min(NATIVE_READ_CHUNK_BYTES, maxBytes));
+        while (!stopped && !signal.aborted && bytesReadTotal < maxBytes) {
+          const remaining = maxBytes - bytesReadTotal;
+          const { bytesRead } = await file.read(
+            buffer,
+            0,
+            Math.min(buffer.length, remaining),
+            null
+          );
+          if (bytesRead === 0) break;
+          const chunk = buffer.subarray(0, bytesRead);
+          if (!binaryChecked) {
+            binaryChecked = true;
+            if (isBinaryBuffer(chunk)) return;
+          }
+          bytesReadTotal += bytesRead;
+          const text = leftover + chunk.toString("utf8");
+          const lines = text.split(/\r?\n/);
+          leftover = lines.pop() ?? "";
+          for (const rawLine of lines) {
+            if (stopped || signal.aborted) break;
+            lineNumber++;
+            const ln = capSubject(rawLine);
+            re.lastIndex = 0;
+            if (!re.test(ln)) continue;
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (fileHits === 1 && matches.length < limit) matches.push(full);
+              break;
+            } else if (fileHits === 1 && matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : 0}`);
+            }
+            if (countOnlyFirstHit || mode !== "content" && matches.length >= limit) {
+              stopped = true;
+              break;
+            }
+          }
+          if (mode === "files_with_matches" && fileHits > 0) break;
+        }
+        if (!stopped && !signal.aborted && leftover.length > 0) {
+          lineNumber++;
+          const ln = capSubject(leftover);
+          re.lastIndex = 0;
+          if (re.test(ln)) {
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (matches.length < limit) matches.push(full);
+            } else if (matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : fileHits}`);
+            }
+          }
+        }
+        if (fileHits > 0) {
+          if (mode === "count") {
+            const idx = matches.findIndex((entry) => entry.startsWith(`${full}:`));
+            if (idx !== -1) matches[idx] = `${full}:${fileHits}`;
+          }
+          if (mode === "files_with_matches" && matches.length >= limit) stopped = true;
+        }
+        if (mode === "content" && matches.length >= limit) stopped = true;
+        if (mode === "count" && matches.length >= limit && (countOnlyFirstHit || mode !== "count"))
+          stopped = true;
+      } finally {
+        await file.close();
+      }
+    } catch {
+    }
+  };
+  const walk = async (dir, relPrefix) => {
+    if (stopped || signal.aborted) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const files = [];
+    const subdirs = [];
+    for (const e of entries) {
+      if (stopped) return;
+      if (DEFAULT_IGNORE.has(e.name)) continue;
+      if (e.isSymbolicLink()) continue;
+      const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (isGitIgnored(rel, true)) continue;
+        subdirs.push({ full, rel });
+      } else if (e.isFile()) {
+        if (isGitIgnored(rel, false)) continue;
+        files.push({ full, name: e.name });
+      }
+    }
+    await mapWithConcurrency(
+      files,
+      NATIVE_SCAN_CONCURRENCY,
+      ({ full, name }) => scanFile(full, name)
+    );
+    await mapWithConcurrency(
+      subdirs,
+      Math.min(16, NATIVE_SCAN_CONCURRENCY),
+      ({ full, rel }) => walk(full, rel)
+    );
+  };
+  await walk(base, "");
+  return {
+    matches,
+    count: total,
+    truncated: stopped,
+    used: "native"
+  };
+}
+
+export {
+  grepTool,
+  __resetRgDetectionForTests
+};
+//# sourceMappingURL=chunk-553IQUMO.js.map