@wrongstack/tools 0.310.1 → 0.313.1

package/dist/grep.js

@@ -1,608 +1,11 @@
-// src/grep.ts
-import { spawn } from "node:child_process";
-import * as fs2 from "node:fs/promises";
-import * as path3 from "node:path";
-import { ToolValidationError } from "@wrongstack/core/types";
 import {
-  buildChildEnv,
-  compileGlob as compileGlob2,
-  DEFAULT_WALK_IGNORE_DIRS,
-  expectDefined
-} from "@wrongstack/core/utils";
-
-// 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;
-}
-
-// src/_regex.ts
-import {
-  capSubject,
-  compileUserRegex,
-  MAX_SUBJECT_LEN
-} from "@wrongstack/primitives";
-
-// src/_util.ts
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-import * as Core from "@wrongstack/core/utils";
-function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
-}
-function allowedRoots(ctx) {
-  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
-}
-function isInsideAny(target, roots) {
-  return roots.some((root) => {
-    const rel = path.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
-  });
-}
-function ensureInsideRoot(absPath, ctx) {
-  const target = path.resolve(absPath);
-  if (ctx.allowOutsideProjectRoot) return target;
-  if (isInsideAny(target, allowedRoots(ctx))) return target;
-  throw new Error(`Path "${absPath}" is outside project root "${path.resolve(ctx.projectRoot)}"`);
-}
-function safeResolve(input, ctx) {
-  return ensureInsideRoot(resolvePath(input, ctx), ctx);
-}
-async function resolveRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return absPath;
-  const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
-  );
-  let probe = absPath;
-  const pendingTail = [];
-  for (; ; ) {
-    let real;
-    try {
-      real = await fsp.realpath(probe);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        const parent = path.dirname(probe);
-        if (parent === probe) return absPath;
-        pendingTail.unshift(path.basename(probe));
-        probe = parent;
-        continue;
-      }
-      throw err;
-    }
-    const candidate = pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
-    if (isInsideAny(candidate, realRoots)) {
-      return candidate;
-    }
-    throw new Error(
-      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
-    );
-  }
-}
-async function safeResolveReal(input, ctx) {
-  const abs = safeResolve(input, ctx);
-  return await resolveRealInsideRoot(abs, ctx);
-}
-function isBinaryBuffer(buf) {
-  const len = Math.min(buf.length, 8192);
-  for (let i = 0; i < len; i++) {
-    if (buf[i] === 0) return true;
-  }
-  return false;
-}
-
-// src/codebase-index/gitignore.ts
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
-import { compileGlob } from "@wrongstack/core/utils";
-function globBody(glob) {
-  return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
-}
-function compileGitignore(lines) {
-  const rules = [];
-  for (const raw of lines) {
-    let line = raw.replace(/\r$/, "");
-    if (!line.trim() || line.trimStart().startsWith("#")) continue;
-    line = line.trim();
-    let negated = false;
-    if (line.startsWith("!")) {
-      negated = true;
-      line = line.slice(1);
-    }
-    let dirOnly = false;
-    if (line.endsWith("/")) {
-      dirOnly = true;
-      line = line.slice(0, -1);
-    }
-    if (!line) continue;
-    const anchored = line.startsWith("/") || line.includes("/");
-    if (line.startsWith("/")) line = line.slice(1);
-    const body = globBody(line);
-    const prefix = anchored ? "^" : "(?:^|.*/)";
-    rules.push({
-      eqOrUnder: new RegExp(`${prefix}${body}(?:/.*)?$`),
-      under: new RegExp(`${prefix}${body}/.*$`),
-      negated,
-      dirOnly
-    });
-  }
-  return (relPath, isDir) => {
-    const p = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
-    let ignored = false;
-    for (const r of rules) {
-      const re = r.dirOnly && !isDir ? r.under : r.eqOrUnder;
-      if (re.test(p)) ignored = !r.negated;
-    }
-    return ignored;
-  };
-}
-async function loadGitignoreMatcher(projectRoot) {
-  let lines = [];
-  try {
-    const raw = await fs.readFile(path2.join(projectRoot, ".gitignore"), "utf8");
-    lines = raw.split("\n");
-  } catch {
-  }
-  return compileGitignore(lines);
-}
-
-// src/grep.ts
-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((resolve2) => {
-    try {
-      const p = spawn("rg", ["--version"], {
-        env: buildChildEnv(),
-        stdio: "ignore",
-        signal: AbortSignal.timeout(1e4),
-        windowsHide: true
-      });
-      p.on("error", () => resolve2(false));
-      p.on("close", (code) => resolve2(code === 0));
-    } catch {
-      resolve2(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 = path3.join(base, ".gitignore");
-  if (await fs2.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 ? compileGlob2(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 fs2.stat(full);
-      if (!stat2.isFile() || stat2.size > maxBytes || stopped || signal.aborted) return;
-      const file = await fs2.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 fs2.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 = path3.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"
-  };
-}
+  __resetRgDetectionForTests,
+  grepTool
+} from "./chunk-553IQUMO.js";
+import "./chunk-Q5JPPCZC.js";
+import "./chunk-U4D5S3VQ.js";
+import "./chunk-LIJQMYYX.js";
+import "./chunk-D33S4RQG.js";
 export {
   __resetRgDetectionForTests,
   grepTool