@sema-agent/core 5.29.0 → 5.31.0

package/dist/tools/fs/search.js

@@ -218,7 +218,7 @@ export async function buildIgnore(env, root, signal) {
 export function walkIsPartial(w) {
     return w.incomplete || w.skippedUnreadable > 0 || w.aborted;
 }
-export async function walk(env, root, start, ignore, signal) {
+export async function walk(env, root, start, ignore, signal, deny) {
     const out = [];
     const nameOnly = [];
     const mtimes = new Map();
@@ -226,6 +226,17 @@ export async function walk(env, root, start, ignore, signal) {
     let skippedLarge = 0;
     let skippedUnreadable = 0;
     let aborted = false;
+    let denyPruned = 0;
+    const denyPatterns = [];
+    const denyHit = (path) => {
+        const hit = deny?.matchPath(path);
+        if (!hit)
+            return false;
+        denyPruned++;
+        if (!denyPatterns.includes(hit.pattern))
+            denyPatterns.push(hit.pattern);
+        return true;
+    };
     const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
     const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
     const stack = [{ dir: start, depth: 0 }];
@@ -255,6 +266,8 @@ export async function walk(env, root, start, ignore, signal) {
             if (info.kind === "directory") {
                 if (ignore(rel(info.path), true) || visited.has(info.path))
                     continue;
+                if (denyHit(info.path))
+                    continue;
                 if (depth < WALK_MAX_DEPTH)
                     stack.push({ dir: info.path, depth: depth + 1 });
                 else
@@ -263,6 +276,8 @@ export async function walk(env, root, start, ignore, signal) {
             else if (info.kind === "file") {
                 if (ignore(rel(info.path), false))
                     continue;
+                if (denyHit(info.path))
+                    continue;
                 if (typeof info.mtimeMs === "number")
                     mtimes.set(info.path, info.mtimeMs);
                 if (hasBinaryExtension(info.path)) {
@@ -290,7 +305,12 @@ export async function walk(env, root, start, ignore, signal) {
     }
     if (stack.length > 0 && out.length >= WALK_MAX_FILES)
         incomplete = true;
-    return { files: out, nameOnly, incomplete, skippedLarge, skippedUnreadable, aborted, mtimes };
+    return { files: out, nameOnly, incomplete, skippedLarge, skippedUnreadable, aborted, mtimes, denyPruned, denyPatterns };
+}
+export function denyWithheldNote(w) {
+    if (w.denyPruned <= 0)
+        return "";
+    return `\n[note: ${w.denyPruned} entr${w.denyPruned === 1 ? "y" : "ies"} matching the sensitive-path read deny list ${w.denyPruned === 1 ? "was" : "were"} withheld from this traversal (pruned entries' descendants not counted; patterns: ${w.denyPatterns.join(", ")})]`;
 }
 function walkCaveat(w, forContentSearch) {
     const parts = [];
@@ -737,7 +757,7 @@ function multilineSpans(content, p, captureText = false, deadline = Infinity) {
     }
     return spans;
 }
-export async function jsGrep(env, root, p, signal, guards) {
+export async function jsGrep(env, root, p, signal, guards, deny, denyOut) {
     const analysis = analyzeRedos(p.pattern, p.ignore_case === true);
     if (analysis.risk)
         return redosRejection(analysis.risk);
@@ -773,16 +793,22 @@ export async function jsGrep(env, root, p, signal, guards) {
                 skippedUnreadable: 0,
                 aborted: false,
                 mtimes: typeof info.value.mtimeMs === "number" ? new Map([[start, info.value.mtimeMs]]) : new Map(),
+                denyPruned: 0,
+                denyPatterns: [],
             };
         }
         else {
-            walked = await walk(env, root, start, ignore, signal);
+            walked = await walk(env, root, start, ignore, signal, deny);
         }
     }
     else {
-        walked = await walk(env, root, start, ignore, signal);
+        walked = await walk(env, root, start, ignore, signal, deny);
+    }
+    if (denyOut !== undefined && walked.denyPruned > 0) {
+        denyOut.withheld = { kind: "pruned_count", count: walked.denyPruned, patterns: walked.denyPatterns };
     }
-    let caveat = walkCaveat(walked, true);
+    let honestyCaveat = walkCaveat(walked, true);
+    const denyNote = denyWithheldNote(walked);
     let files = walked.files;
     files.sort();
     const cap = p.head_limit === 0 ? Infinity : Math.max(1, Math.floor(p.head_limit ?? GREP_DEFAULT_CAP));
@@ -937,11 +963,12 @@ export async function jsGrep(env, root, p, signal, guards) {
         if (multilineSkippedFiles > 0)
             extra.push(`${multilineSkippedFiles} file(s) skipped by multiline matching (content over ${longLineLimit} chars; the pattern's worst-case matching cost grows superlinearly with input length on the fallback engine)`);
         if (extra.length > 0) {
-            caveat = caveat.length > 0
-                ? caveat.replace(/\]$/, `; ${extra.join("; ")}]`)
+            honestyCaveat = honestyCaveat.length > 0
+                ? honestyCaveat.replace(/\]$/, `; ${extra.join("; ")}]`)
                 : `\n…[results may be incomplete: ${extra.join("; ")}]`;
         }
     }
+    const caveat = honestyCaveat + denyNote;
     const paged = (arr) => (off > 0 ? arr.slice(off, off + cap) : arr);
     const offNote = off > 0 ? `\n[offset ${off}]` : "";
     if (mode === "files_with_matches") {
@@ -1016,16 +1043,18 @@ function formatRgStdout(stdout, p, caveat = "") {
         (off > 0 ? `\n[offset ${off}]` : "") +
         caveat);
 }
-async function jsGrepFallback(env, root, p, signal, reason) {
-    const text = await jsGrep(env, root, p, signal);
+async function jsGrepFallback(env, root, p, signal, reason, deny) {
+    const denyOut = {};
+    const text = await jsGrep(env, root, p, signal, undefined, deny, denyOut);
     return {
         text: text.startsWith("Error (grep)")
             ? text
             : `${text}\n[note: ripgrep failed (${reason}); results are from a fallback scanner]`,
         degraded: { fallback: "js-scan", reason: `ripgrep failed (${reason})` },
+        ...(denyOut.withheld !== undefined ? { withheld: denyOut.withheld } : {}),
     };
 }
-export async function rgGrepDetailed(env, root, p, signal) {
+export async function rgGrepDetailed(env, root, p, signal, deny) {
     const mode = p.output_mode ?? "files_with_matches";
     const flags = ["--no-messages", "--no-require-git", "--hidden"];
     for (const d of VCS_DIRS)
@@ -1055,6 +1084,9 @@ export async function rgGrepDetailed(env, root, p, signal) {
             flags.push("--glob", shellQuote(g));
     if (p.type)
         flags.push("--type", shellQuote(p.type));
+    if (deny !== undefined)
+        for (const g of deny.rgExclusionGlobs)
+            flags.push(g.flag, shellQuote(g.glob));
     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 });
@@ -1070,13 +1102,26 @@ export async function rgGrepDetailed(env, root, p, signal) {
                     degraded: { partial: true, reason: "ripgrep timed out" },
                 };
             }
-            return jsGrepFallback(env, root, p, signal, "timed out with no output");
+            return jsGrepFallback(env, root, p, signal, "timed out with no output", deny);
         }
-        return jsGrepFallback(env, root, p, signal, `could not run: ${err.code}`);
+        return jsGrepFallback(env, root, p, signal, `could not run: ${err.code}`, deny);
     }
     const { exitCode, stdout } = res.value;
-    if (exitCode === 1)
-        return { text: NO_MATCHES };
+    const denyDisclosure = async () => {
+        if (deny === undefined || deny.rgExclusionGlobs.length === 0)
+            return { note: "" };
+        const withheld = await rgDenyExistenceProbe(env, root, deny, target, signal);
+        if (withheld === undefined)
+            return { note: "" };
+        const note = withheld.kind === "existence"
+            ? "\n[note: entries matching the sensitive-path read deny list exist under this scope and were excluded (readDenyPatterns)]"
+            : "\n[note: entries matching the sensitive-path read deny list may have been excluded (deny-existence probe failed)]";
+        return { note, withheld };
+    };
+    if (exitCode === 1) {
+        const d = await denyDisclosure();
+        return { text: NO_MATCHES + d.note, ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
+    }
     if (exitCode >= 2) {
         if (stdout.trim().length > 0) {
             return {
@@ -1084,15 +1129,45 @@ export async function rgGrepDetailed(env, root, p, signal) {
                 degraded: { partial: true, reason: `ripgrep exited with code ${exitCode}` },
             };
         }
-        return jsGrepFallback(env, root, p, signal, `exited with code ${exitCode} and produced no output`);
+        return jsGrepFallback(env, root, p, signal, `exited with code ${exitCode} and produced no output`, deny);
     }
     const orderedStdout = mode === "files_with_matches" ? await sortRgFilesByMtime(env, root, stdout, signal) : stdout;
-    return { text: formatRgStdout(orderedStdout, p) };
+    const d = await denyDisclosure();
+    return { text: formatRgStdout(orderedStdout, p) + d.note, ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
 }
-export async function runGrepDetailed(env, root, p, signal) {
+async function rgDenyExistenceProbe(env, root, deny, target, signal) {
+    const probeFlags = ["--files", "--hidden", "--no-require-git", "--no-messages"];
+    for (const d of VCS_DIRS)
+        probeFlags.push("--glob", `!${d}`);
+    for (const g of deny.rgProbeGlobs)
+        probeFlags.push(g.flag, shellQuote(g.glob));
+    try {
+        const res = await env.exec(`( rg ${probeFlags.join(" ")} -- ${target}; echo "__RG_PROBE_EXIT_$?" 1>&2 ) | head -n 1`, { cwd: root, timeout: 10, abortSignal: signal });
+        if (!res.ok)
+            return { kind: "probe_failed" };
+        const first = res.value.stdout.split("\n").find((l) => l.trim().length > 0);
+        if (first !== undefined) {
+            const hit = deny.matchPath(first.trim());
+            return { kind: "existence", ...(hit !== null ? { patterns: [hit.pattern] } : {}) };
+        }
+        const marker = /__RG_PROBE_EXIT_(\d+)/.exec(res.value.stderr ?? "");
+        const rgExit = marker === null ? undefined : Number(marker[1]);
+        if (rgExit === 1)
+            return undefined;
+        if (rgExit === 0)
+            return undefined;
+        return { kind: "probe_failed" };
+    }
+    catch {
+        return { kind: "probe_failed" };
+    }
+}
+export async function runGrepDetailed(env, root, p, signal, deny) {
     if (await detectRipgrep(env))
-        return rgGrepDetailed(env, root, p, signal);
-    return { text: await jsGrep(env, root, p, signal) };
+        return rgGrepDetailed(env, root, p, signal, deny);
+    const denyOut = {};
+    const text = await jsGrep(env, root, p, signal, undefined, deny, denyOut);
+    return { text, ...(denyOut.withheld !== undefined ? { withheld: denyOut.withheld } : {}) };
 }
 export async function runGrep(env, root, p, signal) {
     return (await runGrepDetailed(env, root, p, signal)).text;
@@ -1180,8 +1255,8 @@ export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
         }
         return ig;
     };
-    const walked = await walk(env, root, start, ignore, signal);
-    const caveat = walkCaveat(walked, false);
+    const walked = await walk(env, root, start, ignore, signal, opts.deny);
+    const caveat = walkCaveat(walked, false) + denyWithheldNote(walked);
     const files = [...walked.files, ...walked.nameOnly];
     const rel = (abs) => (abs.startsWith(rootPrefix) ? abs.slice(rootPrefix.length) : abs);
     const cap = Math.max(1, Math.floor(opts.max ?? 500));
@@ -1212,5 +1287,14 @@ export async function runGlobDetailed(env, root, pattern, opts = {}, signal) {
         ? `\n[note: the file-walk budget (${WALK_MAX_FILES} files / ${WALK_MAX_DEPTH} directory levels) ran out before the whole tree was scanned — this empty result is NOT proof the file is absent; scope the search with \`path\`, or use a root-anchored pattern (e.g. "src/**/*.ts") so the walk is pruned toward it, then retry]`
         : "";
     const text = matched.length === 0 ? "No files matched." + ignoreNote + ignoredFileNote + budgetNote + caveat : matched.join("\n") + capNote + caveat;
-    return { text, filenames: matched, numFiles: matched.length, truncated, durationMs: Date.now() - t0, totalMatches, countIsComplete };
+    return {
+        text,
+        filenames: matched,
+        numFiles: matched.length,
+        truncated,
+        durationMs: Date.now() - t0,
+        totalMatches,
+        countIsComplete,
+        ...(walked.denyPruned > 0 ? { withheld: { kind: "pruned_count", count: walked.denyPruned, patterns: walked.denyPatterns } } : {}),
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.29.0",
+  "version": "5.31.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",