@aiready/ast-mcp-server 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  searchCode,
+  validateWorkspacePath
+} from "./chunk-PRWMQQYW.js";
+
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -30,10 +35,11 @@ var GetFileStructureSchema = z.object({
   file: z.string().describe("Absolute path to the file to analyze")
 });
 var SearchCodeSchema = z.object({
-  pattern: z.string().describe("Search pattern (regex)"),
+  pattern: z.string().describe("Search pattern (regex by default)"),
   path: z.string().describe("Directory to search in"),
   filePattern: z.string().optional().describe('Glob filter (e.g., "*.ts")'),
-  limit: z.number().optional().default(50).describe("Max matches to return")
+  limit: z.number().optional().default(50).describe("Max matches to return"),
+  regex: z.boolean().optional().default(true).describe("Use regex mode (default true)")
 });
 var GetSymbolDocsSchema = z.object({
   symbol: z.string().describe("Symbol name to get documentation for"),
@@ -44,10 +50,8 @@ var BuildSymbolIndexSchema = z.object({
 });
 
 // src/adapters/typescript-adapter.ts
-import {
-  Node,
-  SyntaxKind
-} from "ts-morph";
+import { Node as Node2 } from "ts-morph";
+import fs3 from "fs";
 
 // src/project-manager.ts
 import { Project } from "ts-morph";
@@ -57,48 +61,80 @@ import { glob } from "glob";
 var ProjectManager = class {
   projects = /* @__PURE__ */ new Map();
   tsconfigCache = /* @__PURE__ */ new Map();
+  accessOrder = [];
+  // MRU at front
+  maxProjects = 4;
   /**
    * Find all tsconfig.json files in a directory (recursive)
    */
   async findTsConfigs(rootDir) {
-    if (this.tsconfigCache.has(rootDir)) {
-      return this.tsconfigCache.get(rootDir);
+    const safeRoot = validateWorkspacePath(rootDir);
+    if (this.tsconfigCache.has(safeRoot)) {
+      return this.tsconfigCache.get(safeRoot);
     }
     const configs = await glob("**/tsconfig.json", {
-      cwd: rootDir,
+      cwd: safeRoot,
       absolute: true,
       ignore: ["**/node_modules/**", "**/dist/**"]
     });
-    this.tsconfigCache.set(rootDir, configs);
+    this.tsconfigCache.set(safeRoot, configs);
     return configs;
   }
   /**
-   * Get or create a Project for a specific file path
-   */
-  async getProjectForFile(filePath) {
-    const tsconfigPath = await this.findNearestTsConfig(filePath);
-    if (!tsconfigPath) return void 0;
-    return this.getOrCreateProject(tsconfigPath);
-  }
-  /**
-   * Get or create a Project for a tsconfig path
+   * Ensure a Project exists for a given tsconfig path, managing LRU cache
    */
-  getOrCreateProject(tsconfigPath) {
+  ensureProject(tsconfigPath) {
+    this.checkMemoryPressure();
     if (this.projects.has(tsconfigPath)) {
+      this.moveToFront(tsconfigPath);
       return this.projects.get(tsconfigPath);
     }
+    while (this.projects.size >= this.maxProjects) {
+      const oldest = this.accessOrder.pop();
+      this.disposeProject(oldest);
+    }
     const project = new Project({
       tsConfigFilePath: tsconfigPath,
-      skipAddingFilesFromTsConfig: false
+      skipAddingFilesFromTsConfig: true
+      // KEY: don't load all files
     });
     this.projects.set(tsconfigPath, project);
+    this.accessOrder.unshift(tsconfigPath);
     return project;
   }
+  /**
+   * Move a tsconfig path to the front of the access order (MRU)
+   */
+  moveToFront(tsconfigPath) {
+    const index = this.accessOrder.indexOf(tsconfigPath);
+    if (index > -1) {
+      this.accessOrder.splice(index, 1);
+      this.accessOrder.unshift(tsconfigPath);
+    }
+  }
+  checkMemoryPressure() {
+    const heapUsed = process.memoryUsage().heapUsed / 1024 / 1024;
+    const maxHeap = parseInt(process.env.AST_MAX_HEAP_MB || "1536", 10);
+    while (heapUsed > maxHeap && this.projects.size > 1) {
+      const oldest = this.accessOrder.pop();
+      this.disposeProject(oldest);
+    }
+  }
+  disposeProject(tsconfigPath) {
+    const project = this.projects.get(tsconfigPath);
+    if (project) {
+      for (const sourceFile of project.getSourceFiles()) {
+        project.removeSourceFile(sourceFile);
+      }
+      this.projects.delete(tsconfigPath);
+    }
+  }
   /**
    * Find the nearest tsconfig.json for a file
    */
   async findNearestTsConfig(filePath) {
-    let currentDir = path.dirname(filePath);
+    const safePath = validateWorkspacePath(filePath);
+    let currentDir = path.dirname(safePath);
     const root = path.parse(currentDir).root;
     while (currentDir !== root) {
       const tsconfigPath = path.join(currentDir, "tsconfig.json");
@@ -110,125 +146,446 @@ var ProjectManager = class {
     return void 0;
   }
   /**
-   * Get all projects that might contain a file or serve a path
+   * Get all tsconfigs for a path
    */
   async getProjectsForPath(rootDir) {
-    const configs = await this.findTsConfigs(rootDir);
-    return configs.map((config) => this.getOrCreateProject(config));
+    return this.findTsConfigs(rootDir);
   }
   /**
    * Dispose all projects to free memory
    */
   disposeAll() {
-    for (const project of this.projects.values()) {
-      project.getLanguageService().compilerObject.dispose();
+    for (const [key] of this.projects) {
+      this.disposeProject(key);
     }
-    this.projects.clear();
+    this.accessOrder = [];
   }
 };
 var projectManager = new ProjectManager();
 
-// src/adapters/typescript-adapter.ts
-var TypeScriptAdapter = class {
+// src/index/symbol-index.ts
+import fs2 from "fs";
+import crypto from "crypto";
+import path2 from "path";
+import { Node } from "ts-morph";
+var SymbolIndex = class {
+  index = {};
+  getCachePath(rootDir) {
+    const hash = crypto.createHash("sha256").update(rootDir).digest("hex").slice(0, 12);
+    return path2.join(
+      process.platform === "win32" ? process.env.TEMP || "c:/temp" : "/tmp",
+      `ast-index-${hash}.json`
+    );
+  }
+  isCacheValid(cached, rootDir) {
+    if (cached.rootDir !== rootDir) return false;
+    for (const [file, cachedMtime] of Object.entries(cached.fileHashes)) {
+      if (!fs2.existsSync(file)) return false;
+      if (fs2.statSync(file).mtimeMs !== cachedMtime) return false;
+    }
+    return true;
+  }
+  computeStats(cache, duration_ms, memory_mb) {
+    const files = Object.keys(cache.fileHashes).length;
+    let functions = 0;
+    let classes = 0;
+    let interfaces = 0;
+    let types = 0;
+    for (const entries of Object.values(cache.symbols)) {
+      for (const entry of entries) {
+        if (entry.kind === "function" || entry.kind === "method") functions++;
+        if (entry.kind === "class") classes++;
+        if (entry.kind === "interface") interfaces++;
+        if (entry.kind === "type_alias") types++;
+      }
+    }
+    return {
+      indexed: {
+        files,
+        functions,
+        classes,
+        interfaces,
+        types
+      },
+      duration_ms: duration_ms || 0,
+      memory_mb: memory_mb || 0
+    };
+  }
+  mapKind(node) {
+    if (Node.isClassDeclaration(node)) return "class";
+    if (Node.isFunctionDeclaration(node)) return "function";
+    if (Node.isInterfaceDeclaration(node)) return "interface";
+    if (Node.isTypeAliasDeclaration(node)) return "type_alias";
+    if (Node.isEnumDeclaration(node)) return "enum";
+    if (Node.isVariableDeclaration(node)) return "variable";
+    if (Node.isMethodDeclaration(node)) return "method";
+    if (Node.isPropertyDeclaration(node)) return "property";
+    if (Node.isParameterDeclaration(node)) return "parameter";
+    return "variable";
+  }
   /**
-   * Resolve definition of a symbol at a path
+   * Build/Warm the index for a given path
    */
-  async resolveDefinition(symbolName, path2) {
-    const projects = await projectManager.getProjectsForPath(path2);
-    const results = [];
-    for (const project of projects) {
-      const sourceFiles = project.getSourceFiles();
-      for (const sourceFile of sourceFiles) {
-        const nodes = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => id.getText() === symbolName);
-        for (const node of nodes) {
-          const definitions = node.getDefinitionNodes();
-          for (const defNode of definitions) {
-            results.push(this.mapToDefinitionLocation(defNode));
+  async buildIndex(rootDir) {
+    const startTime = Date.now();
+    const safeRoot = validateWorkspacePath(rootDir);
+    const cachePath = this.getCachePath(safeRoot);
+    if (fs2.existsSync(cachePath)) {
+      try {
+        const cached = JSON.parse(
+          fs2.readFileSync(cachePath, "utf-8")
+        );
+        if (this.isCacheValid(cached, safeRoot)) {
+          this.index = cached.symbols;
+          return this.computeStats(
+            cached,
+            Date.now() - startTime,
+            process.memoryUsage().heapUsed / 1024 / 1024
+          );
+        }
+      } catch (e) {
+      }
+    }
+    const tsconfigs = await projectManager.getProjectsForPath(safeRoot);
+    const symbols = {};
+    const fileHashes = {};
+    for (const config of tsconfigs) {
+      const project = projectManager.ensureProject(config);
+      project.addSourceFilesFromTsConfig(config);
+      for (const sourceFile of project.getSourceFiles()) {
+        const filePath = sourceFile.getFilePath();
+        try {
+          fileHashes[filePath] = fs2.statSync(filePath).mtimeMs;
+        } catch {
+          continue;
+        }
+        for (const [name, decls] of sourceFile.getExportedDeclarations()) {
+          for (const decl of decls) {
+            const entry = {
+              name,
+              kind: this.mapKind(decl),
+              file: filePath,
+              line: decl.getStartLineNumber(),
+              column: decl.getStart() - decl.getStartLinePos(),
+              exported: true
+            };
+            (symbols[name] ||= []).push(entry);
+          }
+        }
+        for (const fn of sourceFile.getFunctions()) {
+          const name = fn.getName();
+          if (name && !symbols[name]?.some(
+            (s) => s.file === filePath && s.line === fn.getStartLineNumber()
+          )) {
+            const entry = {
+              name,
+              kind: "function",
+              file: filePath,
+              line: fn.getStartLineNumber(),
+              column: fn.getStart() - fn.getStartLinePos(),
+              exported: false
+            };
+            (symbols[name] ||= []).push(entry);
+          }
+        }
+        for (const cls of sourceFile.getClasses()) {
+          const name = cls.getName();
+          if (name && !symbols[name]?.some(
+            (s) => s.file === filePath && s.line === cls.getStartLineNumber()
+          )) {
+            const entry = {
+              name,
+              kind: "class",
+              file: filePath,
+              line: cls.getStartLineNumber(),
+              column: cls.getStart() - cls.getStartLinePos(),
+              exported: false
+            };
+            (symbols[name] ||= []).push(entry);
           }
         }
       }
     }
-    return this.deduplicateLocations(results);
+    const cache = {
+      version: 1,
+      rootDir: safeRoot,
+      builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fileHashes,
+      symbols
+    };
+    fs2.mkdirSync(path2.dirname(cachePath), { recursive: true });
+    fs2.writeFileSync(cachePath, JSON.stringify(cache));
+    this.index = symbols;
+    const duration = Date.now() - startTime;
+    const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
+    return this.computeStats(cache, duration, Math.round(memoryUsage));
   }
-  /**
-   * Find references to a symbol
-   */
-  async findReferences(symbolName, path2, limit = 50, offset = 0) {
-    const projects = await projectManager.getProjectsForPath(path2);
-    const results = [];
-    for (const project of projects) {
-      const sourceFiles = project.getSourceFiles();
-      for (const sourceFile of sourceFiles) {
-        const nodes = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => id.getText() === symbolName);
-        for (const node of nodes) {
-          const referencedSymbols = node.findReferences();
-          for (const referencedSymbol of referencedSymbols) {
-            const references = referencedSymbol.getReferences();
-            for (const ref of references) {
-              const sourceFile2 = ref.getSourceFile();
-              const lineAndColumn = sourceFile2.getLineAndColumnAtPos(
-                ref.getTextSpan().getStart()
-              );
-              results.push({
-                file: sourceFile2.getFilePath(),
-                line: lineAndColumn.line,
-                column: lineAndColumn.column,
-                text: ref.getNode().getParent()?.getText() || ref.getNode().getText()
-              });
+  lookup(name) {
+    return this.index[name] || [];
+  }
+  lookupByFile(file) {
+    return Object.values(this.index).flat().filter((e) => e.file === file);
+  }
+};
+var symbolIndex = new SymbolIndex();
+
+// src/worker/pool.ts
+import { Worker } from "worker_threads";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var WorkerPool = class {
+  constructor(poolSize) {
+    this.poolSize = poolSize;
+  }
+  workers = [];
+  available = [];
+  queue = [];
+  activeJobs = /* @__PURE__ */ new Map();
+  taskId = 0;
+  async init() {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const workerPath = path3.join(__dirname2, "ast-worker.js");
+    for (let i = 0; i < this.poolSize; i++) {
+      const worker = new Worker(workerPath);
+      worker.on("message", (msg) => this.handleResult(msg));
+      worker.on("error", (err) => this.handleWorkerError(worker, err));
+      this.workers.push(worker);
+      this.available.push(worker);
+    }
+  }
+  async execute(type, payload) {
+    return new Promise((resolve, reject) => {
+      const id = String(++this.taskId);
+      const task = { id, type, payload, resolve, reject };
+      const worker = this.available.pop();
+      if (worker) {
+        this.dispatch(worker, task);
+      } else {
+        this.queue.push(task);
+      }
+    });
+  }
+  dispatch(worker, task) {
+    this.activeJobs.set(task.id, task);
+    worker.postMessage({ id: task.id, type: task.type, payload: task.payload });
+  }
+  handleResult(msg) {
+    const task = this.activeJobs.get(msg.id);
+    if (!task) return;
+    this.activeJobs.delete(msg.id);
+    if (msg.error) {
+      task.reject(new Error(msg.error));
+    } else {
+      task.resolve(msg.result);
+    }
+    const worker = this.workers.find(
+      (w) => !this.available.includes(w) && ![...this.activeJobs.values()].some((t) => t.id === msg.id)
+      // simplistic
+    );
+  }
+  handleWorkerError(worker, err) {
+    const idx = this.workers.indexOf(worker);
+    if (idx !== -1) {
+      worker.terminate();
+      const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+      const workerPath = path3.join(__dirname2, "ast-worker.js");
+      const newWorker = new Worker(workerPath);
+      newWorker.on("message", (msg) => this.handleResult(msg));
+      newWorker.on("error", (e) => this.handleWorkerError(newWorker, e));
+      this.workers[idx] = newWorker;
+      this.available.push(newWorker);
+    }
+  }
+  async terminate() {
+    await Promise.all(this.workers.map((w) => w.terminate()));
+    this.workers = [];
+    this.available = [];
+  }
+};
+
+// src/adapters/typescript-adapter.ts
+var TypeScriptAdapter = class {
+  pool;
+  constructor() {
+    const poolSize = parseInt(process.env.AST_WORKER_POOL_SIZE || "2");
+    this.pool = new WorkerPool(poolSize);
+  }
+  async resolveDefinition(symbolName, path4) {
+    validateWorkspacePath(path4);
+    const indexHits = symbolIndex.lookup(symbolName);
+    if (indexHits.length > 0) {
+      const results = [];
+      for (const hit of indexHits) {
+        const tsconfig2 = await projectManager.findNearestTsConfig(hit.file);
+        if (tsconfig2) {
+          const project = projectManager.ensureProject(tsconfig2);
+          const sourceFile = project.addSourceFileAtPathIfExists(hit.file);
+          if (sourceFile) {
+            const exported = sourceFile.getExportedDeclarations().get(symbolName);
+            if (exported && exported.length > 0) {
+              results.push(this.mapToDefinitionLocation(exported[0]));
+              continue;
             }
           }
         }
+        results.push({
+          file: hit.file,
+          line: hit.line,
+          column: hit.column,
+          kind: hit.kind,
+          snippet: "",
+          documentation: void 0
+        });
       }
+      return results;
+    }
+    if (fs3.statSync(path4).isDirectory()) {
+      return [];
+    }
+    const tsconfig = await projectManager.findNearestTsConfig(path4);
+    if (!tsconfig) return [];
+    try {
+      const result = await this.pool.execute(
+        "resolve_definition",
+        {
+          tsconfig,
+          file: path4,
+          symbol: symbolName
+        }
+      );
+      return result;
+    } catch {
+      const project = projectManager.ensureProject(tsconfig);
+      const sourceFile = project.addSourceFileAtPathIfExists(path4);
+      if (!sourceFile) return [];
+      const exported = sourceFile.getExportedDeclarations().get(symbolName);
+      if (!exported) return [];
+      return exported.map((decl) => this.mapToDefinitionLocation(decl));
     }
-    const uniqueResults = this.deduplicateLocations(results);
-    return {
-      references: uniqueResults.slice(offset, offset + limit),
-      total_count: uniqueResults.length
-    };
   }
-  /**
-   * Find implementations for a symbol
-   */
-  async findImplementations(symbolName, path2, limit = 50, offset = 0) {
-    const projects = await projectManager.getProjectsForPath(path2);
+  async findReferences(symbolName, path4, limit = 50, offset = 0) {
+    validateWorkspacePath(path4);
+    const hits = symbolIndex.lookup(symbolName);
+    if (hits.length === 0) return { references: [], total_count: 0 };
+    const hit = hits[0];
+    const tsconfig = await projectManager.findNearestTsConfig(hit.file);
+    if (!tsconfig) return { references: [], total_count: 0 };
+    const project = projectManager.ensureProject(tsconfig);
+    const sourceFile = project.addSourceFileAtPathIfExists(hit.file);
+    if (!sourceFile) return { references: [], total_count: 0 };
+    const exported = sourceFile.getExportedDeclarations().get(symbolName);
+    if (!exported || exported.length === 0)
+      return { references: [], total_count: 0 };
+    const targetNode = exported[0];
+    try {
+      const { searchCode: searchCode2 } = await import("./search-code-V3LACKQ6.js");
+      const searchResults = await searchCode2(
+        symbolName,
+        path4,
+        "*.{ts,tsx,js,jsx}",
+        1e3,
+        false
+      );
+      const filesToLoad = [...new Set(searchResults.map((r) => r.file))];
+      for (const file of filesToLoad) {
+        project.addSourceFileAtPathIfExists(file);
+      }
+    } catch (_e) {
+    }
+    const refSymbols = targetNode.findReferences?.();
+    if (!refSymbols) return { references: [], total_count: 0 };
     const results = [];
-    for (const project of projects) {
-      const sourceFiles = project.getSourceFiles();
-      for (const sourceFile of sourceFiles) {
-        const nodes = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => id.getText() === symbolName);
-        for (const node of nodes) {
-          const implementations = node.getImplementations();
-          for (const impl of implementations) {
-            const sourceFile2 = impl.getSourceFile();
-            const lineAndColumn = sourceFile2.getLineAndColumnAtPos(
-              impl.getTextSpan().getStart()
-            );
-            results.push({
-              file: sourceFile2.getFilePath(),
-              line: lineAndColumn.line,
-              column: lineAndColumn.column,
-              text: impl.getNode().getParent()?.getText() || impl.getNode().getText()
-            });
-          }
-        }
+    for (const refSymbol of refSymbols) {
+      for (const ref of refSymbol.getReferences()) {
+        const sf = ref.getSourceFile();
+        const lc = sf.getLineAndColumnAtPos(ref.getTextSpan().getStart());
+        results.push({
+          file: sf.getFilePath(),
+          line: lc.line,
+          column: lc.column,
+          text: ref.getNode().getParent()?.getText() || ref.getNode().getText()
+        });
       }
     }
-    const uniqueResults = this.deduplicateLocations(results);
+    const unique = this.deduplicateLocations(results);
     return {
-      implementations: uniqueResults.slice(offset, offset + limit),
-      total_count: uniqueResults.length
+      references: unique.slice(offset, offset + limit),
+      total_count: unique.length
     };
   }
-  /**
-   * Get file structure overview
-   */
+  async findImplementations(symbolName, path4, limit = 50, offset = 0) {
+    validateWorkspacePath(path4);
+    const hits = symbolIndex.lookup(symbolName);
+    if (hits.length === 0) return { implementations: [], total_count: 0 };
+    const hit = hits[0];
+    const tsconfig = await projectManager.findNearestTsConfig(hit.file);
+    if (!tsconfig) return { implementations: [], total_count: 0 };
+    try {
+      const result = await this.pool.execute("find_implementations", {
+        tsconfig,
+        file: hit.file,
+        symbol: symbolName
+      });
+      return {
+        implementations: result.implementations.slice(offset, offset + limit),
+        total_count: result.total_count
+      };
+    } catch {
+      const project = projectManager.ensureProject(tsconfig);
+      const sourceFile = project.addSourceFileAtPathIfExists(hit.file);
+      if (!sourceFile) return { implementations: [], total_count: 0 };
+      const exported = sourceFile.getExportedDeclarations().get(symbolName);
+      if (!exported || exported.length === 0)
+        return { implementations: [], total_count: 0 };
+      const targetNode = exported[0];
+      if (!Node2.isClassDeclaration(targetNode) && !Node2.isInterfaceDeclaration(targetNode)) {
+        return { implementations: [], total_count: 0 };
+      }
+      try {
+        const { searchCode: searchCode2 } = await import("./search-code-V3LACKQ6.js");
+        const searchResults = await searchCode2(
+          symbolName,
+          path4,
+          "*.{ts,tsx,js,jsx}",
+          1e3,
+          false
+        );
+        const filesToLoad = [...new Set(searchResults.map((r) => r.file))];
+        for (const file of filesToLoad) {
+          project.addSourceFileAtPathIfExists(file);
+        }
+      } catch (_e) {
+      }
+      const results = [];
+      const implementations = targetNode.getImplementations?.();
+      if (implementations) {
+        for (const impl of implementations) {
+          const sf = impl.getSourceFile();
+          const lc = sf.getLineAndColumnAtPos(impl.getTextSpan().getStart());
+          results.push({
+            file: sf.getFilePath(),
+            line: lc.line,
+            column: lc.column,
+            text: impl.getNode().getParent()?.getText() || impl.getNode().getText()
+          });
+        }
+      }
+      const unique = this.deduplicateLocations(results);
+      return {
+        implementations: unique.slice(offset, offset + limit),
+        total_count: unique.length
+      };
+    }
+  }
   async getFileStructure(filePath) {
-    const project = await projectManager.getProjectForFile(filePath);
-    if (!project) return void 0;
-    const sourceFile = project.getSourceFile(filePath);
+    const safePath = validateWorkspacePath(filePath);
+    const tsconfig = await projectManager.findNearestTsConfig(safePath);
+    if (!tsconfig) return void 0;
+    const project = projectManager.ensureProject(tsconfig);
+    const sourceFile = project.addSourceFileAtPathIfExists(safePath);
     if (!sourceFile) return void 0;
     const structure = {
-      file: filePath,
+      file: safePath,
       imports: sourceFile.getImportDeclarations().map((imp) => ({
         module: imp.getModuleSpecifierValue(),
         names: imp.getNamedImports().map((ni) => ni.getName())
@@ -245,9 +602,9 @@ var TypeScriptAdapter = class {
     };
     return structure;
   }
-  /**
-   * Helper: Map ts-morph Node (Declaration) to DefinitionLocation
-   */
+  async shutdown() {
+    await this.pool.terminate();
+  }
   mapToDefinitionLocation(node) {
     const sourceFile = node.getSourceFile();
     const lineAndColumn = sourceFile.getLineAndColumnAtPos(node.getStart());
@@ -260,34 +617,25 @@ var TypeScriptAdapter = class {
       documentation: this.getJsDoc(node)
     };
   }
-  /**
-   * Helper: Map ts-morph Node to SymbolKind
-   */
   mapNodeToSymbolKind(node) {
-    if (Node.isClassDeclaration(node)) return "class";
-    if (Node.isFunctionDeclaration(node)) return "function";
-    if (Node.isInterfaceDeclaration(node)) return "interface";
-    if (Node.isTypeAliasDeclaration(node)) return "type_alias";
-    if (Node.isEnumDeclaration(node)) return "enum";
-    if (Node.isVariableDeclaration(node)) return "variable";
-    if (Node.isMethodDeclaration(node)) return "method";
-    if (Node.isPropertyDeclaration(node)) return "property";
-    if (Node.isParameterDeclaration(node)) return "parameter";
+    if (Node2.isClassDeclaration(node)) return "class";
+    if (Node2.isFunctionDeclaration(node)) return "function";
+    if (Node2.isInterfaceDeclaration(node)) return "interface";
+    if (Node2.isTypeAliasDeclaration(node)) return "type_alias";
+    if (Node2.isEnumDeclaration(node)) return "enum";
+    if (Node2.isVariableDeclaration(node)) return "variable";
+    if (Node2.isMethodDeclaration(node)) return "method";
+    if (Node2.isPropertyDeclaration(node)) return "property";
+    if (Node2.isParameterDeclaration(node)) return "parameter";
     return "variable";
   }
-  /**
-   * Helper: Map Symbol to SymbolKind
-   */
   mapSymbolKind(symbol) {
     const decls = symbol.getDeclarations();
     if (decls.length > 0) return this.mapNodeToSymbolKind(decls[0]);
     return "variable";
   }
-  /**
-   * Helper: Get JSDoc from Node
-   */
   getJsDoc(node) {
-    if (Node.isJSDocable(node)) {
+    if (Node2.isJSDocable(node)) {
       const docs = node.getJsDocs();
       if (docs.length > 0) {
         return docs[0].getCommentText();
@@ -295,11 +643,8 @@ var TypeScriptAdapter = class {
     }
     return void 0;
   }
-  /**
-   * Helper: Get full JSDoc info (with tags)
-   */
   getSymbolDocs(node) {
-    if (Node.isJSDocable(node)) {
+    if (Node2.isJSDocable(node)) {
       const docs = node.getJsDocs();
       if (docs.length > 0) {
         const doc = docs[0];
@@ -362,9 +707,6 @@ var TypeScriptAdapter = class {
       members: enm.getMembers().map((m) => m.getName())
     };
   }
-  /**
-   * Helper: Deduplicate locations
-   */
   deduplicateLocations(locations) {
     const seen = /* @__PURE__ */ new Set();
     return locations.filter((loc) => {
@@ -378,20 +720,20 @@ var TypeScriptAdapter = class {
 var typescriptAdapter = new TypeScriptAdapter();
 
 // src/tools/resolve-definition.ts
-async function resolveDefinition(symbol, path2) {
-  return await typescriptAdapter.resolveDefinition(symbol, path2);
+async function resolveDefinition(symbol, path4) {
+  return await typescriptAdapter.resolveDefinition(symbol, path4);
 }
 
 // src/tools/find-references.ts
-async function findReferences(symbol, path2, limit = 50, offset = 0) {
-  return await typescriptAdapter.findReferences(symbol, path2, limit, offset);
+async function findReferences(symbol, path4, limit = 50, offset = 0) {
+  return await typescriptAdapter.findReferences(symbol, path4, limit, offset);
 }
 
 // src/tools/find-implementations.ts
-async function findImplementations(symbol, path2, limit = 50, offset = 0) {
+async function findImplementations(symbol, path4, limit = 50, offset = 0) {
   return await typescriptAdapter.findImplementations(
     symbol,
-    path2,
+    path4,
     limit,
     offset
   );
@@ -402,76 +744,27 @@ async function getFileStructure(file) {
   return await typescriptAdapter.getFileStructure(file);
 }
 
-// src/tools/search-code.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { rgPath } from "@vscode/ripgrep";
-var execFileAsync = promisify(execFile);
-async function searchCode(pattern, searchPath, filePattern, limit = 50) {
-  const args = [
-    "--json",
-    "--max-count",
-    limit.toString(),
-    "--fixed-strings",
-    // Default to fixed strings unless we want regex
-    pattern,
-    searchPath
-  ];
-  if (filePattern) {
-    args.push("--glob", filePattern);
-  }
-  args.push("--glob", "!**/node_modules/**");
-  args.push("--glob", "!**/dist/**");
-  args.push("--glob", "!**/.git/**");
-  try {
-    const { stdout } = await execFileAsync(rgPath, args);
-    const lines = stdout.split("\n").filter(Boolean);
-    const results = [];
-    for (const line of lines) {
-      const data = JSON.parse(line);
-      if (data.type === "match") {
-        const file = data.data.path.text;
-        const lineNumber = data.data.line_number;
-        const submatches = data.data.submatches;
-        for (const submatch of submatches) {
-          results.push({
-            file,
-            line: lineNumber,
-            column: submatch.start,
-            text: data.data.lines.text.trim()
-          });
-        }
-      }
-    }
-    return results.slice(0, limit);
-  } catch (error) {
-    if (error.code === 1) {
-      return [];
-    }
-    throw error;
-  }
-}
-
 // src/tools/get-symbol-docs.ts
-import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+import { SyntaxKind } from "ts-morph";
 async function getSymbolDocs(symbol, filePath) {
-  const projects = await projectManager.getProjectsForPath(filePath);
-  for (const project of projects) {
-    const sourceFile = project.getSourceFile(filePath);
-    if (sourceFile) {
-      const node = sourceFile.getDescendantsOfKind(SyntaxKind2.Identifier).find((id) => id.getText() === symbol);
-      if (node) {
-        const decls = node.getSymbol()?.getDeclarations();
-        if (decls && decls.length > 0) {
-          const docs = typescriptAdapter.getSymbolDocs(decls[0]);
-          if (docs) {
-            return {
-              symbol,
-              file: sourceFile.getFilePath(),
-              line: sourceFile.getLineAndColumnAtPos(decls[0].getStart()).line,
-              ...docs
-            };
-          }
+  const safePath = validateWorkspacePath(filePath);
+  const tsconfig = await projectManager.findNearestTsConfig(safePath);
+  if (!tsconfig) return void 0;
+  const project = projectManager.ensureProject(tsconfig);
+  const sourceFile = project.addSourceFileAtPathIfExists(safePath);
+  if (sourceFile) {
+    const node = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).find((id) => id.getText() === symbol);
+    if (node) {
+      const decls = node.getSymbol()?.getDeclarations();
+      if (decls && decls.length > 0) {
+        const docs = typescriptAdapter.getSymbolDocs(decls[0]);
+        if (docs) {
+          return {
+            symbol,
+            file: sourceFile.getFilePath(),
+            line: sourceFile.getLineAndColumnAtPos(decls[0].getStart()).line,
+            ...docs
+          };
         }
       }
     }
@@ -479,49 +772,9 @@ async function getSymbolDocs(symbol, filePath) {
   return void 0;
 }
 
-// src/index/symbol-index.ts
-var SymbolIndex = class {
-  /**
-   * Build/Warm the index for a given path
-   */
-  async buildIndex(rootDir) {
-    const startTime = Date.now();
-    const projects = await projectManager.getProjectsForPath(rootDir);
-    let fileCount = 0;
-    let functionCount = 0;
-    let classCount = 0;
-    let interfaceCount = 0;
-    let typeCount = 0;
-    for (const project of projects) {
-      const sourceFiles = project.getSourceFiles();
-      fileCount += sourceFiles.length;
-      for (const sourceFile of sourceFiles) {
-        functionCount += sourceFile.getFunctions().length;
-        classCount += sourceFile.getClasses().length;
-        interfaceCount += sourceFile.getInterfaces().length;
-        typeCount += sourceFile.getTypeAliases().length;
-      }
-    }
-    const duration = Date.now() - startTime;
-    const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
-    return {
-      indexed: {
-        files: fileCount,
-        functions: functionCount,
-        classes: classCount,
-        interfaces: interfaceCount,
-        types: typeCount
-      },
-      duration_ms: duration,
-      memory_mb: Math.round(memoryUsage)
-    };
-  }
-};
-var symbolIndex = new SymbolIndex();
-
 // src/tools/build-symbol-index.ts
-async function buildSymbolIndex(path2) {
-  return await symbolIndex.buildIndex(path2);
+async function buildSymbolIndex(path4) {
+  return await symbolIndex.buildIndex(path4);
 }
 
 // src/index.ts
@@ -615,7 +868,8 @@ var ASTExplorerServer = class {
                 pattern: { type: "string", description: "Search pattern" },
                 path: { type: "string", description: "Directory to search" },
                 filePattern: { type: "string", description: "Glob filter" },
-                limit: { type: "number", default: 50 }
+                limit: { type: "number", default: 50 },
+                regex: { type: "boolean", default: true }
               },
               required: ["pattern", "path"]
             }
@@ -651,8 +905,8 @@ var ASTExplorerServer = class {
       try {
         switch (name) {
           case "resolve_definition": {
-            const { symbol, path: path2 } = ResolveDefinitionSchema.parse(args);
-            const results = await resolveDefinition(symbol, path2);
+            const { symbol, path: path4 } = ResolveDefinitionSchema.parse(args);
+            const results = await resolveDefinition(symbol, path4);
             return {
               content: [
                 { type: "text", text: JSON.stringify(results, null, 2) }
@@ -660,8 +914,8 @@ var ASTExplorerServer = class {
             };
           }
           case "find_references": {
-            const { symbol, path: path2, limit, offset } = FindReferencesSchema.parse(args);
-            const results = await findReferences(symbol, path2, limit, offset);
+            const { symbol, path: path4, limit, offset } = FindReferencesSchema.parse(args);
+            const results = await findReferences(symbol, path4, limit, offset);
             return {
               content: [
                 { type: "text", text: JSON.stringify(results, null, 2) }
@@ -669,10 +923,10 @@ var ASTExplorerServer = class {
             };
           }
           case "find_implementations": {
-            const { symbol, path: path2, limit, offset } = FindImplementationsSchema.parse(args);
+            const { symbol, path: path4, limit, offset } = FindImplementationsSchema.parse(args);
             const results = await findImplementations(
               symbol,
-              path2,
+              path4,
               limit,
               offset
             );
@@ -692,8 +946,14 @@ var ASTExplorerServer = class {
             };
           }
           case "search_code": {
-            const { pattern, path: path2, filePattern, limit } = SearchCodeSchema.parse(args);
-            const results = await searchCode(pattern, path2, filePattern, limit);
+            const { pattern, path: path4, filePattern, limit, regex } = SearchCodeSchema.parse(args);
+            const results = await searchCode(
+              pattern,
+              path4,
+              filePattern,
+              limit,
+              regex
+            );
             return {
               content: [
                 { type: "text", text: JSON.stringify(results, null, 2) }
@@ -701,15 +961,15 @@ var ASTExplorerServer = class {
             };
           }
           case "get_symbol_docs": {
-            const { symbol, path: path2 } = GetSymbolDocsSchema.parse(args);
-            const docs = await getSymbolDocs(symbol, path2);
+            const { symbol, path: path4 } = GetSymbolDocsSchema.parse(args);
+            const docs = await getSymbolDocs(symbol, path4);
             return {
               content: [{ type: "text", text: JSON.stringify(docs, null, 2) }]
             };
           }
           case "build_symbol_index": {
-            const { path: path2 } = BuildSymbolIndexSchema.parse(args);
-            const stats = await buildSymbolIndex(path2);
+            const { path: path4 } = BuildSymbolIndexSchema.parse(args);
+            const stats = await buildSymbolIndex(path4);
             return {
               content: [{ type: "text", text: JSON.stringify(stats, null, 2) }]
             };