@sema-ai/core 1.275.1

package/dist/tools/fs/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/tools/fs/search.ts"],"names":[],"mappings":"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"}

package/dist/tools/fs/search.js

@@ -0,0 +1,650 @@
+import { hasBinaryExtension } from "./safety.js";
+/**
+ * grep/glob search engine (design/64 §10). Two paths, same output, so it works on any execution env:
+ *   - **ripgrep when present** (detected once per env) — fast, respects .gitignore, skips binary/hidden.
+ *   - **JS fallback** otherwise (remote E2B/SSH may have no `rg`) — hardened to NOT crawl `node_modules`,
+ *     `build`, `.dart_tool`, …; it parses `.gitignore` and skips binary files, so it isn't slow or noisy.
+ * Output is relative `path:line:text` (content), `path` (files), or `path:count` — matching CC's GrepTool.
+ */
+const WALK_MAX_FILES = 5000;
+const WALK_MAX_DEPTH = 32;
+const GREP_DEFAULT_CAP = 250; // CC default (design/116 review S2)
+const FILE_MAX_BYTES = 5 * 1024 * 1024; // skip very large files in the JS fallback (never useful to grep)
+/** Directories never worth crawling (design/64 §10.3) — dependency/build/cache trees. */
+export const DEFAULT_IGNORE_DIRS = new Set([
+    "node_modules", ".git", ".hg", ".svn", "build", "dist", "out", "target", ".dart_tool", ".pub-cache",
+    ".next", ".nuxt", ".gradle", ".idea", ".vscode", "Pods", ".venv", "venv", "__pycache__", ".mypy_cache",
+    ".pytest_cache", "coverage", ".turbo", ".cache", "vendor",
+]);
+/** JS-fallback file-type → glob map for {@link GrepParams.type} (the rg path uses rg's own type table). */
+const TYPE_GLOBS = {
+    js: "*.{js,jsx,mjs,cjs}",
+    ts: "*.{ts,tsx,mts,cts}",
+    py: "*.{py,pyi}",
+    rust: "*.rs",
+    go: "*.go",
+    java: "*.java",
+    c: "*.{c,h}",
+    cpp: "*.{cpp,cc,cxx,hpp,hh}",
+    ruby: "*.rb",
+    php: "*.php",
+    swift: "*.swift",
+    kotlin: "*.{kt,kts}",
+    csharp: "*.cs",
+    sh: "*.{sh,bash,zsh}",
+    md: "*.{md,mdx}",
+    markdown: "*.{md,mdx}",
+    json: "*.json",
+    yaml: "*.{yml,yaml}",
+    html: "*.{html,htm}",
+    css: "*.{css,scss,less}",
+};
+const basename = (p) => p.slice(Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\")) + 1); // [384] sweep: dual-family
+const NO_MATCHES = "No matches.";
+/** 批④ #6 (CC 2.1.198 Grep call, bundle :333383-333390): split the `glob` param into individual glob
+ *  tokens — whitespace-separated first; a token WITHOUT braces is further split on commas
+ *  (`"*.ts,*.tsx"` → two globs), while a brace token (`*.{ts,tsx}`) is kept whole (its commas are
+ *  alternation syntax, not separators). CC-verbatim splitting rules. */
+export function splitGlobParam(glob) {
+    const out = [];
+    for (const token of glob.split(/\s+/)) {
+        if (token.includes("{") && token.includes("}")) {
+            if (token.length > 0)
+                out.push(token);
+        }
+        else
+            out.push(...token.split(",").filter(Boolean));
+    }
+    return out;
+}
+/** 批④ #8 (CC 2.1.198 RWp, bundle :332987): decompose an ABSOLUTE glob pattern into a base directory +
+ *  relative pattern — cut at the last separator before the first glob metachar (`* ? [ {`); a pattern
+ *  with no metachar splits dirname/basename. Returns undefined for a relative pattern (caller keeps it
+ *  as-is) or when no usable base can be derived. */
+export function splitAbsoluteGlobPattern(pattern) {
+    if (!(pattern.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pattern)))
+        return undefined;
+    const m = /[*?[{]/.exec(pattern);
+    if (!m) {
+        const i = Math.max(pattern.lastIndexOf("/"), pattern.lastIndexOf("\\"));
+        if (i <= 0)
+            return undefined;
+        return { baseDir: pattern.slice(0, i), relativePattern: pattern.slice(i + 1) };
+    }
+    const prefix = pattern.slice(0, m.index);
+    const cut = Math.max(prefix.lastIndexOf("/"), prefix.lastIndexOf("\\"));
+    if (cut === -1)
+        return undefined;
+    let baseDir = pattern.slice(0, cut);
+    if (baseDir === "" && cut === 0)
+        baseDir = "/";
+    if (/^[A-Za-z]:$/.test(baseDir))
+        baseDir = baseDir + pattern[cut];
+    if (!baseDir)
+        return undefined;
+    return { baseDir, relativePattern: pattern.slice(cut + 1) };
+}
+/**
+ * POSIX-safe single-quote so an arbitrary model-supplied string can't break out of the shell command that
+ * runs ripgrep. Wraps in single quotes (inside which the shell expands nothing — no `$()`, backtick, `;`, or
+ * glob) and escapes any embedded single quote via the `'\''` idiom (close, escaped-quote, reopen). Exported
+ * for direct injection testing (council [R145]). Renamed from `shq` for legibility.
+ */
+export function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/** Compile a gitignore/glob token to a RegExp tested against a relative posix path. */
+function globTokenToRegExp(token, anchored, braces = false) {
+    // `braces` (design/116 review B1): glob/grep patterns support `{a,b}` alternation (`*.{ts,tsx}`), which
+    // the escaping below would otherwise turn into a LITERAL `{ts,tsx}` that never matches — every brace
+    // entry in TYPE_GLOBS and any model-sent `glob:"*.{ts,tsx}"` silently returned "No matches." on the JS
+    // fallback. Kept OFF for the gitignore path (gitignore has no brace syntax — `{` is literal there).
+    const charToRe = (ch) => ch === "*" ? "[^/]*" : ch === "?" ? "[^/]" : ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    let re = "";
+    for (let i = 0; i < token.length; i++) {
+        const c = token[i];
+        if (c === "*") {
+            if (token[i + 1] === "*") {
+                re += ".*";
+                i++;
+                if (token[i + 1] === "/")
+                    i++;
+            }
+            else
+                re += "[^/]*";
+        }
+        else if (c === "?")
+            re += "[^/]";
+        else if (braces && c === "{") {
+            const close = token.indexOf("}", i);
+            if (close > i + 1) {
+                // Non-nested alternation: each alternative gets the same *, ?, escape rules.
+                const alts = token.slice(i + 1, close).split(",").map((alt) => [...alt].map(charToRe).join(""));
+                re += `(?:${alts.join("|")})`;
+                i = close;
+            }
+            else
+                re += "\\{"; // unmatched/empty brace → literal
+        }
+        else
+            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`${anchored ? "^" : "(^|/)"}${re}$`);
+}
+/** Lightweight `.gitignore` matcher (handles comments, negation, dir-only `/`, anchoring, `*`/`?`). */
+export function gitignoreMatcher(content) {
+    const rules = content
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith("#"))
+        .map((raw) => {
+        let neg = false;
+        let pat = raw;
+        if (pat.startsWith("!")) {
+            neg = true;
+            pat = pat.slice(1);
+        }
+        let dirOnly = false;
+        if (pat.endsWith("/")) {
+            dirOnly = true;
+            pat = pat.slice(0, -1);
+        }
+        const anchored = pat.startsWith("/");
+        if (anchored)
+            pat = pat.replace(/^\/+/, "");
+        return { neg, dirOnly, anchored, re: globTokenToRegExp(pat, anchored), bare: pat };
+    });
+    return (relRaw, isDir) => {
+        const rel = relRaw.replace(/\\/g, "/"); // [384] sweep: win32 rel keys are backslash-form; glob regexes are "/"-built
+        let ignored = false;
+        for (const r of rules) {
+            if (r.dirOnly && !isDir)
+                continue;
+            const hit = r.re.test(rel) || (!r.anchored && (r.re.test(basename(rel)) || rel.split("/").includes(r.bare)));
+            if (hit)
+                ignored = !r.neg;
+        }
+        return ignored;
+    };
+}
+/** Build the combined ignore predicate (ignore-set ∪ .gitignore) for a JS-fallback walk.
+ *  Exported so repo-map (design/72 §1) walks with the SAME ignore semantics as grep/glob. */
+export async function buildIgnore(env, root, signal) {
+    let gi;
+    const giPath = `${root.replace(/\/+$/, "")}/.gitignore`;
+    const read = await env.readTextFile(giPath, signal).catch(() => undefined);
+    if (read && read.ok)
+        gi = gitignoreMatcher(read.value);
+    return (rel, isDir) => {
+        const base = basename(rel);
+        if (isDir && DEFAULT_IGNORE_DIRS.has(base))
+            return true;
+        if (base.startsWith(".") && base !== ".")
+            return true; // skip dotfiles/dirs (matches the prior walk)
+        if (gi && gi(rel, isDir))
+            return true;
+        return false;
+    };
+}
+/** Bounded, ignore-aware recursive walk. Returns absolute file paths under `start`. Exported for
+ *  repo-map (design/72 §1) — same bounded/ignore-aware traversal as grep/glob, one source of truth. */
+export async function walk(env, root, start, ignore, signal) {
+    const out = [];
+    const nameOnly = [];
+    let incomplete = false;
+    let skippedLarge = 0;
+    const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/"); // [384] sweep(Opus 复审补漏)
+    const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
+    const stack = [{ dir: start, depth: 0 }];
+    const visited = new Set();
+    while (stack.length > 0 && out.length < WALK_MAX_FILES) {
+        const { dir, depth } = stack.pop();
+        if (visited.has(dir))
+            continue;
+        visited.add(dir);
+        const listing = await env.listDir(dir, signal);
+        if (!listing.ok)
+            continue;
+        for (const info of listing.value) {
+            if (info.kind === "directory") {
+                if (ignore(rel(info.path), true) || visited.has(info.path))
+                    continue;
+                if (depth < WALK_MAX_DEPTH)
+                    stack.push({ dir: info.path, depth: depth + 1 });
+                else
+                    incomplete = true; // a real (non-ignored) subtree was cut off by the depth ceiling
+            }
+            else if (info.kind === "file") {
+                if (ignore(rel(info.path), false))
+                    continue;
+                if (hasBinaryExtension(info.path)) {
+                    if (nameOnly.length < WALK_MAX_FILES)
+                        nameOnly.push(info.path);
+                    else
+                        incomplete = true;
+                    continue;
+                }
+                if (typeof info.size === "number" && info.size > FILE_MAX_BYTES) {
+                    skippedLarge++;
+                    if (nameOnly.length < WALK_MAX_FILES)
+                        nameOnly.push(info.path);
+                    else
+                        incomplete = true;
+                    continue;
+                }
+                out.push(info.path);
+                if (out.length >= WALK_MAX_FILES) {
+                    incomplete = true; // boundary false-positive possible (exactly-N trees); markers say "may"
+                    break;
+                }
+            }
+        }
+    }
+    if (stack.length > 0 && out.length >= WALK_MAX_FILES)
+        incomplete = true;
+    return { files: out, nameOnly, incomplete, skippedLarge };
+}
+/** Honesty suffix for results built on a bounded walk: appended to EVERY output shape (including
+ *  "No matches." — an unflagged empty result reads as "the code doesn't contain X", the exact harm the
+ *  A-8 fix documented). Empty when the walk was exhaustive. */
+function walkCaveat(w, forContentSearch) {
+    const parts = [];
+    if (w.incomplete)
+        parts.push(`file walk hit its ${WALK_MAX_FILES}-file/${WALK_MAX_DEPTH}-depth limit`);
+    if (forContentSearch && w.skippedLarge > 0) {
+        parts.push(`${w.skippedLarge} file(s) over ${Math.round(FILE_MAX_BYTES / (1024 * 1024))}MB not searched`);
+    }
+    return parts.length > 0 ? `\n…[results may be incomplete: ${parts.join("; ")}]` : "";
+}
+function compilePattern(p) {
+    if (p.regex) {
+        const re = new RegExp(p.pattern, p.ignore_case ? "i" : "");
+        return (l) => re.test(l);
+    }
+    if (p.ignore_case) {
+        const needle = p.pattern.toLowerCase();
+        return (l) => l.toLowerCase().includes(needle);
+    }
+    return (l) => l.includes(p.pattern);
+}
+/** 批④ #5: the matched (non-empty) substrings of one line, for `only_matching` (rg -o). Literal
+ *  patterns return the file's ACTUAL span (case-insensitive match still reports the original casing). */
+function matchedParts(line, p) {
+    const parts = [];
+    if (p.regex) {
+        const re = new RegExp(p.pattern, `g${p.ignore_case ? "i" : ""}`);
+        for (let m = re.exec(line); m !== null; m = re.exec(line)) {
+            if (m[0].length > 0)
+                parts.push(m[0]);
+            else
+                re.lastIndex++; // zero-width safety
+            if (parts.length > 1000)
+                break;
+        }
+    }
+    else if (p.pattern.length > 0) {
+        const hay = p.ignore_case ? line.toLowerCase() : line;
+        const needle = p.ignore_case ? p.pattern.toLowerCase() : p.pattern;
+        for (let idx = hay.indexOf(needle); idx !== -1; idx = hay.indexOf(needle, idx + needle.length)) {
+            parts.push(line.slice(idx, idx + needle.length));
+            if (parts.length > 1000)
+                break;
+        }
+    }
+    return parts;
+}
+/**
+ * audit A-8: whole-file matcher for `multiline:true` (rg parity: `-U --multiline-dotall`). Returns
+ * [startLine, endLine] (1-based, inclusive) per match. Regex gets `s` (dot matches newline) + `g`;
+ * a literal pattern is an indexOf scan (it may contain real newlines).
+ */
+function multilineSpans(content, p, captureText = false) {
+    const spans = [];
+    // offset → 1-based line via precomputed line-start offsets
+    const starts = [0];
+    for (let i = 0; i < content.length; i++)
+        if (content[i] === "\n")
+            starts.push(i + 1);
+    const lineAt = (off) => {
+        let lo = 0, hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= off)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    };
+    // 1.253 双轨终审 LOW (only_matching × multiline): the matched TEXT is captured only when the caller
+    // needs it (-o output), bounded per match so a pathological greedy span can't hold megabytes.
+    const MATCH_TEXT_MAX = 2_000;
+    if (p.regex) {
+        const re = new RegExp(p.pattern, `gs${p.ignore_case ? "i" : ""}`);
+        for (let m = re.exec(content); m !== null; m = re.exec(content)) {
+            spans.push([lineAt(m.index), lineAt(m.index + Math.max(0, m[0].length - 1)), captureText ? m[0].slice(0, MATCH_TEXT_MAX) : undefined]);
+            if (m[0].length === 0)
+                re.lastIndex++; // zero-width safety
+            if (spans.length > 10_000)
+                break;
+        }
+    }
+    else {
+        const hay = p.ignore_case ? content.toLowerCase() : content;
+        const needle = p.ignore_case ? p.pattern.toLowerCase() : p.pattern;
+        if (needle.length > 0) {
+            for (let idx = hay.indexOf(needle); idx !== -1; idx = hay.indexOf(needle, idx + needle.length)) {
+                spans.push([lineAt(idx), lineAt(idx + needle.length - 1), captureText ? content.slice(idx, idx + Math.min(needle.length, MATCH_TEXT_MAX)) : undefined]);
+                if (spans.length > 10_000)
+                    break;
+            }
+        }
+    }
+    return spans;
+}
+/** JS-fallback grep: ignore-aware walk + per-line scan, honoring output_mode / context / head_limit. */
+export async function jsGrep(env, root, p, signal) {
+    let test;
+    try {
+        test = compilePattern(p);
+    }
+    catch (e) {
+        return `Error (grep): invalid regex: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    const ignore = await buildIgnore(env, root, signal);
+    const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
+    const start = p.path ? (p.path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p.path) ? p.path : `${rootPrefix}${p.path}`) : root;
+    const walked = await walk(env, root, start, ignore, signal);
+    const caveat = walkCaveat(walked, true);
+    let files = walked.files;
+    files.sort();
+    // head_limit 0 = unlimited (CC "Pass 0 for unlimited", design/116 review S2).
+    const cap = p.head_limit === 0 ? Infinity : Math.max(1, Math.floor(p.head_limit ?? GREP_DEFAULT_CAP));
+    const mode = p.output_mode ?? "content";
+    const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
+    // audit A-8: honor `glob` (rg parity: --glob). Previously silently ignored — a glob-scoped search
+    // scanned EVERY file, so unrelated matches filled the result cap and crowded out the real targets.
+    // 批④ #6: the param may carry SEVERAL globs (comma/whitespace-separated, CC parity) — match ANY.
+    if (p.glob) {
+        const globRes = splitGlobParam(p.glob).map((g) => globTokenToRegExp(g, false, true));
+        if (globRes.length > 0)
+            files = files.filter((f) => globRes.some((re) => re.test(rel(f))));
+    }
+    // design/116 W1: honor `type` (CC/rg --type) via the glob map; an unknown type is ignored (searching
+    // everything) with an honest note rather than silently returning nothing.
+    let typeNote = "";
+    if (p.type) {
+        const tg = TYPE_GLOBS[p.type.toLowerCase()];
+        if (tg) {
+            const typeRe = globTokenToRegExp(tg, false, true);
+            files = files.filter((f) => typeRe.test(basename(f)));
+        }
+        else {
+            typeNote = `\n[note: unknown type "${p.type}" — searched all files]`;
+        }
+    }
+    // CC semantics (design/116 review S1, GrepTool.ts: "context takes precedence over context_before/context_after"):
+    // -C wins when sent; -B/-A only apply without it.
+    const ctxB = Math.max(0, Math.floor(p.context ?? p.context_before ?? 0));
+    const ctxA = Math.max(0, Math.floor(p.context ?? p.context_after ?? 0));
+    const ctx = Math.max(ctxB, ctxA); // legacy uses below (cap-marker honesty) key off "any context in play"
+    // design/116 W1: `offset` pagination — collect offset+cap items, emit the slice after the offset.
+    const off = Math.min(100_000, Math.max(0, Math.floor(p.offset ?? 0))); // clamped: a huge offset must not unbound the collection buffer
+    const collectCap = cap + off;
+    const out = [];
+    const fileMatches = [];
+    const counts = [];
+    // True totals: ACCUMULATE output only until `cap`, but keep COUNTING (cheap) so the `[capped at]`
+    // marker can report the real total, not the cap (output-cap honesty: a cap that looks like the total
+    // hides how much was dropped). Push a line only while under cap; the per-line guards below also stop
+    // the inner context loops from overshooting `cap` by a full match window.
+    let totalContent = 0;
+    let totalFiles = 0;
+    for (const f of files) {
+        const read = await env.readTextFile(f, signal);
+        if (!read.ok)
+            continue;
+        const lines = read.value.split("\n");
+        // rg parity: a trailing newline doesn't make a phantom final line. Drop one trailing "" so the
+        // JS-fallback line set (and its match count) matches ripgrep's instead of inflating by one.
+        if (lines.length > 1 && lines.at(-1) === "")
+            lines.pop();
+        let fileCount = 0;
+        if (p.multiline) {
+            // audit A-8: honor `multiline` (rg parity: -U --multiline-dotall). Previously silently ignored —
+            // per-line matching made any cross-line pattern return "No matches.", which reads as "the code
+            // doesn't contain X". Whole-file spans, mapped back to 1-based lines.
+            let spans;
+            try {
+                spans = multilineSpans(read.value, p, mode === "content" && p.only_matching === true);
+            }
+            catch (e) {
+                return `Error (grep): invalid regex: ${e instanceof Error ? e.message : String(e)}`;
+            }
+            fileCount = spans.length;
+            if (mode === "content") {
+                for (const [s, eL, text] of spans) {
+                    // 1.253 双轨终审 LOW (批④ #5 completion): `-o` under multiline emits the matched SEGMENT,
+                    // one output record per matched line (rg -U -o shape: the match's own lines, numbered from
+                    // the span start), instead of silently falling back to whole-line windows. Context never
+                    // applies under -o (same rule as the single-line branch).
+                    if (p.only_matching && text !== undefined) {
+                        const parts = text.split("\n");
+                        for (let k = 0; k < parts.length; k++) {
+                            if (out.length < collectCap)
+                                out.push(`${rel(f)}:${s + k}:${parts[k].slice(0, 500)}`);
+                        }
+                        continue;
+                    }
+                    for (let j = Math.max(0, s - 1 - ctxB); j <= Math.min(lines.length - 1, eL - 1 + ctxA); j++) {
+                        if (out.length < collectCap)
+                            out.push(`${rel(f)}:${j + 1}:${lines[j].slice(0, 500)}`);
+                    }
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < lines.length; i++) {
+                if (!test(lines[i]))
+                    continue;
+                fileCount++;
+                if (mode === "content") {
+                    // 批④ #5 (`-o`): emit only the matched (non-empty) parts, one per output line (rg -o parity).
+                    // Context windows don't apply in only-matching output (the parts ARE the output).
+                    if (p.only_matching) {
+                        for (const part of matchedParts(lines[i], p)) {
+                            if (out.length < collectCap)
+                                out.push(`${rel(f)}:${i + 1}:${part.slice(0, 500)}`);
+                        }
+                    }
+                    else if (ctx > 0) {
+                        for (let j = Math.max(0, i - ctxB); j <= Math.min(lines.length - 1, i + ctxA); j++) {
+                            if (out.length < collectCap)
+                                out.push(`${rel(f)}:${j + 1}:${lines[j].slice(0, 500)}`);
+                        }
+                    }
+                    else if (out.length < collectCap) {
+                        out.push(`${rel(f)}:${i + 1}:${lines[i].slice(0, 500)}`);
+                    }
+                }
+            }
+        }
+        if (mode === "content")
+            totalContent += fileCount; // matches are ≤ output lines (context inflates out)
+        if (fileCount > 0) {
+            totalFiles++;
+            if (mode === "files_with_matches" && fileMatches.length < collectCap)
+                fileMatches.push(rel(f));
+            else if (mode === "count" && counts.length < collectCap)
+                counts.push(`${rel(f)}:${fileCount}`);
+        }
+    }
+    // Offset pagination (design/116 W1): emit the window AFTER the first `off` collected items. An offset
+    // past the end is an honest empty ("No matches" + note), not an error.
+    const paged = (arr) => (off > 0 ? arr.slice(off, off + cap) : arr);
+    const offNote = off > 0 ? `\n[offset ${off}]` : "";
+    // Cap markers on EVERY output mode (content had one; files_with_matches/count silently dropped the
+    // tail — and the rg path marks all three, so the fallback was also behaviorally inconsistent with it).
+    // Report the REAL total (not the cap) so the dropped count is honest.
+    if (mode === "files_with_matches") {
+        const body = paged(fileMatches);
+        return body.length === 0
+            ? NO_MATCHES + offNote + typeNote + caveat
+            : body.join("\n") + (totalFiles > off + cap ? `\n…[capped at ${cap} of ${totalFiles}]` : "") + offNote + typeNote + caveat;
+    }
+    if (mode === "count") {
+        const body = paged(counts);
+        return body.length === 0
+            ? NO_MATCHES + offNote + typeNote + caveat
+            : body.join("\n") + (totalFiles > off + cap ? `\n…[capped at ${cap} of ${totalFiles}]` : "") + offNote + typeNote + caveat;
+    }
+    // `totalContent` counts MATCHES (exact: one per matching line, independent of context). `out` holds
+    // match+context lines, so when context is in play `out` can reach the cap on fewer matches — in that
+    // case the cap bounds OUTPUT lines, and the true match total is a lower bound on what was dropped.
+    const body = paged(out);
+    if (body.length === 0)
+        return NO_MATCHES + offNote + typeNote + caveat;
+    if (out.length < collectCap)
+        return body.join("\n") + offNote + typeNote + caveat; // nothing truncated
+    // Output was capped. One output line == one match ONLY for single-line matching with no context, where
+    // `totalContent` is the exact total and `[capped at C of T]` is precise. If context is in play (each match
+    // drags in a window) OR the match is multiline (codex [R145]: one span covers MANY lines), output lines ≥
+    // matches — the cap bounds OUTPUT lines, not matches, so naming an exact total would lie (the `capped at 4
+    // of 1` bug: 4 capped output lines, 1 multiline match). Report the match total as an honest lower bound.
+    const marker = ctx > 0 || p.multiline || p.only_matching // 批④ #5: -o can emit several parts per matching line — totals are a lower bound
+        ? `\n…[capped at ${cap}; ${totalContent}+ match(es) found, more output omitted]`
+        : `\n…[capped at ${cap} of ${totalContent}]`;
+    return body.join("\n") + marker + offNote + typeNote + caveat;
+}
+const rgCache = new WeakMap();
+/** Detect ripgrep once per env (cached). */
+export function detectRipgrep(env) {
+    let cached = rgCache.get(env);
+    if (!cached) {
+        cached = env
+            .exec("rg --version", { timeout: 10 })
+            .then((r) => r.ok && r.value.exitCode === 0)
+            .catch(() => false);
+        rgCache.set(env, cached);
+    }
+    return cached;
+}
+/** ripgrep grep: build flags from params, run, normalize to the same output as {@link jsGrep}. */
+export async function rgGrep(env, root, p, signal) {
+    const mode = p.output_mode ?? "content";
+    // --no-require-git: honor .gitignore even when the project dir isn't a git repo (ripgrep otherwise only
+    // applies .gitignore inside a git tree), so the rg path matches the JS fallback's ignore behavior.
+    const flags = ["--no-messages", "--no-require-git"];
+    // 批④ #7 (CC 2.1.198 verbatim, bundle :333367): bound each output line — a single pathological
+    // multi-MB line (minified bundle, base64 blob) must not blow the whole result.
+    // 1.253 双轨终审 LOW: --max-columns-preview keeps a PREFIX of an over-long matching line (with
+    // rg's "[... N more matches]" note) instead of replacing it with an elided placeholder — same
+    // "show the first 500 chars" behavior as the jsGrep fallback's line slice.
+    flags.push("--max-columns", "500", "--max-columns-preview");
+    if (!p.regex)
+        flags.push("-F"); // literal substring unless regex requested
+    if (p.ignore_case)
+        flags.push("-i");
+    if (p.multiline)
+        flags.push("-U", "--multiline-dotall");
+    if (mode === "content") {
+        flags.push("--no-heading", "-n");
+        if (p.only_matching)
+            flags.push("-o"); // 批④ #5 (CC: content mode only)
+        // CC semantics (design/116 review S1): -C wins over -B/-A when both are sent; -C alone sets both.
+        const ctxB = p.context ?? p.context_before;
+        const ctxA = p.context ?? p.context_after;
+        if (ctxB && ctxB > 0)
+            flags.push("-B", String(Math.floor(ctxB)));
+        if (ctxA && ctxA > 0)
+            flags.push("-A", String(Math.floor(ctxA)));
+    }
+    else if (mode === "files_with_matches")
+        flags.push("-l");
+    else if (mode === "count")
+        flags.push("-c");
+    // 批④ #6: comma/whitespace-separated glob list → one --glob per token (CC parity).
+    if (p.glob)
+        for (const g of splitGlobParam(p.glob))
+            flags.push("--glob", shellQuote(g));
+    // rg's built-in type table (design/116 W1, CC `type`). An unknown type makes rg exit(2) → JS fallback
+    // handles it with its own map/note, so a bad type never hard-errors.
+    if (p.type)
+        flags.push("--type", shellQuote(p.type));
+    const target = p.path ? shellQuote(p.path) : ".";
+    const cmd = `rg ${flags.join(" ")} -e ${shellQuote(p.pattern)} -- ${target}`;
+    const res = await env.exec(cmd, { cwd: root, timeout: 60, abortSignal: signal });
+    if (!res.ok)
+        return jsGrep(env, root, p, signal); // adapter/exec failure → fall back rather than error out
+    const { exitCode, stdout } = res.value;
+    if (exitCode === 1)
+        return NO_MATCHES; // rg: 1 = no matches
+    if (exitCode >= 2)
+        return jsGrep(env, root, p, signal); // rg error (e.g. bad regex it rejects) → JS fallback
+    const cap = p.head_limit === 0 ? Infinity : Math.max(1, Math.floor(p.head_limit ?? GREP_DEFAULT_CAP)); // 0 = unlimited (S2)
+    const off = Math.max(0, Math.floor(p.offset ?? 0));
+    const lines = stdout.split("\n").filter((l) => l.length > 0);
+    const capped = lines.slice(off, off + cap);
+    if (capped.length === 0)
+        return NO_MATCHES + (off > 0 ? `\n[offset ${off}]` : "");
+    // Report the REAL total (we have it: `lines.length`), not the cap, so the dropped count is honest.
+    return (capped.join("\n") +
+        (lines.length > off + cap ? `\n…[capped at ${cap} of ${lines.length}]` : "") +
+        (off > 0 ? `\n[offset ${off}]` : ""));
+}
+/** grep dispatch: ripgrep when the env has it, else the hardened JS fallback (design/64 §10.3). */
+export async function runGrep(env, root, p, signal) {
+    return (await detectRipgrep(env)) ? rgGrep(env, root, p, signal) : jsGrep(env, root, p, signal);
+}
+/** glob: find files by name pattern, with optional sub-path scoping; returns RELATIVE paths (design/64 §10.4). */
+export async function runGlob(env, root, pattern, opts = {}, signal) {
+    return (await runGlobDetailed(env, root, pattern, opts, signal)).text;
+}
+/** Structured sibling of {@link runGlob} (design/116 W3): same walk/match, plus the CC-shaped facts a
+ *  shell renders (`filenames`/`numFiles`/`truncated`/`durationMs`/`totalMatches`/`countIsComplete`)
+ *  without re-parsing the text.
+ *
+ *  CC207 backlog P2-2 (CC 2.1.206:397761-398004 = 2.1.207:342454-342633, node-sliced verbatim):
+ *   · `totalMatches` — "Total number of matching files before truncation. A lower bound when
+ *     countIsComplete is false." (CC: `totalMatches: g.length`)
+ *   · `countIsComplete` — "Whether totalMatches is the exact total (true) or a floor because the
+ *     underlying search truncated its own output (false)." (CC: `countIsComplete: !m`, m = the rg
+ *     enumeration cut its own output; sema equivalent = the bounded walk hit its file/depth ceiling)
+ *   · `numFiles` — "Number of file paths returned (after any truncation)" (CC: `numFiles: u.length`
+ *     post-slice; was matchedAll.length here — pre-truncation total — fixed to the CC contract)
+ *   · `truncated` — CC: `y = m || g.length > n + r` (underlying-incomplete OR over the result cap). */
+export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
+    const t0 = Date.now();
+    const ignore = await buildIgnore(env, root, signal);
+    const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
+    const start = opts.path ? (opts.path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(opts.path) ? opts.path : `${rootPrefix}${opts.path}`) : root;
+    const walked = await walk(env, root, start, ignore, signal);
+    const caveat = walkCaveat(walked, false);
+    // Glob matches NAMES: binary/oversize files are legitimate glob results (only content search skips them).
+    const files = [...walked.files, ...walked.nameOnly];
+    const re = globTokenToRegExp(pattern, false, true);
+    const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
+    const cap = Math.max(1, Math.floor(opts.max ?? 500));
+    const matchedAll = files.filter((f) => re.test(rel(f)) || re.test(basename(f))).map(rel).sort();
+    const matched = matchedAll.slice(0, cap);
+    const totalMatches = matchedAll.length;
+    const countIsComplete = !walked.incomplete;
+    const truncated = !countIsComplete || totalMatches > cap;
+    // Model-facing truncation note: CC 2.1.206:397947-397957 verbatim (fn QTg; the third
+    // "totalMatches undefined" tier is CC's legacy-persisted-result branch — unreachable here,
+    // core always computes totalMatches). Appended as its own line iff truncated, like CC's
+    // `[...filenames, ...(truncated ? [QTg(e)] : [])].join("\n")`. The `matched.length === 0`
+    // exclusion is CC-congruent too (三轮复查亲核 206:398116-398120): CC's
+    // mapToolResultToToolResultBlockParam early-returns "No files found" on an empty filenames list
+    // BEFORE the truncated-note branch, so an empty-but-truncated walk carries no QTg note in CC
+    // either. The walkCaveat honesty suffix stays the one sema delta (A-8: an unflagged empty/partial
+    // result reads as exhaustive).
+    const capNote = !truncated || matched.length === 0
+        ? ""
+        : countIsComplete
+            ? `\n(Showing ${matched.length} of ${totalMatches} matching files; ${totalMatches - matched.length} more are not listed. Narrow the pattern or path to see the rest.)`
+            : `\n(Showing the first ${matched.length} files; there are more than ${totalMatches} matches. Narrow the pattern or path to see the rest.)`;
+    const text = matched.length === 0 ? "No files matched." + caveat : matched.join("\n") + capNote + caveat;
+    return { text, filenames: matched, numFiles: matched.length, truncated, durationMs: Date.now() - t0, totalMatches, countIsComplete };
+}
+//# sourceMappingURL=search.js.map