claude-code-session-manager 0.57.1 → 0.59.0

package/src/main/repoAnalyzer.cjs

@@ -1,346 +0,0 @@
-/**
- * repo:analyze(cwd) — walk a project tree and return a compact stats snapshot
- * for the RepoVisualizationModal.
- *
- * Ported in spirit from ClaudeCodeUnleashed's src/main/ipc/repoAnalyzer.ts, but
- * stripped down to what we actually surface (no dependency listing, no full
- * tree return, no file-content fetch). The renderer renders:
- *   - language breakdown bar (extension → file count, line count)
- *   - top directories treemap
- *   - uncommitted-file badge from git:status
- * so the IPC return shape stays in lockstep with what the modal needs.
- *
- * Security:
- *   - cwd is validatePath'd (allowedRoots = home). Never follows symlinks
- *     (lstat-based; dirent.isSymbolicLink() check on every entry).
- *   - Hard ceilings: 30s wall-clock, 5000 files, 100KB per-file line counting.
- *   - Reads only — no writes, no spawn.
- *
- * Complexity: O(N) entries where N = files+dirs visited (bounded by
- *   MAX_FILES_TO_ANALYZE). Tail-recursion stack depth is bounded by
- *   MAX_DEPTH (10) so no stack hazards on pathologically nested trees.
- */
-
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const { validatePath } = require('./config.cjs');
-const { schemas } = require('./ipcSchemas.cjs');
-const gitMod = require('./git.cjs');
-
-// Directories to skip — `.git`, common build / dep / cache dirs.
-const IGNORE_DIRS = new Set([
-  '.git', 'node_modules', 'dist', 'build', 'out', '.next', '.nuxt',
-  'coverage', '.cache', '.vscode', '.idea', '__pycache__', 'venv',
-  '.env', 'target', 'vendor', 'bower_components',
-  '.turbo', '.parcel-cache', '.svelte-kit', '.angular',
-]);
-
-// Filenames to skip outright (lockfiles, OS detritus).
-const IGNORE_FILES = new Set([
-  '.DS_Store', 'Thumbs.db',
-  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
-]);
-
-// Per-extension display name. Anything not in here lumps under 'other'.
-const LANG_LABELS = {
-  '.ts': 'TypeScript',
-  '.tsx': 'TSX',
-  '.js': 'JavaScript',
-  '.jsx': 'JSX',
-  '.cjs': 'CommonJS',
-  '.mjs': 'ES Module',
-  '.json': 'JSON',
-  '.css': 'CSS',
-  '.scss': 'SCSS',
-  '.less': 'Less',
-  '.html': 'HTML',
-  '.md': 'Markdown',
-  '.mdx': 'MDX',
-  '.py': 'Python',
-  '.go': 'Go',
-  '.rs': 'Rust',
-  '.java': 'Java',
-  '.kt': 'Kotlin',
-  '.c': 'C',
-  '.cpp': 'C++',
-  '.cc': 'C++',
-  '.h': 'C/C++ Header',
-  '.hpp': 'C++ Header',
-  '.swift': 'Swift',
-  '.rb': 'Ruby',
-  '.php': 'PHP',
-  '.sql': 'SQL',
-  '.sh': 'Shell',
-  '.bash': 'Shell',
-  '.zsh': 'Shell',
-  '.yaml': 'YAML',
-  '.yml': 'YAML',
-  '.toml': 'TOML',
-  '.xml': 'XML',
-  '.svg': 'SVG',
-  '.vue': 'Vue',
-  '.svelte': 'Svelte',
-};
-
-// Caps. Wall-clock is enforced by an AbortController-style deadline; the
-// per-file line cap stops giant generated files (e.g. 5 MB package-lock that
-// somehow escapes the ignore list) from blocking the event loop.
-const MAX_DEPTH = 12;
-const MAX_FILES_TO_ANALYZE = 5000;
-const MAX_FILE_SIZE_FOR_LINE_COUNT = 100 * 1024; // 100 KiB
-const DEADLINE_MS = 30_000;
-const TOP_DIRS_LIMIT = 10;
-
-/** Count newlines without loading entire file into memory beyond the cap. */
-async function countLines(filePath, sizeHint) {
-  if (sizeHint > MAX_FILE_SIZE_FOR_LINE_COUNT) return 0;
-  try {
-    const buf = await fsp.readFile(filePath);
-    if (buf.length === 0) return 0;
-    let n = 1;
-    for (let i = 0; i < buf.length; i++) {
-      if (buf[i] === 0x0a) n++;
-    }
-    // Don't count a final empty trailing line.
-    if (buf[buf.length - 1] === 0x0a) n--;
-    return n;
-  } catch {
-    return 0;
-  }
-}
-
-function languageKey(ext) {
-  if (!ext) return 'other';
-  return LANG_LABELS[ext] ? ext.slice(1) : 'other';
-}
-
-/**
- * Recursive walk. Mutates `ctx` (single object per top-level call) so we
- * don't allocate a fresh stats frame per directory — keeps the hot path
- * contiguous (CLAUDE.md performance guidance). Stops early when deadline is
- * past or the file ceiling is hit.
- *
- * Returns the per-immediate-subtree { fileCount, totalLines } so the caller
- * (one level up) can attribute it to the top-level directory bucket.
- */
-async function walk(absDir, relDir, depth, ctx) {
-  if (ctx.stopped || Date.now() > ctx.deadline) {
-    ctx.stopped = true;
-    return { fileCount: 0, totalLines: 0 };
-  }
-  if (depth > MAX_DEPTH) return { fileCount: 0, totalLines: 0 };
-
-  let entries;
-  try {
-    entries = await fsp.readdir(absDir, { withFileTypes: true });
-  } catch {
-    return { fileCount: 0, totalLines: 0 };
-  }
-
-  let subFiles = 0;
-  let subLines = 0;
-
-  for (const entry of entries) {
-    if (ctx.stopped) break;
-    if (Date.now() > ctx.deadline) {
-      ctx.stopped = true;
-      break;
-    }
-
-    // Never follow symlinks (security). withFileTypes gives us
-    // isSymbolicLink() directly — no extra stat needed.
-    if (entry.isSymbolicLink()) continue;
-
-    const name = entry.name;
-
-    if (entry.isDirectory()) {
-      if (IGNORE_DIRS.has(name)) continue;
-      const childAbs = path.join(absDir, name);
-      const childRel = relDir ? path.join(relDir, name) : name;
-      const result = await walk(childAbs, childRel, depth + 1, ctx);
-      subFiles += result.fileCount;
-      subLines += result.totalLines;
-      continue;
-    }
-
-    if (!entry.isFile()) continue;
-    if (IGNORE_FILES.has(name)) continue;
-    if (ctx.fileCount >= MAX_FILES_TO_ANALYZE) {
-      ctx.stopped = true;
-      break;
-    }
-
-    ctx.fileCount++;
-    subFiles++;
-    ctx.totalFiles++;
-
-    const ext = path.extname(name).toLowerCase();
-    let size = 0;
-    let lines = 0;
-    try {
-      const st = await fsp.stat(path.join(absDir, name));
-      size = st.size;
-    } catch {
-      // unreadable — count the file but skip lines
-    }
-
-    // Only line-count "interesting" files. JSON / SVG / XML / YAML are noisy
-    // and don't really represent "code"; skipping them keeps the LOC number
-    // closer to what a developer expects.
-    if (LANG_LABELS[ext] && ext !== '.svg' && ext !== '.xml' && ext !== '.json') {
-      lines = await countLines(path.join(absDir, name), size);
-    }
-    subLines += lines;
-    ctx.totalLines += lines;
-
-    // Language breakdown bucket.
-    const key = languageKey(ext);
-    const langBucket = ctx.languages[key] ?? (ctx.languages[key] = { files: 0, lines: 0 });
-    langBucket.files++;
-    langBucket.lines += lines;
-  }
-
-  // Top-dir attribution happens in analyze() based on the return value, not
-  // here — avoids double-pushing when walk recurses into nested dirs.
-  return { fileCount: subFiles, totalLines: subLines };
-}
-
-/**
- * repo:analyze entry — runs the walk, then asks git.cjs for status (cached,
- * so this is cheap when called repeatedly). On any path-validation or fs
- * failure returns a `{ ok:false, error }` shape so the renderer can decide
- * whether to show an error state or just empty stats.
- */
-async function analyze(cwd) {
-  let realCwd;
-  try {
-    realCwd = validatePath(cwd);
-  } catch (e) {
-    return { ok: false, error: (e && e.message) || 'invalid cwd' };
-  }
-
-  const startMs = Date.now();
-  const ctx = {
-    deadline: startMs + DEADLINE_MS,
-    stopped: false,
-    fileCount: 0,
-    totalFiles: 0,
-    totalLines: 0,
-    languages: Object.create(null),
-    topDirs: [],
-  };
-
-  // Walk the top-level dir manually (we want depth-1 directories listed in
-  // topDirs but not "." itself).
-  let entries;
-  try {
-    entries = await fsp.readdir(realCwd, { withFileTypes: true });
-  } catch (e) {
-    return { ok: false, error: (e && e.message) || 'readdir failed' };
-  }
-
-  // First pass: count files directly in the root, group root-level loose
-  // files under a synthetic "(root)" bucket so they're visible in the treemap.
-  let rootLooseFiles = 0;
-  let rootLooseLines = 0;
-
-  // Process directories at depth 1, files at depth 0 (root). We follow the
-  // pattern: lstat-equivalent (entry.isSymbolicLink()) → no follow.
-  for (const entry of entries) {
-    if (ctx.stopped) break;
-    if (Date.now() > ctx.deadline) { ctx.stopped = true; break; }
-    if (entry.isSymbolicLink()) continue;
-    const name = entry.name;
-
-    if (entry.isDirectory()) {
-      if (IGNORE_DIRS.has(name)) continue;
-      const result = await walk(path.join(realCwd, name), name, 1, ctx);
-      ctx.topDirs.push({ path: name, fileCount: result.fileCount, totalLines: result.totalLines });
-      continue;
-    }
-
-    if (!entry.isFile()) continue;
-    if (IGNORE_FILES.has(name)) continue;
-    if (ctx.fileCount >= MAX_FILES_TO_ANALYZE) { ctx.stopped = true; break; }
-
-    ctx.fileCount++;
-    ctx.totalFiles++;
-    rootLooseFiles++;
-
-    const ext = path.extname(name).toLowerCase();
-    let size = 0;
-    let lines = 0;
-    try {
-      const st = await fsp.stat(path.join(realCwd, name));
-      size = st.size;
-    } catch { /* */ }
-    if (LANG_LABELS[ext] && ext !== '.svg' && ext !== '.xml' && ext !== '.json') {
-      lines = await countLines(path.join(realCwd, name), size);
-    }
-    rootLooseLines += lines;
-    ctx.totalLines += lines;
-    const key = languageKey(ext);
-    const langBucket = ctx.languages[key] ?? (ctx.languages[key] = { files: 0, lines: 0 });
-    langBucket.files++;
-    langBucket.lines += lines;
-  }
-
-  if (rootLooseFiles > 0) {
-    ctx.topDirs.push({ path: '(root)', fileCount: rootLooseFiles, totalLines: rootLooseLines });
-  }
-
-  // Sort top dirs by file count desc, then trim. Tie-break by name for stability.
-  ctx.topDirs.sort((a, b) => {
-    if (b.fileCount !== a.fileCount) return b.fileCount - a.fileCount;
-    return a.path.localeCompare(b.path);
-  });
-  const topDirectories = ctx.topDirs.slice(0, TOP_DIRS_LIMIT);
-
-  // Materialize the languages map sorted by file count desc.
-  const languageBreakdown = Object.create(null);
-  const langEntries = Object.entries(ctx.languages).sort((a, b) => b[1].files - a[1].files);
-  for (const [k, v] of langEntries) languageBreakdown[k] = v;
-
-  // Git status — best-effort. Failure (not a git repo / git missing / timeout)
-  // returns null which we surface as { uncommitted: 0, branch: null }.
-  let gitStatus = { uncommitted: 0, branch: null };
-  try {
-    const s = await gitMod.getStatus(realCwd);
-    if (s) {
-      gitStatus = {
-        uncommitted: s.uncommittedCount || 0,
-        branch: s.branch || null,
-      };
-    }
-  } catch { /* gitMod swallows errors but be defensive */ }
-
-  return {
-    ok: true,
-    cwd: realCwd,
-    totalFiles: ctx.totalFiles,
-    totalLines: ctx.totalLines,
-    languageBreakdown,
-    topDirectories,
-    gitStatus,
-    truncated: ctx.stopped,
-    durationMs: Date.now() - startMs,
-  };
-}
-
-function register(ipcMain) {
-  ipcMain.handle('repo:analyze', async (_e, payload) => {
-    const parsed = schemas.repoAnalyze.safeParse(payload);
-    if (!parsed.success) {
-      return { ok: false, error: 'invalid payload' };
-    }
-    return analyze(parsed.data.cwd);
-  });
-}
-
-module.exports = {
-  register,
-  analyze,
-  // Exported for tests.
-  LANG_LABELS,
-  IGNORE_DIRS,
-};

package/src/main/search.cjs

@@ -1,332 +0,0 @@
-/**
- * Search IPC — fuzzy file path search + content grep.
- *
- * - Prefers ripgrep (`rg`) when present on PATH for both fast file enumeration
- *   (`rg --files`) and content search (`rg --json`). Falls back to a Node
- *   fs-based recursive walk capped at depth 10 when rg is missing.
- * - All cwds are routed through `config.cjs`'s `validatePath` so the renderer
- *   can never search outside the home directory.
- * - 10s wall-clock ceiling per call — search runs that overflow are killed
- *   and return partial results.
- * - Ignored dirs (both modes): .git / node_modules / dist / build / .next /
- *   .cache / coverage / .turbo.
- *
- * Designed to back two renderer modals: QuickOpen (Cmd+P) and GlobalSearch
- * (Cmd+Shift+F).
- */
-
-const { ipcMain } = require('electron');
-const { spawn } = require('node:child_process');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const os = require('node:os');
-const { z } = require('zod');
-
-const { validatePath } = require('./config.cjs');
-
-const TIMEOUT_MS = 10_000;
-const MAX_FILES = 5000;
-const MAX_TEXT_MATCHES = 500;
-const MAX_WALK_DEPTH = 10;
-const IGNORED_DIRS = new Set([
-  '.git', 'node_modules', 'dist', 'build', '.next',
-  '.cache', 'coverage', '.turbo', '.parcel-cache', '.pnpm-store',
-]);
-
-// ── ripgrep detection ─────────────────────────────────────────────────────
-let _rgAvailable = null; // null = unknown, true/false = cached
-function probeRipgrep() {
-  if (_rgAvailable !== null) return _rgAvailable;
-  return new Promise((resolve) => {
-    let resolved = false;
-    const done = (val) => { if (!resolved) { resolved = true; _rgAvailable = val; resolve(val); } };
-    try {
-      const proc = spawn('rg', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-      proc.on('error', () => done(false));
-      proc.on('exit', (code) => done(code === 0));
-      // Hard timeout: probe shouldn't take more than 1s.
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch { /* noop */ } done(false); }, 1000);
-    } catch {
-      done(false);
-    }
-  });
-}
-
-// ── helpers ───────────────────────────────────────────────────────────────
-const { expandHome } = require('./lib/expandHome.cjs');
-
-/**
- * Spawn rg with argv (no shell), capture stdout/stderr, enforce TIMEOUT_MS.
- * Resolves to { ok, stdout, stderr, exitCode, timedOut }.
- */
-function runRg(args, cwd) {
-  return new Promise((resolve) => {
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-    let proc;
-    try {
-      proc = spawn('rg', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-    } catch (e) {
-      resolve({ ok: false, stdout: '', stderr: e.message, exitCode: -1, timedOut: false });
-      return;
-    }
-    const timer = setTimeout(() => {
-      timedOut = true;
-      try { proc.kill('SIGTERM'); } catch { /* noop */ }
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch { /* noop */ } }, 500);
-    }, TIMEOUT_MS);
-
-    proc.stdout.on('data', (chunk) => {
-      stdout += chunk.toString('utf8');
-      // Soft cap on buffer growth — if rg yields more than 10 MB of stdout
-      // something is wrong with the query; just kill it.
-      if (stdout.length > 10 * 1024 * 1024) {
-        try { proc.kill('SIGTERM'); } catch { /* noop */ }
-      }
-    });
-    proc.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
-    proc.on('error', (e) => {
-      clearTimeout(timer);
-      resolve({ ok: false, stdout, stderr: e.message, exitCode: -1, timedOut });
-    });
-    proc.on('exit', (code) => {
-      clearTimeout(timer);
-      // rg exits 1 when zero matches found — that's still "ok" for us.
-      resolve({ ok: code === 0 || code === 1, stdout, stderr, exitCode: code ?? -1, timedOut });
-    });
-  });
-}
-
-/**
- * Recursive fs walk capped at MAX_WALK_DEPTH and ignoring IGNORED_DIRS.
- * Returns absolute paths. Bails out early at MAX_FILES.
- */
-async function fsWalk(rootAbs) {
-  const out = [];
-  const startedAt = Date.now();
-  async function walk(dir, depth) {
-    if (depth > MAX_WALK_DEPTH) return;
-    if (out.length >= MAX_FILES) return;
-    if (Date.now() - startedAt > TIMEOUT_MS) return;
-    let entries;
-    try {
-      entries = await fsp.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (out.length >= MAX_FILES) return;
-      if (entry.name.startsWith('.') && entry.name !== '.env') {
-        // Skip dotfiles by default — matches rg's defaults closely enough
-        // for our use case. .env is a common exception users may want.
-        if (entry.isDirectory()) continue;
-      }
-      if (entry.isDirectory()) {
-        if (IGNORED_DIRS.has(entry.name)) continue;
-        await walk(path.join(dir, entry.name), depth + 1);
-      } else if (entry.isFile()) {
-        out.push(path.join(dir, entry.name));
-      }
-    }
-  }
-  await walk(rootAbs, 0);
-  return out;
-}
-
-/**
- * Naive content grep for the rg-fallback path. Reads each file up to 1 MB,
- * splits on newlines, returns the first MAX_TEXT_MATCHES occurrences. Skips
- * binary files heuristically (NUL byte in first 4 KiB).
- */
-async function fsGrep(rootAbs, needle, opts) {
-  const caseSensitive = !!opts.caseSensitive;
-  const limit = Math.max(1, Math.min(MAX_TEXT_MATCHES, opts.limit ?? MAX_TEXT_MATCHES));
-  const haystack = caseSensitive ? needle : needle.toLowerCase();
-  const startedAt = Date.now();
-  const files = await fsWalk(rootAbs);
-  const matches = [];
-  for (const file of files) {
-    if (matches.length >= limit) break;
-    if (Date.now() - startedAt > TIMEOUT_MS) break;
-    let buf;
-    try {
-      const st = await fsp.stat(file);
-      if (st.size > 1024 * 1024) continue;
-      buf = await fsp.readFile(file);
-    } catch { continue; }
-    // Binary sniff.
-    const sniff = buf.slice(0, 4096);
-    if (sniff.includes(0)) continue;
-    const text = buf.toString('utf8');
-    const lines = text.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      if (matches.length >= limit) break;
-      const line = lines[i];
-      const target = caseSensitive ? line : line.toLowerCase();
-      const idx = target.indexOf(haystack);
-      if (idx !== -1) {
-        matches.push({
-          path: file,
-          line: i + 1,
-          column: idx + 1,
-          text: line.length > 400 ? line.slice(0, 400) + '…' : line,
-        });
-      }
-    }
-  }
-  return matches;
-}
-
-// ── public API: search:files ──────────────────────────────────────────────
-async function searchFiles({ cwd, query, opts }) {
-  const limit = Math.max(1, Math.min(MAX_FILES, opts?.limit ?? MAX_FILES));
-  let resolved;
-  try { resolved = validatePath(expandHome(cwd)); }
-  catch (e) { return { ok: false, files: [], error: e.message, usedRipgrep: false }; }
-
-  const usedRipgrep = await probeRipgrep();
-  let absPaths = [];
-  if (usedRipgrep) {
-    // `rg --files` enumerates the tree honoring .gitignore. We add explicit
-    // --glob '!dir' exclusions on top in case the repo isn't a git repo.
-    const args = [
-      '--files', '--hidden', '--follow',
-      '--max-filesize', '5M',
-    ];
-    for (const dir of IGNORED_DIRS) {
-      args.push('--glob', `!**/${dir}/**`);
-    }
-    const result = await runRg(args, resolved);
-    if (result.timedOut) {
-      return { ok: false, files: [], error: 'search timeout (10s)', usedRipgrep: true };
-    }
-    if (!result.ok) {
-      return { ok: false, files: [], error: result.stderr || `rg exit ${result.exitCode}`, usedRipgrep: true };
-    }
-    absPaths = result.stdout.split('\n')
-      .filter((l) => l.length > 0)
-      .map((rel) => path.join(resolved, rel));
-  } else {
-    absPaths = await fsWalk(resolved);
-  }
-
-  // Fuzzy filter / sort happens in renderer. Main returns the candidate set.
-  // When query is provided we do a coarse case-insensitive substring filter
-  // to cut payload size — renderer's fuzzy ranker handles the precise scoring.
-  if (query && query.length > 0) {
-    const q = query.toLowerCase();
-    absPaths = absPaths.filter((p) => p.toLowerCase().includes(q));
-  }
-  absPaths = absPaths.slice(0, limit);
-
-  // Shape each entry like files:list so QuickOpen can reuse FileNode types.
-  const files = absPaths.map((abs) => ({
-    name: path.basename(abs),
-    path: abs,
-    isDirectory: false,
-    isFile: true,
-  }));
-  return { ok: true, files, error: null, usedRipgrep };
-}
-
-// ── public API: search:text ───────────────────────────────────────────────
-async function searchText({ cwd, query, opts }) {
-  const limit = Math.max(1, Math.min(MAX_TEXT_MATCHES, opts?.limit ?? MAX_TEXT_MATCHES));
-  const caseSensitive = !!opts?.caseSensitive;
-  if (!query || query.length === 0) {
-    return { ok: true, matches: [], error: null, usedRipgrep: false };
-  }
-  let resolved;
-  try { resolved = validatePath(expandHome(cwd)); }
-  catch (e) { return { ok: false, matches: [], error: e.message, usedRipgrep: false }; }
-
-  const usedRipgrep = await probeRipgrep();
-  if (!usedRipgrep) {
-    const matches = await fsGrep(resolved, query, { caseSensitive, limit });
-    return { ok: true, matches, error: null, usedRipgrep: false };
-  }
-
-  // rg --json gives us { type, data: { ... } } lines. We use --fixed-strings
-  // so users don't accidentally trigger regex on `.` or `(`. Renderer can
-  // toggle regex later if we ever surface that option.
-  const args = [
-    '--json', '--fixed-strings', '--hidden', '--follow',
-    '--max-filesize', '5M',
-    '--max-count', String(limit),
-  ];
-  if (!caseSensitive) args.push('--ignore-case');
-  for (const dir of IGNORED_DIRS) {
-    args.push('--glob', `!**/${dir}/**`);
-  }
-  args.push('--', query);
-
-  const result = await runRg(args, resolved);
-  if (result.timedOut) {
-    return { ok: false, matches: [], error: 'search timeout (10s)', usedRipgrep: true };
-  }
-  if (!result.ok) {
-    return { ok: false, matches: [], error: result.stderr || `rg exit ${result.exitCode}`, usedRipgrep: true };
-  }
-
-  const matches = [];
-  const lines = result.stdout.split('\n');
-  for (const raw of lines) {
-    if (matches.length >= limit) break;
-    if (!raw) continue;
-    let evt;
-    try { evt = JSON.parse(raw); } catch { continue; }
-    if (evt.type !== 'match') continue;
-    const data = evt.data;
-    if (!data) continue;
-    const rel = data.path?.text;
-    if (!rel) continue;
-    const abs = path.isAbsolute(rel) ? rel : path.join(resolved, rel);
-    const lineNum = data.line_number ?? 0;
-    let text = data.lines?.text ?? '';
-    if (text.endsWith('\n')) text = text.slice(0, -1);
-    if (text.length > 400) text = text.slice(0, 400) + '…';
-    const column = (data.submatches && data.submatches[0]?.start != null)
-      ? data.submatches[0].start + 1
-      : 1;
-    matches.push({ path: abs, line: lineNum, column, text });
-  }
-  return { ok: true, matches, error: null, usedRipgrep: true };
-}
-
-// ── IPC registration ──────────────────────────────────────────────────────
-const searchFilesSchema = z.object({
-  cwd: z.string().min(1).max(4096),
-  query: z.string().max(1024).optional().default(''),
-  opts: z.object({
-    limit: z.number().int().min(1).max(MAX_FILES).optional(),
-  }).optional(),
-});
-
-const searchTextSchema = z.object({
-  cwd: z.string().min(1).max(4096),
-  query: z.string().min(1).max(1024),
-  opts: z.object({
-    limit: z.number().int().min(1).max(MAX_TEXT_MATCHES).optional(),
-    caseSensitive: z.boolean().optional(),
-  }).optional(),
-});
-
-function registerSearchHandlers() {
-  ipcMain.handle('search:files', (_e, payload) => {
-    const parsed = searchFilesSchema.parse(payload);
-    return searchFiles(parsed);
-  });
-  ipcMain.handle('search:text', (_e, payload) => {
-    const parsed = searchTextSchema.parse(payload);
-    return searchText(parsed);
-  });
-}
-
-module.exports = {
-  registerSearchHandlers,
-  // exported for tests
-  searchFiles,
-  searchText,
-  probeRipgrep,
-};