@gemini-designer/mcp-server 0.1.39 → 0.1.40

package/src/context/builder.ts

@@ -11,6 +11,7 @@ import * as path from 'node:path';
 import { Config } from '../config/index.js';
 import { isPathAllowed, isSensitiveFile, sanitizeContent } from './filter.js';
 import { assertReadablePath } from './guards.js';
+import { ripgrepListFiles } from '../utils/ripgrep.js';
 
 // Token estimation: ~4 characters per token for English text/code
 const CHARS_PER_TOKEN = 4;
@@ -190,38 +191,34 @@ export async function discoverUIFiles(directory: string, config: Config): Promis
     /tailwind\.config\./,
   ];
 
-  const files: string[] = [];
-
-  function scan(dir: string, depth: number = 0) {
-    if (depth > 3) return; // Max depth
-
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Skip node_modules, .git, etc.
-        if (entry.isDirectory()) {
-          if (['node_modules', '.git', 'dist', 'build', '.next', '.nuxt'].includes(entry.name)) {
-            continue;
-          }
-          scan(fullPath, depth + 1);
-        } else if (entry.isFile()) {
-          // Check if matches UI patterns
-          if (uiPatterns.some((pattern) => pattern.test(entry.name))) {
-            if (isPathAllowed(fullPath, config.allowedPaths) && !isSensitiveFile(fullPath)) {
-              files.push(fullPath);
-            }
-          }
-        }
-      }
-    } catch {
-      // Skip directories we can't read
-    }
+  const excludedDirs = ['node_modules', '.git', 'dist', 'build', '.next', '.nuxt'];
+  const excludeGlobs = excludedDirs.map((d) => `!**/${d}/**`);
+
+  let list: Awaited<ReturnType<typeof ripgrepListFiles>>;
+  try {
+    list = await ripgrepListFiles({
+      cwd: directory,
+      includeHidden: true,
+      noIgnore: true,
+      maxFiles: 5000,
+      maxDepth: 3,
+      globs: excludeGlobs,
+      cacheTtlMs: 1500,
+    });
+  } catch {
+    // Fall back to empty on rg failures; caller can still operate without auto-discovery.
+    return [];
   }
 
-  scan(directory);
+  const files: string[] = [];
+  for (const rel of list.files) {
+    const name = path.basename(rel);
+    if (!uiPatterns.some((pattern) => pattern.test(name))) continue;
+    const abs = path.resolve(directory, rel);
+    if (!isPathAllowed(abs, config.allowedPaths)) continue;
+    if (isSensitiveFile(abs)) continue;
+    files.push(abs);
+  }
 
   // Sort by relevance
   return sortByRelevance(files);

package/src/tools/catalog-components.ts

@@ -15,7 +15,8 @@ import * as path from 'node:path';
 import { Config } from '../config/index.js';
 import { assertReadableDir } from '../context/guards.js';
 import { getProjectRootAbs } from '../context/project-root.js';
-import { walkFiles, toPosixPath } from '../utils/walk.js';
+import { DEFAULT_EXCLUDE_DIR_NAMES, toPosixPath } from '../utils/walk.js';
+import { extensionGlob, ripgrepListFiles } from '../utils/ripgrep.js';
 import { buildComponentCatalog } from '../components/catalog.js';
 import { resolveWithinProjectRoot } from '../output/path-resolve.js';
 
@@ -71,8 +72,32 @@ export function registerCatalogComponents(server: McpServer, config: Config): vo
 
       const allFiles: string[] = [];
       for (const r of safeRoots) {
-        const found = walkFiles(r, { includeExtensions: extensions, maxFiles });
-        allFiles.push(...found);
+        const extGlob = extensionGlob(extensions);
+        const globs: string[] = [];
+        for (const d of DEFAULT_EXCLUDE_DIR_NAMES) globs.push(`!**/${d}/**`);
+        if (extGlob) globs.push(extGlob);
+
+        let found: Awaited<ReturnType<typeof ripgrepListFiles>>;
+        try {
+          found = await ripgrepListFiles({
+            cwd: r,
+            includeHidden: true,
+            noIgnore: true,
+            maxFiles,
+            globs,
+            cacheTtlMs: 2500,
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : 'ripgrep failed';
+          return {
+            content: [{ type: 'text' as const, text: `Error: ${message}` }],
+            isError: true,
+          };
+        }
+
+        for (const rel of found.files) {
+          allFiles.push(path.resolve(r, rel));
+        }
       }
 
       // Use projectRoot (when provided) so paths are stable for agents in monorepos

package/src/tools/detect-ui-stack.ts

@@ -17,6 +17,7 @@ import * as path from 'node:path';
 import { Config } from '../config/index.js';
 import { assertReadableDir } from '../context/guards.js';
 import { detectUiStack } from '../stack/detect.js';
+import { ripgrepListFiles } from '../utils/ripgrep.js';
 
 const inputSchema = {
   root: z
@@ -26,19 +27,26 @@ const inputSchema = {
     .default(process.cwd()),
 };
 
-function findPackageJsonRoots(rootDir: string, maxDepth: number): string[] {
-  const deny = new Set([
-    'node_modules',
-    '.git',
-    '.next',
-    'dist',
-    'build',
-    'out',
-    'coverage',
-    '.turbo',
-    '.cache',
-    'tmp',
-  ]);
+const PACKAGE_JSON_DENY_DIRS = [
+  'node_modules',
+  '.git',
+  '.next',
+  'dist',
+  'build',
+  'out',
+  'coverage',
+  '.turbo',
+  '.cache',
+  'tmp',
+];
+
+function isWithinPath(parent: string, child: string): boolean {
+  const rel = path.relative(parent, child);
+  return rel === '' || (!rel.startsWith(`..${path.sep}`) && rel !== '..' && !path.isAbsolute(rel));
+}
+
+function findPackageJsonRootsFs(rootDir: string, maxDepth: number): string[] {
+  const deny = new Set(PACKAGE_JSON_DENY_DIRS);
 
   const out: string[] = [];
   const q: Array<{ dir: string; depth: number }> = [{ dir: rootDir, depth: 0 }];
@@ -74,6 +82,35 @@ function findPackageJsonRoots(rootDir: string, maxDepth: number): string[] {
   return out.sort();
 }
 
+async function findPackageJsonRootsRg(rootDir: string, maxDepth: number): Promise<string[]> {
+  const globs = PACKAGE_JSON_DENY_DIRS.map((d) => `!**/${d}/**`);
+  // Match previous behavior: don't descend into dot-directories.
+  globs.push('!**/.*/**');
+  globs.push('**/package.json');
+
+  const files = await ripgrepListFiles({
+    cwd: rootDir,
+    includeHidden: true,
+    noIgnore: true,
+    maxFiles: 2000,
+    maxDepth,
+    globs,
+    cacheTtlMs: 2500,
+  });
+
+  const absDirs = [...new Set(files.files.map((p) => path.dirname(p)).filter((d) => d !== '.' && d !== ''))]
+    .map((d) => path.resolve(rootDir, d))
+    .sort((a, b) => a.length - b.length);
+
+  const kept: string[] = [];
+  for (const d of absDirs) {
+    if (kept.some((k) => isWithinPath(k, d))) continue;
+    kept.push(d);
+  }
+
+  return kept.sort();
+}
+
 export function registerDetectUIStack(server: McpServer, config: Config): void {
   server.registerTool(
     'detect_ui_stack',
@@ -104,7 +141,7 @@ export function registerDetectUIStack(server: McpServer, config: Config): void {
       // try to find subprojects and either auto-select or guide the user.
       const missingPkg = result.warnings.some((w) => w.includes('package.json not found'));
       if (missingPkg) {
-        const candidates = findPackageJsonRoots(safeRoot, 3);
+        const candidates = await findPackageJsonRootsRg(safeRoot, 3).catch(() => findPackageJsonRootsFs(safeRoot, 3));
         if (candidates.length === 1) {
           effectiveRoot = candidates[0];
           result = detectUiStack(effectiveRoot);

package/src/tools/repo-search.ts

@@ -7,12 +7,12 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import * as fs from 'node:fs';
 import * as path from 'node:path';
 
 import { Config } from '../config/index.js';
 import { getProjectRootAbs } from '../context/project-root.js';
 import { isSensitiveFile } from '../context/filter.js';
+import { ripgrepJsonSearch } from '../utils/ripgrep.js';
 
 const inputSchema = {
   projectRoot: z
@@ -20,7 +20,7 @@ const inputSchema = {
     .optional()
     .describe('Optional project root to search (defaults to cwd).'),
   pattern: z.string().min(1).describe('String pattern to search for.'),
-  regex: z.boolean().default(false).describe('Treat pattern as a JavaScript RegExp source.'),
+  regex: z.boolean().default(false).describe('Treat pattern as a ripgrep regex (PCRE2).'),
   caseSensitive: z.boolean().default(false).describe('Case-sensitive search (default: false).'),
   maxResults: z.number().int().min(1).max(2000).default(200).describe('Maximum matches to return.'),
   maxFileBytes: z
@@ -34,7 +34,7 @@ const inputSchema = {
   includeBinary: z.boolean().default(false).describe('If true, attempt to search binary files (not recommended).'),
 };
 
-const DEFAULT_IGNORED_DIRS = new Set([
+const DEFAULT_IGNORED_DIRS = [
   'node_modules',
   '.git',
   'dist',
@@ -46,67 +46,7 @@ const DEFAULT_IGNORED_DIRS = new Set([
   'coverage',
   '.cache',
   '.gemini-designer',
-]);
-
-const TEXT_EXTENSIONS = new Set([
-  '.ts',
-  '.tsx',
-  '.js',
-  '.jsx',
-  '.mjs',
-  '.cjs',
-  '.json',
-  '.md',
-  '.html',
-  '.css',
-  '.scss',
-  '.sass',
-  '.less',
-  '.styl',
-  '.vue',
-  '.svelte',
-  '.astro',
-  '.yml',
-  '.yaml',
-  '.toml',
-  '.txt',
-]);
-
-function isBinaryBuffer(buf: Buffer): boolean {
-  // Heuristic: if it contains a NUL byte, treat as binary.
-  return buf.includes(0);
-}
-
-function normalizeRel(root: string, abs: string): string {
-  return path.relative(root, abs).replace(/\\/g, '/');
-}
-
-function walkFiles(root: string, maxFiles: number = 50_000): string[] {
-  const out: string[] = [];
-  const stack: string[] = [root];
-
-  while (stack.length) {
-    const dir = stack.pop() as string;
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const e of entries) {
-      if (out.length >= maxFiles) return out;
-      const abs = path.join(dir, e.name);
-      if (e.isDirectory()) {
-        if (DEFAULT_IGNORED_DIRS.has(e.name)) continue;
-        stack.push(abs);
-      } else if (e.isFile()) {
-        out.push(abs);
-      }
-    }
-  }
-  return out;
-}
+];
 
 export function registerRepoSearch(server: McpServer, _config: Config): void {
   server.registerTool(
@@ -129,63 +69,28 @@ export function registerRepoSearch(server: McpServer, _config: Config): void {
       const includePreview = args.includePreview !== false;
       const includeBinary = args.includeBinary === true;
 
-      let re: RegExp;
+      const ignoredDirGlobs = DEFAULT_IGNORED_DIRS.map((d) => `!**/${d}/**`);
+
+      let res: Awaited<ReturnType<typeof ripgrepJsonSearch>>;
       try {
-        re = regex
-          ? new RegExp(pattern, caseSensitive ? 'g' : 'gi')
-          : new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), caseSensitive ? 'g' : 'gi');
+        res = await ripgrepJsonSearch({
+          cwd: projectRootAbs,
+          pattern,
+          fixedStrings: !regex,
+          caseSensitive,
+          includeHidden: true,
+          includeBinary,
+          maxFileBytes,
+          maxResults,
+          globs: ignoredDirGlobs,
+          usePcre2: regex,
+          shouldIgnorePath: (abs) => isSensitiveFile(abs),
+          includePreview,
+          previewMaxChars: 240,
+        });
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        return { content: [{ type: 'text' as const, text: `Error: invalid pattern/regex: ${msg}` }], isError: true };
-      }
-
-      const matches: Array<{ path: string; line: number; column: number; preview?: string }> = [];
-      const scannedFiles: string[] = [];
-      const files = walkFiles(projectRootAbs);
-
-      for (const abs of files) {
-        if (matches.length >= maxResults) break;
-        if (isSensitiveFile(abs)) continue;
-
-        const ext = path.extname(abs).toLowerCase();
-        if (!includeBinary && !TEXT_EXTENSIONS.has(ext)) continue;
-
-        let st: fs.Stats;
-        try {
-          st = fs.statSync(abs);
-        } catch {
-          continue;
-        }
-        if (st.size > maxFileBytes) continue;
-
-        let buf: Buffer;
-        try {
-          buf = fs.readFileSync(abs);
-        } catch {
-          continue;
-        }
-
-        if (!includeBinary && isBinaryBuffer(buf)) continue;
-
-        const text = buf.toString('utf-8');
-        scannedFiles.push(normalizeRel(projectRootAbs, abs));
-
-        const lines = text.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i++) {
-          if (matches.length >= maxResults) break;
-          const line = lines[i];
-          re.lastIndex = 0;
-          let m: RegExpExecArray | null;
-          while ((m = re.exec(line)) && matches.length < maxResults) {
-            matches.push({
-              path: normalizeRel(projectRootAbs, abs),
-              line: i + 1,
-              column: (m.index || 0) + 1,
-              preview: includePreview ? line.slice(0, 240) : undefined,
-            });
-            if (m.index === re.lastIndex) re.lastIndex++; // avoid infinite loops
-          }
-        }
+        return { content: [{ type: 'text' as const, text: `Error: ripgrep search failed: ${msg}` }], isError: true };
       }
 
       const out = {
@@ -193,9 +98,10 @@ export function registerRepoSearch(server: McpServer, _config: Config): void {
         pattern,
         regex,
         caseSensitive,
-        matchCount: matches.length,
-        matches,
-        scannedFilesCount: scannedFiles.length,
+        matchCount: res.matches.length,
+        matches: res.matches,
+        scannedFilesCount: res.scannedFilesCount,
+        truncated: res.truncated,
       };
 
       return { content: [{ type: 'text' as const, text: JSON.stringify(out, null, 2) }] };

package/src/tools/repo-tree.ts

@@ -13,7 +13,9 @@ import { Config } from '../config/index.js';
 import { getProjectRootAbs } from '../context/project-root.js';
 import { assertReadableDir } from '../context/guards.js';
 import { isSensitiveFile } from '../context/filter.js';
-import { walkFiles, toPosixPath } from '../utils/walk.js';
+import { toPosixPath } from '../utils/walk.js';
+import { extensionGlob, ripgrepListFiles } from '../utils/ripgrep.js';
+import { mapWithConcurrency } from '../utils/concurrency.js';
 
 const inputSchema = {
   projectRoot: z
@@ -59,29 +61,54 @@ export function registerRepoTree(server: McpServer, config: Config): void {
       const maxFiles = (args.maxFiles as number) || 10_000;
       const includeMeta = args.includeMeta === true;
 
-      const absFiles = walkFiles(safeRoot, { includeExtensions, excludeDirNames, maxFiles });
+      const defaultExcludedDirs = ['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'coverage', '.cache'];
+      const excludeGlobs = [...new Set([...defaultExcludedDirs, ...excludeDirNames])]
+        .map((d) => d.trim())
+        .filter(Boolean)
+        .map((d) => `!**/${d}/**`);
+
+      const extGlob = extensionGlob(includeExtensions);
+      const includeGlobs = extGlob ? [extGlob] : [];
+
+      let list: Awaited<ReturnType<typeof ripgrepListFiles>>;
+      try {
+        list = await ripgrepListFiles({
+          cwd: safeRoot,
+          includeHidden: true,
+          noIgnore: true,
+          maxFiles,
+          globs: [...excludeGlobs, ...includeGlobs],
+          cacheTtlMs: 1500,
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'ripgrep failed';
+        return { content: [{ type: 'text' as const, text: `Error: ${message}` }], isError: true };
+      }
+
+      const relFiles = list.files
+        .map((rel) => toPosixPath(rel))
+        .filter((rel) => rel && !rel.startsWith('..') && !isSensitiveFile(rel));
 
       const files: Array<any> = [];
-      for (const abs of absFiles) {
-        const rel = toPosixPath(path.relative(safeRoot, abs));
-        if (!rel || rel.startsWith('..')) continue;
-        if (isSensitiveFile(rel)) continue;
-        if (!includeMeta) {
-          files.push({ path: rel });
-          continue;
-        }
-        try {
-          const st = fs.statSync(abs);
-          files.push({ path: rel, sizeBytes: st.size, mtimeMs: st.mtimeMs });
-        } catch {
-          files.push({ path: rel });
-        }
+      if (!includeMeta) {
+        for (const rel of relFiles) files.push({ path: rel });
+      } else {
+        const meta = await mapWithConcurrency(relFiles, 32, async (rel) => {
+          const abs = path.join(safeRoot, rel);
+          try {
+            const st = await fs.promises.stat(abs);
+            return { path: rel, sizeBytes: st.size, mtimeMs: st.mtimeMs };
+          } catch {
+            return { path: rel };
+          }
+        });
+        files.push(...meta);
       }
 
       const out = {
         root: safeRoot,
         count: files.length,
-        truncated: absFiles.length >= maxFiles,
+        truncated: list.truncated,
         files,
       };
 

package/src/utils/concurrency.ts

@@ -0,0 +1,21 @@
+export async function mapWithConcurrency<T, R>(
+  items: T[],
+  concurrency: number,
+  mapper: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const limit = Math.max(1, Math.floor(concurrency));
+  const results = new Array<R>(items.length);
+  let nextIndex = 0;
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (true) {
+      const idx = nextIndex++;
+      if (idx >= items.length) break;
+      results[idx] = await mapper(items[idx], idx);
+    }
+  });
+
+  await Promise.all(workers);
+  return results;
+}
+