sift-light 1.0.3-2 → 1.0.3-4

package/src/search-policy-stdin-filter.ts

@@ -0,0 +1,174 @@
+import { executableName, type ShellLanguage } from "./search-policy-commands.js";
+
+// Only options whose operands cannot name an input file are accepted here. Unknown
+// options fail closed, since grep variants and PowerShell aliases can add file inputs.
+const GREP_SWITCHES = new Set("abcEFGHhiILlnoPqsTUuvwxyzZ".split(""));
+const GREP_VALUE_OPTIONS = new Set(["A", "B", "C", "m"]);
+const GREP_LONG_SWITCHES = new Set([
+  "--basic-regexp",
+  "--extended-regexp",
+  "--fixed-strings",
+  "--perl-regexp",
+  "--ignore-case",
+  "--no-ignore-case",
+  "--invert-match",
+  "--word-regexp",
+  "--line-regexp",
+  "--count",
+  "--files-with-matches",
+  "--files-without-match",
+  "--only-matching",
+  "--quiet",
+  "--silent",
+  "--no-messages",
+  "--byte-offset",
+  "--line-number",
+  "--with-filename",
+  "--no-filename",
+  "--initial-tab",
+  "--null",
+  "--null-data",
+  "--text",
+  "--binary",
+  "--line-buffered",
+  "--no-group-separator",
+]);
+const GREP_LONG_VALUES = new Set([
+  "--after-context",
+  "--before-context",
+  "--context",
+  "--max-count",
+  "--binary-files",
+  "--label",
+  "--group-separator",
+  "--include",
+  "--exclude",
+  "--exclude-dir",
+]);
+
+function isStdinOnlyGrep(args: readonly (string | null)[]): boolean {
+  const positionals: string[] = [];
+  let hasPatternOption = false;
+  let optionsEnded = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === null || arg === undefined) return false;
+    // Some grep implementations (and GNU grep with POSIXLY_CORRECT) stop option
+    // parsing at the first operand. Later option-looking words can be file names.
+    if (positionals.length > 0 && arg !== "-") return false;
+    if (!optionsEnded && arg === "--") {
+      optionsEnded = true;
+      continue;
+    }
+    if (!optionsEnded && arg.startsWith("--")) {
+      const separator = arg.indexOf("=");
+      const option = separator < 0 ? arg : arg.slice(0, separator);
+      const attached = separator < 0 ? undefined : arg.slice(separator + 1);
+      if (option === "--regexp") {
+        hasPatternOption = true;
+      } else if (option === "--color" || option === "--colour") {
+        continue;
+      } else if (GREP_LONG_SWITCHES.has(option) && attached === undefined) {
+        continue;
+      } else if (!GREP_LONG_VALUES.has(option)) {
+        return false;
+      }
+      if (attached === undefined) {
+        index += 1;
+        if (args[index] === null || args[index] === undefined) return false;
+      }
+      continue;
+    }
+    if (!optionsEnded && arg.startsWith("-") && arg !== "-") {
+      for (let optionIndex = 1; optionIndex < arg.length; optionIndex += 1) {
+        const option = arg[optionIndex];
+        if (option === "e") {
+          hasPatternOption = true;
+        } else if (option !== undefined && GREP_SWITCHES.has(option)) {
+          continue;
+        } else if (option === undefined || !GREP_VALUE_OPTIONS.has(option)) {
+          return false;
+        }
+        if (optionIndex === arg.length - 1) {
+          index += 1;
+          if (args[index] === null || args[index] === undefined) return false;
+        }
+        break;
+      }
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return hasPatternOption
+    ? positionals.every((operand) => operand === "-")
+    : positionals.length > 0 && positionals.slice(1).every((operand) => operand === "-");
+}
+
+const SELECT_STRING_SWITCHES = new Set([
+  "simplematch",
+  "casesensitive",
+  "quiet",
+  "list",
+  "noemphasis",
+  "notmatch",
+  "allmatches",
+  "raw",
+  "verbose",
+  "debug",
+]);
+const SELECT_STRING_VALUES = new Set([
+  "culture",
+  "encoding",
+  "context",
+  "erroraction",
+  "warningaction",
+  "informationaction",
+  "outvariable",
+  "pipelinevariable",
+]);
+
+function isPipelineOnlySelectString(
+  args: readonly (string | null)[],
+  namedParameters: readonly boolean[],
+): boolean {
+  let hasPattern = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === null || arg === undefined) return false;
+    if (!namedParameters[index]) {
+      if (hasPattern) return false; // Further positional values can bind to -Path.
+      hasPattern = true;
+      continue;
+    }
+    const separator = arg.indexOf(":");
+    const option = (separator < 0 ? arg.slice(1) : arg.slice(1, separator)).toLowerCase();
+    if (SELECT_STRING_SWITCHES.has(option) && separator < 0) continue;
+    if (option !== "pattern" && !SELECT_STRING_VALUES.has(option)) return false;
+    if (option === "pattern") {
+      if (hasPattern) return false;
+      hasPattern = true;
+    }
+    if (separator < 0) {
+      index += 1;
+      if (args[index] === null || args[index] === undefined) return false;
+    }
+  }
+  return hasPattern;
+}
+
+/** The exception is for filters consuming the pipeline, never for file operands. */
+export function isStdinOnlySearchFilter(
+  words: readonly (string | null)[],
+  language: ShellLanguage,
+  namedParameters: readonly boolean[],
+): boolean {
+  const executable = words[0];
+  if (executable === null || executable === undefined) return false;
+  const name = executableName(executable);
+  if (language === "powershell")
+    return (
+      ["select-string", "sls"].includes(name.toLowerCase()) &&
+      isPipelineOnlySelectString(words.slice(1), namedParameters.slice(1))
+    );
+  return ["grep", "egrep", "fgrep"].includes(name) && isStdinOnlyGrep(words.slice(1));
+}

package/src/search-policy.ts

@@ -3,7 +3,7 @@ import { recoverShellSearch } from "./search-policy-recovery.js";
 import { ShellSearchPolicy, type ShellSearchMatch } from "./search-policy-shell.js";
 
 export const SEARCH_POLICY_GUIDANCE =
-  "Local content and filename searches must use sift-light. Built-in search tools and direct search commands are blocked before execution; filtering output from an unrelated producer at a pipeline tail remains available. Use pattern for contents or mode=files with query for filenames. Keep read/edit/write, tests and builds available. After a denial, call sift-light once with the stated repair; do not paste the denial into the request, repeat the blocked call, use another shell/custom script, or weaken the search mode.";
+  "Local content and filename searches must use sift-light. Built-in search tools and direct search commands are blocked before execution; recognized stdin-only filtering of output from an unrelated producer remains available at any pipeline position. File operands, recursive search options, file-sourced patterns and input redirection are not filter exceptions. Use pattern for contents or mode=files with query for filenames. Keep read/edit/write, tests and builds available. After a denial, call sift-light once with the stated repair; do not paste the denial into the request, repeat the blocked call, use another shell/custom script, or weaken the search mode.";
 export const PI_REPLACED_SEARCH_TOOLS = new Set(["grep", "find"]);
 export const PREFERRED_SEARCH_GUIDANCE =
   "Prefer sift-light for local content and filename searches because it provides bounded evidence, coverage and continuation details. Conventional search entries remain available in advisory mode.";

package/src/service.ts

@@ -598,7 +598,11 @@ export class SiftLightService {
 
     const request = normalizeRequest(input);
     let scan = await this.#runRipgrep(request, cwd, signal);
-    if (scan.totalMatches === 0 && request.path !== undefined && request.scope !== "strict") {
+    if (
+      scan.totalMatches === 0 &&
+      request.path !== undefined &&
+      (await new SearchPathPolicy(cwd).allowsScopeExpansion(request.path, request.scope))
+    ) {
       const { path: requestedPath, ...projectRequest } = request;
       scan = await this.#runRipgrep(
         { ...projectRequest, expandedFromPath: requestedPath },

package/src/workspace-files.ts

@@ -55,6 +55,7 @@ export async function listWorkspaceFiles(
   const absolutePath = resolve(cwd, options.path ?? ".");
   const policy = new SearchPathPolicy(cwd);
   const searchPath = await policy.resolveSearchTarget(absolutePath);
+  const ripgrepCwd = await policy.ripgrepWorkingDirectory(searchPath);
   const maxFiles = options.maxFiles ?? MAX_SOURCE_REVISION_FILES;
   if (!Number.isSafeInteger(maxFiles) || maxFiles < 1)
     throw new SiftLightError("Candidate file limit must be a positive integer");
@@ -81,7 +82,7 @@ export async function listWorkspaceFiles(
           "--",
           searchPath,
         ],
-        cwd,
+        cwd: ripgrepCwd,
         ...(signal ? { signal } : {}),
       },
       async (stdout) => {