@gemini-designer/mcp-server 0.1.39 → 0.1.40

package/src/utils/ripgrep.ts

@@ -0,0 +1,360 @@
+import { spawn } from 'node:child_process';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+
+let rgPathPromise: Promise<string> | undefined;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function extractRgPath(mod: unknown): string | undefined {
+  if (!isRecord(mod)) return undefined;
+
+  const direct = mod.rgPath;
+  if (typeof direct === 'string' && direct.length > 0) return direct;
+
+  const def = mod.default;
+  if (isRecord(def)) {
+    const nested = def.rgPath;
+    if (typeof nested === 'string' && nested.length > 0) return nested;
+  }
+
+  return undefined;
+}
+
+export async function resolveRipgrepPath(): Promise<string> {
+  if (!rgPathPromise) {
+    rgPathPromise = (async () => {
+      try {
+        const mod = (await import('@vscode/ripgrep')) as unknown;
+        const rgPath = extractRgPath(mod);
+        if (typeof rgPath === 'string' && rgPath.length > 0) return rgPath;
+      } catch {
+        // Fall back to system rg.
+      }
+      return 'rg';
+    })();
+  }
+  return rgPathPromise;
+}
+
+type RipgrepEvent = { type: string; data?: unknown };
+
+function getPathText(data: unknown): string | undefined {
+  if (!isRecord(data)) return undefined;
+  const p = data.path;
+  if (!isRecord(p)) return undefined;
+  const t = p.text;
+  return typeof t === 'string' && t.length > 0 ? t : undefined;
+}
+
+function getLineNumber(data: unknown): number | undefined {
+  if (!isRecord(data)) return undefined;
+  const n = data.line_number;
+  return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
+}
+
+function getLineText(data: unknown): string {
+  if (!isRecord(data)) return '';
+  const lines = data.lines;
+  if (!isRecord(lines)) return '';
+  return typeof lines.text === 'string' ? lines.text : '';
+}
+
+function getSubmatchStarts(data: unknown): number[] {
+  if (!isRecord(data)) return [];
+  const subs = data.submatches;
+  if (!Array.isArray(subs)) return [];
+  const out: number[] = [];
+  for (const sm of subs) {
+    if (!isRecord(sm)) continue;
+    const start = sm.start;
+    if (typeof start === 'number' && Number.isFinite(start)) out.push(start);
+  }
+  return out;
+}
+
+export interface RipgrepMatch {
+  path: string;
+  line: number;
+  column: number;
+  preview?: string;
+}
+
+export interface RipgrepSearchOptions {
+  cwd: string;
+  pattern: string;
+  fixedStrings: boolean;
+  caseSensitive: boolean;
+  includeHidden: boolean;
+  includeBinary: boolean;
+  maxFileBytes: number;
+  maxResults: number;
+  globs?: string[];
+  usePcre2?: boolean;
+  shouldIgnorePath?: (absPath: string) => boolean;
+  includePreview?: boolean;
+  previewMaxChars?: number;
+}
+
+export interface RipgrepSearchResult {
+  matches: RipgrepMatch[];
+  scannedFilesCount: number;
+  truncated: boolean;
+}
+
+export interface RipgrepListFilesOptions {
+  cwd: string;
+  includeHidden: boolean;
+  noIgnore: boolean;
+  maxFiles: number;
+  maxDepth?: number;
+  globs?: string[];
+  shouldIgnorePath?: (absPath: string) => boolean;
+  cacheTtlMs?: number;
+}
+
+export interface RipgrepListFilesResult {
+  files: string[];
+  truncated: boolean;
+}
+
+const filesCache = new Map<string, { expiresAt: number; promise: Promise<RipgrepListFilesResult> }>();
+
+function makeFilesCacheKey(opts: RipgrepListFilesOptions): string {
+  return JSON.stringify({
+    cwd: opts.cwd,
+    includeHidden: opts.includeHidden,
+    noIgnore: opts.noIgnore,
+    maxFiles: opts.maxFiles,
+    maxDepth: opts.maxDepth ?? null,
+    globs: opts.globs || [],
+  });
+}
+
+function pruneFilesCache(now: number, maxEntries = 50): void {
+  for (const [k, v] of filesCache) {
+    if (v.expiresAt <= now) filesCache.delete(k);
+  }
+  if (filesCache.size <= maxEntries) return;
+  const entries = [...filesCache.entries()].sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+  for (let i = 0; i < entries.length - maxEntries; i++) {
+    filesCache.delete(entries[i][0]);
+  }
+}
+
+async function ripgrepListFilesUncached(opts: RipgrepListFilesOptions): Promise<RipgrepListFilesResult> {
+  const rgPath = await resolveRipgrepPath();
+
+  const args: string[] = ['--no-config', '--files', '--no-messages'];
+  if (opts.includeHidden) args.push('--hidden');
+  if (opts.noIgnore) args.push('--no-ignore');
+  if (typeof opts.maxDepth === 'number') args.push('--max-depth', String(opts.maxDepth));
+  for (const g of opts.globs || []) args.push('--glob', g);
+
+  const child = spawn(rgPath, args, {
+    cwd: opts.cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  const files: string[] = [];
+  let truncated = false;
+
+  const stderrChunks: string[] = [];
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', (d) => stderrChunks.push(String(d)));
+
+  const rl = readline.createInterface({ input: child.stdout });
+
+  const stopEarly = (): void => {
+    if (truncated) return;
+    truncated = true;
+    try {
+      child.kill();
+    } catch {
+      // ignore
+    }
+    try {
+      rl.close();
+    } catch {
+      // ignore
+    }
+  };
+
+  rl.on('line', (line) => {
+    if (truncated) return;
+    const rel = line.replace(/\r?\n$/, '').trim();
+    if (!rel) return;
+    const abs = path.resolve(opts.cwd, rel);
+    if (opts.shouldIgnorePath?.(abs)) return;
+    files.push(rel.replace(/\\/g, '/'));
+    if (files.length >= opts.maxFiles) stopEarly();
+  });
+
+  const exit = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => {
+    child.on('close', (code, signal) => resolve({ code, signal }));
+  });
+
+  if (!truncated && exit.code === 2) {
+    const stderr = stderrChunks.join('').trim();
+    const msg = stderr.length > 0 ? stderr : 'ripgrep failed';
+    throw new Error(msg);
+  }
+
+  return { files, truncated };
+}
+
+export async function ripgrepListFiles(opts: RipgrepListFilesOptions): Promise<RipgrepListFilesResult> {
+  const ttlMs = opts.cacheTtlMs ?? 0;
+  if (ttlMs <= 0) return ripgrepListFilesUncached(opts);
+
+  const now = Date.now();
+  pruneFilesCache(now);
+  const key = makeFilesCacheKey(opts);
+  const cached = filesCache.get(key);
+  if (cached && cached.expiresAt > now) return cached.promise;
+
+  const promise = ripgrepListFilesUncached({ ...opts, cacheTtlMs: 0 });
+  filesCache.set(key, { expiresAt: now + ttlMs, promise });
+  return promise;
+}
+
+export function extensionGlob(extensions: string[]): string | null {
+  const cleaned = [...new Set(extensions.map((e) => e.trim()).filter(Boolean))]
+    .map((e) => (e.startsWith('.') ? e.slice(1) : e))
+    .filter(Boolean);
+  if (cleaned.length === 0) return null;
+  if (cleaned.length === 1) return `**/*.${cleaned[0]}`;
+  return `**/*.{${cleaned.join(',')}}`;
+}
+
+export async function ripgrepJsonSearch(opts: RipgrepSearchOptions): Promise<RipgrepSearchResult> {
+  const rgPath = await resolveRipgrepPath();
+
+  const args: string[] = ['--no-config', '--json', '--no-messages'];
+
+  if (opts.includeHidden) args.push('--hidden');
+  if (opts.includeBinary) args.push('--text');
+  if (!opts.caseSensitive) args.push('-i');
+  if (opts.fixedStrings) args.push('--fixed-strings');
+  if (opts.usePcre2 && !opts.fixedStrings) args.push('--pcre2');
+  args.push('--max-filesize', String(opts.maxFileBytes));
+
+  for (const g of opts.globs || []) {
+    args.push('--glob', g);
+  }
+
+  args.push(opts.pattern);
+
+  const child = spawn(rgPath, args, {
+    cwd: opts.cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  const matches: RipgrepMatch[] = [];
+  const scanned = new Set<string>();
+  const ignoredRelPaths = new Set<string>();
+  let truncated = false;
+
+  const includePreview = opts.includePreview !== false;
+  const previewMaxChars = opts.previewMaxChars ?? 240;
+
+  const stderrChunks: string[] = [];
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', (d) => stderrChunks.push(String(d)));
+
+  const rl = readline.createInterface({ input: child.stdout });
+
+  const stopEarly = (): void => {
+    if (truncated) return;
+    truncated = true;
+    try {
+      child.kill();
+    } catch {
+      // ignore
+    }
+    try {
+      rl.close();
+    } catch {
+      // ignore
+    }
+  };
+
+  rl.on('line', (line) => {
+    if (truncated) return;
+    let evt: RipgrepEvent | undefined;
+    try {
+      const parsed = JSON.parse(line) as unknown;
+      if (!isRecord(parsed) || typeof parsed.type !== 'string') return;
+      evt = parsed as RipgrepEvent;
+    } catch {
+      // If we terminate early, the last line can be truncated; ignore parse failures.
+      return;
+    }
+    if (!evt) return;
+
+    if (evt.type === 'begin') {
+      const rel = getPathText(evt.data);
+      if (!rel) return;
+      const abs = path.resolve(opts.cwd, rel);
+      if (opts.shouldIgnorePath?.(abs)) {
+        ignoredRelPaths.add(rel);
+        return;
+      }
+      scanned.add(rel);
+      return;
+    }
+
+    if (evt.type === 'match') {
+      const rel = getPathText(evt.data);
+      if (!rel) return;
+      if (ignoredRelPaths.has(rel)) return;
+
+      const abs = path.resolve(opts.cwd, rel);
+      if (opts.shouldIgnorePath?.(abs)) {
+        ignoredRelPaths.add(rel);
+        return;
+      }
+
+      const lineNumber = getLineNumber(evt.data);
+      if (!lineNumber) return;
+      const rawLine = getLineText(evt.data);
+      const preview = includePreview ? rawLine.replace(/\r?\n$/, '').slice(0, previewMaxChars) : undefined;
+
+      const starts = getSubmatchStarts(evt.data);
+      if (starts.length === 0) {
+        if (matches.length < opts.maxResults) {
+          matches.push({ path: rel.replace(/\\/g, '/'), line: lineNumber, column: 1, preview });
+          if (matches.length >= opts.maxResults) stopEarly();
+        }
+        return;
+      }
+
+      for (const start of starts) {
+        if (matches.length >= opts.maxResults) {
+          stopEarly();
+          break;
+        }
+        matches.push({ path: rel.replace(/\\/g, '/'), line: lineNumber, column: start + 1, preview });
+      }
+      return;
+    }
+  });
+
+  const exit = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve) => {
+    child.on('close', (code, signal) => resolve({ code, signal }));
+  });
+
+  // rg exit codes:
+  // 0 = match found, 1 = no matches, 2 = error.
+  if (!truncated && exit.code === 2) {
+    const stderr = stderrChunks.join('').trim();
+    const msg = stderr.length > 0 ? stderr : 'ripgrep failed';
+    throw new Error(msg);
+  }
+
+  return { matches, scannedFilesCount: scanned.size, truncated };
+}

package/src/utils/walk.ts

@@ -27,11 +27,11 @@ const DEFAULT_EXCLUDE_DIRS = [
   'coverage',
 ];
 
+export const DEFAULT_EXCLUDE_DIR_NAMES = DEFAULT_EXCLUDE_DIRS;
+
 export function walkFiles(rootDir: string, options: WalkOptions = {}): string[] {
   const includeExtensions = (options.includeExtensions || []).map((e) => e.toLowerCase());
-  const exclude = new Set(
-    (options.excludeDirNames || DEFAULT_EXCLUDE_DIRS).map((d) => d.toLowerCase())
-  );
+  const exclude = new Set((options.excludeDirNames || DEFAULT_EXCLUDE_DIR_NAMES).map((d) => d.toLowerCase()));
   const maxFiles = typeof options.maxFiles === 'number' ? options.maxFiles : 10_000;
 
   const results: string[] = [];