fix: 🐛 Add path and -l support

Author: chezsmithy

core/tools/definitions/grepSearch.ts

@@ -21,20 +21,28 @@ export const grepSearchTool: Tool = {
         query: {
           type: "string",
           description:
-            "The search query to use. Must be a valid ripgrep regex expression, escaped where needed",
+            "The search query to use. Must be a valid ripgrep regex expression. For word boundaries use \\b, for literal parentheses use \\(, for alternations use (pattern1|pattern2). Examples: 'function.*add', '\\bclass\\b', 'add.*\\(', '\\b(def|function)\\b'",
         },
         args: {
           type: "array",
           items: { type: "string" },
           description:
             "Optional additional ripgrep arguments, for example ['-n', '-w']",
         },
+        path: {
+          type: "string",
+          description:
+            "Optional path to search in - can be a specific file (e.g., 'src/main.ts') or directory (e.g., 'src/'). If not provided, searches entire project.",
+        },
       },
     },
   },
   defaultToolPolicy: "allowedWithoutPermission",
   systemMessageDescription: {
     prefix: `To perform a grep search within the project, call the ${BuiltInToolNames.GrepSearch} tool with the query pattern to match. For example:`,
-    exampleArgs: [["query", ".*main_services.*"]],
+    exampleArgs: [
+      ["query", ".*main_services.*"],
+      ["query", "throw new Error"],
+    ],
   },
 };

core/tools/implementations/grepSearch.ts

@@ -47,9 +47,11 @@ function splitGrepResultsByFile(content: string): ContextItem[] {
 export const grepSearchImpl: ToolImpl = async (args, extras) => {
   const query = getStringArg(args, "query");
   const extraArgs = getOptionalStringArrayArg(args, "args");
+  const path = args.path as string | undefined;
   const ripgrepArgs = buildRipgrepArgs(query, {
     extraArgs,
     maxResults: DEFAULT_GREP_SEARCH_RESULTS_LIMIT,
+    path,
   });
 
   const results = await extras.ide.getSearchResults(

core/util/grepSearch.ts

@@ -20,20 +20,83 @@ function sanitizeRipgrepArgs(args?: string[]): string[] {
   );
 }
 
+/**
+ * Validates and sanitizes a search path for use with ripgrep
+ * @param searchPath The path to validate (can be file or directory)
+ * @returns The sanitized path or throws an error if invalid
+ */
+function validateSearchPath(searchPath: string): string {
+  // Remove any potentially dangerous characters
+  const dangerous = /[|;&`$(){}[\]]/;
+  if (dangerous.test(searchPath)) {
+    throw new Error(`Invalid characters in search path: ${searchPath}`);
+  }
+
+  // Normalize path separators and remove leading/trailing whitespace
+  const normalized = searchPath.trim().replace(/\\/g, "/");
+
+  // Don't allow absolute paths or path traversal for security
+  if (
+    normalized.startsWith("/") ||
+    normalized.includes("../") ||
+    normalized.includes("..\\")
+  ) {
+    throw new Error(
+      `Absolute paths and path traversal not allowed: ${searchPath}`,
+    );
+  }
+
+  return normalized;
+}
+
+/**
+ * Validates and potentially fixes common regex pattern issues for ripgrep
+ * @param query The regex pattern to validate
+ * @returns The validated pattern or throws an error if invalid
+ */
+function validateRipgrepPattern(query: string): string {
+  // Check for common problematic patterns and provide helpful error messages
+  if (query.includes("\\b") && query.includes("|")) {
+    // Common issue: complex patterns with word boundaries and alternations
+    // These should work but may need careful escaping
+    console.warn(
+      "Complex pattern detected with word boundaries and alternations. Ensure proper escaping.",
+    );
+  }
+
+  if (query.match(/\\[^bdswnrtfav\\]/)) {
+    console.warn(
+      "Unusual escape sequence detected in pattern. Double-check escaping.",
+    );
+  }
+
+  return query;
+}
+
 export function buildRipgrepArgs(
   query: string,
-  { extraArgs, maxResults }: { extraArgs?: string[]; maxResults?: number } = {},
+  {
+    extraArgs,
+    maxResults,
+    path,
+  }: { extraArgs?: string[]; maxResults?: number; path?: string } = {},
 ): string[] {
   const args = [...DEFAULT_RIPGREP_ARGS];
   const sanitized = sanitizeRipgrepArgs(extraArgs);
 
+  // Validate the query pattern
+  const validatedQuery = validateRipgrepPattern(query);
+
   let before = DEFAULT_CONTEXT_BEFORE;
   let after = DEFAULT_CONTEXT_AFTER;
   const remaining: string[] = [];
 
   for (let i = 0; i < sanitized.length; i++) {
     const arg = sanitized[i];
-    if ((arg === "-A" || arg === "-B" || arg === "-C") && i + 1 < sanitized.length) {
+    if (
+      (arg === "-A" || arg === "-B" || arg === "-C") &&
+      i + 1 < sanitized.length
+    ) {
       const val = parseInt(sanitized[i + 1]!, 10);
       if (!isNaN(val)) {
         if (arg === "-A") {
@@ -64,14 +127,22 @@ export function buildRipgrepArgs(
   }
 
   args.push(...remaining);
-  args.push("-e", query, ".");
+
+  // Determine search target (path or current directory)
+  const searchTarget = path ? validateSearchPath(path) : ".";
+  args.push("-e", validatedQuery, searchTarget);
   return args;
 }
 
 /*
   Formats the output of a grep search to reduce unnecessary indentation, lines, etc
-  Assumes a command with these params
+  Handles both standard ripgrep output with --heading and simple file lists (e.g., with -l flag)
+  
+  Standard format:
     ripgrep -i --ignore-file .continueignore --ignore-file .gitignore -C 2 --heading -m 100 -e <query> .
+  
+  File list format (with -l flag):
+    ripgrep -l -i --ignore-file .continueignore --ignore-file .gitignore -e <query> .
 
   Also can truncate the output to a specified number of characters
 */
@@ -86,15 +157,48 @@ export function formatGrepSearchResults(
   let numResults = 0;
   const keepLines: string[] = [];
 
+  // Check if this looks like a simple file list (all lines start with ./ and no content)
+  const lines = results.split("\n").filter((l) => !!l);
+  const isFileListOnly =
+    lines.length > 0 &&
+    lines.every((line) => line.startsWith("./") || line === "No matches found");
+
+  if (isFileListOnly) {
+    // Handle simple file list output (e.g., from -l flag)
+    const fileLines = lines.filter((line) => line.startsWith("./"));
+    numResults = fileLines.length;
+    const formatted = fileLines.join("\n");
+
+    if (maxChars && formatted.length > maxChars) {
+      return {
+        formatted: formatted.substring(0, maxChars),
+        numResults,
+        truncated: true,
+      };
+    } else {
+      return {
+        formatted,
+        numResults,
+        truncated: false,
+      };
+    }
+  }
+
+  // Handle standard format with content
   function countLeadingSpaces(line: string) {
     return line?.match(/^ */)?.[0].length ?? 0;
   }
 
   const processResult = (lines: string[]) => {
-    // Skip results in which only the file path was kept
+    // Handle file path lines
     const resultPath = lines[0];
     const resultContent = lines.slice(1);
+
+    // For file-only results (like with -l), still include the path
     if (resultContent.length === 0) {
+      if (resultPath && resultPath.startsWith("./")) {
+        keepLines.push(resultPath);
+      }
       return;
     }
 
@@ -126,7 +230,7 @@ export function formatGrepSearchResults(
   };
 
   let resultLines: string[] = [];
-  for (const line of results.split("\n").filter((l) => !!l)) {
+  for (const line of lines) {
     if (line.startsWith("./") || line === "--") {
       processResult(resultLines); // process previous result
       resultLines = [line];

core/util/grepSearch.vitest.ts

@@ -118,13 +118,16 @@ test("handles empty input", () => {
   expect(result.formatted).toBe("");
 });
 
-test("handles input with only file paths (no content) - lines should be skipped", () => {
+test("handles input with only file paths (no content) - now includes file paths", () => {
   const input =
     "./empty-file.ts\n./another-empty.js\n./has-content.ts\n searchMatch";
   const result = formatGrepSearchResults(input);
 
   expect(result.numResults).toBe(3);
-  expect(result.formatted).toBe("./has-content.ts\n  searchMatch");
+  // Now includes all file paths, including empty ones, plus content for files that have matches
+  expect(result.formatted).toBe(
+    "./empty-file.ts\n./another-empty.js\n./has-content.ts\n  searchMatch",
+  );
 });
 
 test("truncates output when exceeding maxChars", () => {
@@ -302,3 +305,122 @@ test("buildRipgrepArgs merges context flags", () => {
     ".",
   ]);
 });
+
+// Tests for -l flag handling
+test("handles -l flag output (files only)", () => {
+  const fileListOutput = `./src/main.ts
+./src/utils.ts
+./tests/main.test.ts`;
+
+  const result = formatGrepSearchResults(fileListOutput);
+
+  expect(result.numResults).toBe(3);
+  expect(result.truncated).toBe(false);
+  expect(result.formatted).toBe(fileListOutput);
+});
+
+test("handles empty -l flag output", () => {
+  const result = formatGrepSearchResults("");
+
+  expect(result.numResults).toBe(0);
+  expect(result.truncated).toBe(false);
+  expect(result.formatted).toBe("");
+});
+
+test("handles no matches found message", () => {
+  const noMatchesOutput = "No matches found";
+
+  const result = formatGrepSearchResults(noMatchesOutput);
+
+  expect(result.numResults).toBe(0);
+  expect(result.truncated).toBe(false);
+  expect(result.formatted).toBe("");
+});
+
+test("buildRipgrepArgs handles -l flag correctly", () => {
+  const argsWithL = buildRipgrepArgs("test", { extraArgs: ["-l"] });
+  expect(argsWithL).toContain("-l");
+  expect(argsWithL).toEqual([
+    "-i",
+    "--ignore-file",
+    ".continueignore",
+    "--ignore-file",
+    ".gitignore",
+    "-C",
+    "2",
+    "--heading",
+    "-l",
+    "-e",
+    "test",
+    ".",
+  ]);
+});
+
+// Tests for complex regex patterns
+test("buildRipgrepArgs handles complex regex patterns", () => {
+  const complexPattern = "\\b(def|function).*\\badd\\b.*\\(";
+  const args = buildRipgrepArgs(complexPattern);
+
+  expect(args).toContain("-e");
+  const eIndex = args.indexOf("-e");
+  expect(args[eIndex + 1]).toBe(complexPattern);
+});
+
+test("buildRipgrepArgs handles word boundaries", () => {
+  const wordBoundaryPattern = "\\bfunction\\b";
+  const args = buildRipgrepArgs(wordBoundaryPattern);
+
+  expect(args).toContain("-e");
+  const eIndex = args.indexOf("-e");
+  expect(args[eIndex + 1]).toBe(wordBoundaryPattern);
+});
+
+test("buildRipgrepArgs handles parentheses in patterns", () => {
+  const parenPattern = "add.*\\(";
+  const args = buildRipgrepArgs(parenPattern);
+
+  expect(args).toContain("-e");
+  const eIndex = args.indexOf("-e");
+  expect(args[eIndex + 1]).toBe(parenPattern);
+});
+
+// Tests for path parameter
+test("buildRipgrepArgs handles file path", () => {
+  const args = buildRipgrepArgs("test", { path: "src/main.ts" });
+
+  expect(args).toContain("src/main.ts");
+  expect(args[args.length - 1]).toBe("src/main.ts");
+});
+
+test("buildRipgrepArgs handles directory path", () => {
+  const args = buildRipgrepArgs("test", { path: "src/" });
+
+  expect(args).toContain("src/");
+  expect(args[args.length - 1]).toBe("src/");
+});
+
+test("buildRipgrepArgs defaults to current directory when no path specified", () => {
+  const args = buildRipgrepArgs("test");
+
+  expect(args[args.length - 1]).toBe(".");
+});
+
+test("buildRipgrepArgs rejects dangerous paths", () => {
+  expect(() => {
+    buildRipgrepArgs("test", { path: "/etc/passwd" });
+  }).toThrow("Absolute paths and path traversal not allowed");
+
+  expect(() => {
+    buildRipgrepArgs("test", { path: "../../../etc/passwd" });
+  }).toThrow("Absolute paths and path traversal not allowed");
+
+  expect(() => {
+    buildRipgrepArgs("test", { path: "file;rm -rf /" });
+  }).toThrow("Invalid characters in search path");
+});
+
+test("buildRipgrepArgs normalizes paths", () => {
+  const args = buildRipgrepArgs("test", { path: "  src\\main.ts  " });
+
+  expect(args[args.length - 1]).toBe("src/main.ts");
+});