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

Both use a Node.js fs-based implementation (no ripgrep dependency)
that skips node_modules, .git, and other non-source directories.

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,185 @@ 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 };
+
+/**
+ * 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. Reads files line-by-line and collects
+ * matches up to `maxResults`.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: file-walking search with early exits
+async function grepSearch(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[] = [];
+  let truncated = false;
+
+  for await (const rel of walkFiles(cwd, target, include)) {
+    if (matches.length >= maxResults) {
+      truncated = true;
+      break;
+    }
+    const absPath = path.join(cwd, rel);
+    let content: string;
+    try {
+      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) {
+          truncated = true;
+          break;
+        }
+      }
+    }
+  }
+
+  return { matches, truncated };
+}
+
+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 globSearch(
+  cwd: string,
+  pattern: string,
+  searchPath: string | undefined,
+  maxResults: number
+): Promise<{ files: string[]; truncated: boolean }> {
+  const target = searchPath ? safePath(cwd, searchPath) : cwd;
+  const files: string[] = [];
+  let truncated = false;
+
+  for await (const rel of walkFiles(cwd, target, pattern)) {
+    files.push(rel);
+    if (files.length >= maxResults + 1) {
+      truncated = true;
+      break;
+    }
+  }
+
+  if (truncated) {
+    files.length = maxResults;
+  }
+  return { files, truncated };
+}
+
+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 globSearch(
+        cwd,
+        pattern,
+        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";

src/lib/init/wizard-runner.ts

@@ -137,6 +137,20 @@ export function describeLocalOp(payload: LocalOpPayload): string {
     }
     case "list-dir":
       return "Listing directory...";
+    case "grep": {
+      const searches = payload.params.searches;
+      if (searches.length === 1 && searches[0]) {
+        return `Searching for ${safeCodeSpan(searches[0].pattern)}...`;
+      }
+      return `Running ${searches.length} searches...`;
+    }
+    case "glob": {
+      const patterns = payload.params.patterns;
+      if (patterns.length === 1 && patterns[0]) {
+        return `Finding files matching ${safeCodeSpan(patterns[0])}...`;
+      }
+      return `Finding files (${patterns.length} patterns)...`;
+    }
     case "create-sentry-project":
       return `Creating project ${safeCodeSpan(payload.params.name)} (${payload.params.platform})...`;
     case "detect-sentry":