feat(init): add grep and glob local-op handlers

Add two new local-op types that let the server search project files
without reading them all:

- grep: regex search across files with optional glob filter, batched
  (multiple patterns in one round-trip), capped at 100 matches per
  search with 2000-char line truncation

- glob: find files by pattern, batched (multiple patterns in one
  round-trip), capped at 100 results

Uses ripgrep (rg) when available for speed and native binary file
detection. Falls back to a Node.js fs-based implementation that skips
node_modules, .git, and other non-source directories, with a per-file
size cap matching MAX_FILE_BYTES (256KB).

Counterpart server-side schemas will be added in cli-init-api.

Made-with: Cursor

Author: betegon

src/lib/init/local-ops.ts

@@ -32,6 +32,8 @@ import type {
   DetectSentryPayload,
   DirEntry,
   FileExistsBatchPayload,
+  GlobPayload,
+  GrepPayload,
   ListDirPayload,
   LocalOpPayload,
   LocalOpResult,
@@ -313,6 +315,10 @@ export async function handleLocalOp(
         return await runCommands(payload, options.dryRun);
       case "apply-patchset":
         return await applyPatchset(payload, options.dryRun);
+      case "grep":
+        return await grep(payload);
+      case "glob":
+        return await glob(payload);
       case "create-sentry-project":
         return await createSentryProject(payload, options);
       case "detect-sentry":
@@ -846,6 +852,331 @@ async function detectSentry(
   };
 }
 
+// ── Grep & Glob ─────────────────────────────────────────────────────
+
+const MAX_GREP_RESULTS_PER_SEARCH = 100;
+const MAX_GREP_LINE_LENGTH = 2000;
+const MAX_GLOB_RESULTS = 100;
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+]);
+
+type GrepMatch = { path: string; lineNum: number; line: string };
+
+// ── Ripgrep implementations (preferred when rg is on PATH) ──────────
+
+function spawnCollect(
+  cmd: string,
+  args: string[],
+  cwd: string
+): Promise<{ stdout: string; ok: boolean }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 30_000,
+    });
+
+    const chunks: Buffer[] = [];
+    let len = 0;
+    child.stdout.on("data", (chunk: Buffer) => {
+      if (len < MAX_OUTPUT_BYTES) {
+        chunks.push(chunk);
+        len += chunk.length;
+      }
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+    child.on("close", (code) => {
+      resolve({
+        stdout: Buffer.concat(chunks).toString("utf-8"),
+        ok: code === 0 || code === 1,
+      });
+    });
+  });
+}
+
+function parseRgGrepOutput(
+  cwd: string,
+  stdout: string,
+  maxResults: number
+): { matches: GrepMatch[]; truncated: boolean } {
+  const lines = stdout.split("\n").filter(Boolean);
+  const truncated = lines.length > maxResults;
+  const matches: GrepMatch[] = [];
+
+  for (const line of lines.slice(0, maxResults)) {
+    const sepIdx = line.indexOf(":");
+    if (sepIdx === -1) {
+      continue;
+    }
+    const filePart = line.substring(0, sepIdx);
+    const rest = line.substring(sepIdx + 1);
+    const numSepIdx = rest.indexOf(":");
+    if (numSepIdx === -1) {
+      continue;
+    }
+    const lineNum = Number.parseInt(rest.substring(0, numSepIdx), 10);
+    let text = rest.substring(numSepIdx + 1);
+    if (text.length > MAX_GREP_LINE_LENGTH) {
+      text = `${text.substring(0, MAX_GREP_LINE_LENGTH)}…`;
+    }
+    matches.push({ path: path.relative(cwd, filePart), lineNum, line: text });
+  }
+
+  return { matches, truncated };
+}
+
+async function rgGrepSearch(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  include: string | undefined;
+  maxResults: number;
+}): Promise<{ matches: GrepMatch[]; truncated: boolean }> {
+  const { cwd, pattern, searchPath, include, maxResults } = opts;
+  const target = searchPath ? safePath(cwd, searchPath) : cwd;
+  const args = [
+    "-nH",
+    "--no-messages",
+    "--hidden",
+    "--max-count",
+    String(maxResults + 1),
+    "--regexp",
+    pattern,
+  ];
+  if (include) {
+    args.push("--glob", include);
+  }
+  args.push(target);
+
+  const { stdout } = await spawnCollect("rg", args, cwd);
+  return parseRgGrepOutput(cwd, stdout, maxResults);
+}
+
+async function rgGlobSearch(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  maxResults: number;
+}): Promise<{ files: string[]; truncated: boolean }> {
+  const { cwd, pattern, searchPath, maxResults } = opts;
+  const target = searchPath ? safePath(cwd, searchPath) : cwd;
+  const args = ["--files", "--hidden", "--glob", pattern, target];
+
+  const { stdout } = await spawnCollect("rg", args, cwd);
+  const lines = stdout.split("\n").filter(Boolean);
+  const truncated = lines.length > maxResults;
+  const files = lines.slice(0, maxResults).map((f) => path.relative(cwd, f));
+  return { files, truncated };
+}
+
+// ── Node.js fallback (when rg is not installed) ─────────────────────
+
+/**
+ * Recursively walk a directory, yielding relative file paths.
+ * Skips common non-source directories and respects an optional glob filter.
+ */
+async function* walkFiles(
+  root: string,
+  base: string,
+  globPattern: string | undefined
+): AsyncGenerator<string> {
+  let entries: fs.Dirent[];
+  try {
+    entries = await fs.promises.readdir(base, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(base, entry.name);
+    const rel = path.relative(root, full);
+    if (
+      entry.isDirectory() &&
+      !SKIP_DIRS.has(entry.name) &&
+      !entry.name.startsWith(".")
+    ) {
+      yield* walkFiles(root, full, globPattern);
+    } else if (
+      entry.isFile() &&
+      (!globPattern || matchGlob(entry.name, globPattern))
+    ) {
+      yield rel;
+    }
+  }
+}
+
+/** Minimal glob matcher — supports `*` and `?` wildcards. */
+function matchGlob(name: string, pattern: string): boolean {
+  const re = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${re}$`).test(name);
+}
+
+/**
+ * Search files for a regex pattern using Node.js fs. Fallback for when
+ * ripgrep is not available.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: file-walking search with early exits
+async function fsGrepSearch(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  include: string | undefined;
+  maxResults: number;
+}): Promise<{ matches: GrepMatch[]; truncated: boolean }> {
+  const { cwd, pattern, searchPath, include, maxResults } = opts;
+  const target = searchPath ? safePath(cwd, searchPath) : cwd;
+  const regex = new RegExp(pattern);
+  const matches: GrepMatch[] = [];
+
+  for await (const rel of walkFiles(cwd, target, include)) {
+    if (matches.length > maxResults) {
+      break;
+    }
+    const absPath = path.join(cwd, rel);
+    let content: string;
+    try {
+      const stat = await fs.promises.stat(absPath);
+      if (stat.size > MAX_FILE_BYTES) {
+        continue;
+      }
+      content = await fs.promises.readFile(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i] ?? "";
+      if (regex.test(line)) {
+        let text = line;
+        if (text.length > MAX_GREP_LINE_LENGTH) {
+          text = `${text.substring(0, MAX_GREP_LINE_LENGTH)}…`;
+        }
+        matches.push({ path: rel, lineNum: i + 1, line: text });
+        if (matches.length > maxResults) {
+          break;
+        }
+      }
+    }
+  }
+
+  const truncated = matches.length > maxResults;
+  if (truncated) {
+    matches.length = maxResults;
+  }
+  return { matches, truncated };
+}
+
+async function fsGlobSearch(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  maxResults: number;
+}): Promise<{ files: string[]; truncated: boolean }> {
+  const { cwd, pattern, searchPath, maxResults } = opts;
+  const target = searchPath ? safePath(cwd, searchPath) : cwd;
+  const files: string[] = [];
+
+  for await (const rel of walkFiles(cwd, target, pattern)) {
+    files.push(rel);
+    if (files.length > maxResults) {
+      break;
+    }
+  }
+
+  const truncated = files.length > maxResults;
+  if (truncated) {
+    files.length = maxResults;
+  }
+  return { files, truncated };
+}
+
+// ── Dispatch: try rg, fall back to Node.js ──────────────────────────
+
+async function grepSearch(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  include: string | undefined;
+  maxResults: number;
+}): Promise<{ matches: GrepMatch[]; truncated: boolean }> {
+  try {
+    return await rgGrepSearch(opts);
+  } catch {
+    return await fsGrepSearch(opts);
+  }
+}
+
+async function globSearchImpl(opts: {
+  cwd: string;
+  pattern: string;
+  searchPath: string | undefined;
+  maxResults: number;
+}): Promise<{ files: string[]; truncated: boolean }> {
+  try {
+    return await rgGlobSearch(opts);
+  } catch {
+    return await fsGlobSearch(opts);
+  }
+}
+
+async function grep(payload: GrepPayload): Promise<LocalOpResult> {
+  const { cwd, params } = payload;
+  const maxResults = params.maxResultsPerSearch ?? MAX_GREP_RESULTS_PER_SEARCH;
+
+  const results = await Promise.all(
+    params.searches.map(async (search) => {
+      const { matches, truncated } = await grepSearch({
+        cwd,
+        pattern: search.pattern,
+        searchPath: search.path,
+        include: search.include,
+        maxResults,
+      });
+      return {
+        pattern: search.pattern,
+        matches,
+        truncated,
+        totalMatches: matches.length,
+      };
+    })
+  );
+
+  return { ok: true, data: { results } };
+}
+
+async function glob(payload: GlobPayload): Promise<LocalOpResult> {
+  const { cwd, params } = payload;
+  const maxResults = params.maxResults ?? MAX_GLOB_RESULTS;
+
+  const results = await Promise.all(
+    params.patterns.map(async (pattern) => {
+      const { files, truncated } = await globSearchImpl({
+        cwd,
+        pattern,
+        searchPath: params.path,
+        maxResults,
+      });
+      return { pattern, files, truncated };
+    })
+  );
+
+  return { ok: true, data: { results } };
+}
+
+// ── Sentry project + DSN ────────────────────────────────────────────
+
 async function createSentryProject(
   payload: CreateSentryProjectPayload,
   options: WizardOptions

src/lib/init/types.ts

@@ -25,6 +25,8 @@ export type LocalOpPayload =
   | FileExistsBatchPayload
   | RunCommandsPayload
   | ApplyPatchsetPayload
+  | GrepPayload
+  | GlobPayload
   | CreateSentryProjectPayload
   | DetectSentryPayload;
 
@@ -69,6 +71,33 @@ export type RunCommandsPayload = {
   };
 };
 
+export type GrepSearch = {
+  pattern: string;
+  path?: string;
+  include?: string;
+};
+
+export type GrepPayload = {
+  type: "local-op";
+  operation: "grep";
+  cwd: string;
+  params: {
+    searches: GrepSearch[];
+    maxResultsPerSearch?: number;
+  };
+};
+
+export type GlobPayload = {
+  type: "local-op";
+  operation: "glob";
+  cwd: string;
+  params: {
+    patterns: string[];
+    path?: string;
+    maxResults?: number;
+  };
+};
+
 export type ApplyPatchsetPayload = {
   type: "local-op";
   operation: "apply-patchset";