@aiready/ast-mcp-server 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,17 +30,118 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/security.ts
+function resolveWorkspaceRoot() {
+  return process.env.AST_WORKSPACE_ROOT || process.cwd();
+}
+function validateWorkspacePath(inputPath) {
+  const root = resolveWorkspaceRoot();
+  const resolved = import_path.default.resolve(root, inputPath);
+  const normalized = import_path.default.normalize(resolved);
+  if (!normalized.startsWith(root)) {
+    throw new Error(
+      `Path traversal detected: ${inputPath} escapes workspace root`
+    );
+  }
+  if (normalized.includes("\0")) {
+    throw new Error("Path contains null bytes");
+  }
+  return normalized;
+}
+var import_path;
+var init_security = __esm({
+  "src/security.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path = __toESM(require("path"), 1);
+  }
+});
+
+// src/tools/search-code.ts
+var search_code_exports = {};
+__export(search_code_exports, {
+  searchCode: () => searchCode
+});
+async function searchCode(pattern, searchPath, filePattern, limit = 50, regex = true) {
+  const safePath = validateWorkspacePath(searchPath);
+  const args = [
+    "--json",
+    "--max-count",
+    limit.toString(),
+    "--max-columns",
+    "500"
+  ];
+  if (!regex) {
+    args.push("--fixed-strings");
+  }
+  args.push(pattern, safePath);
+  if (filePattern) {
+    args.push("--glob", filePattern);
+  }
+  args.push("--glob", "!**/node_modules/**");
+  args.push("--glob", "!**/dist/**");
+  args.push("--glob", "!**/.git/**");
+  try {
+    const { stdout } = await execFileAsync(import_ripgrep.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;
+  }
+}
+var import_child_process, import_util, import_ripgrep, execFileAsync;
+var init_search_code = __esm({
+  "src/tools/search-code.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_child_process = require("child_process");
+    import_util = require("util");
+    import_ripgrep = require("@vscode/ripgrep");
+    init_security();
+    execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   ASTExplorerServer: () => ASTExplorerServer
 });
 module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 
 // src/schemas.ts
+init_cjs_shims();
 var import_zod = require("zod");
 var ResolveDefinitionSchema = import_zod.z.object({
   symbol: import_zod.z.string().describe(
@@ -61,10 +165,11 @@ var GetFileStructureSchema = import_zod.z.object({
   file: import_zod.z.string().describe("Absolute path to the file to analyze")
 });
 var SearchCodeSchema = import_zod.z.object({
-  pattern: import_zod.z.string().describe("Search pattern (regex)"),
+  pattern: import_zod.z.string().describe("Search pattern (regex by default)"),
   path: import_zod.z.string().describe("Directory to search in"),
   filePattern: import_zod.z.string().optional().describe('Glob filter (e.g., "*.ts")'),
-  limit: import_zod.z.number().optional().default(50).describe("Max matches to return")
+  limit: import_zod.z.number().optional().default(50).describe("Max matches to return"),
+  regex: import_zod.z.boolean().optional().default(true).describe("Use regex mode (default true)")
 });
 var GetSymbolDocsSchema = import_zod.z.object({
   symbol: import_zod.z.string().describe("Symbol name to get documentation for"),
@@ -74,189 +179,450 @@ var BuildSymbolIndexSchema = import_zod.z.object({
   path: import_zod.z.string().describe("Project root directory to index")
 });
 
+// src/tools/resolve-definition.ts
+init_cjs_shims();
+
 // src/adapters/typescript-adapter.ts
-var import_ts_morph2 = require("ts-morph");
+init_cjs_shims();
+var import_ts_morph3 = require("ts-morph");
+var import_fs3 = __toESM(require("fs"), 1);
 
 // src/project-manager.ts
+init_cjs_shims();
 var import_ts_morph = require("ts-morph");
-var import_path = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
 var import_glob = require("glob");
+init_security();
 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 (0, import_glob.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 import_ts_morph.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 = import_path.default.dirname(filePath);
-    const root = import_path.default.parse(currentDir).root;
+    const safePath = validateWorkspacePath(filePath);
+    let currentDir = import_path2.default.dirname(safePath);
+    const root = import_path2.default.parse(currentDir).root;
     while (currentDir !== root) {
-      const tsconfigPath = import_path.default.join(currentDir, "tsconfig.json");
+      const tsconfigPath = import_path2.default.join(currentDir, "tsconfig.json");
       if (import_fs.default.existsSync(tsconfigPath)) {
         return tsconfigPath;
       }
-      currentDir = import_path.default.dirname(currentDir);
+      currentDir = import_path2.default.dirname(currentDir);
     }
     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
+init_cjs_shims();
+init_security();
+var import_fs2 = __toESM(require("fs"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_ts_morph2 = require("ts-morph");
+var SymbolIndex = class {
+  index = {};
+  getCachePath(rootDir) {
+    const hash = import_crypto.default.createHash("sha256").update(rootDir).digest("hex").slice(0, 12);
+    return import_path3.default.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 (!import_fs2.default.existsSync(file)) return false;
+      if (import_fs2.default.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 (import_ts_morph2.Node.isClassDeclaration(node)) return "class";
+    if (import_ts_morph2.Node.isFunctionDeclaration(node)) return "function";
+    if (import_ts_morph2.Node.isInterfaceDeclaration(node)) return "interface";
+    if (import_ts_morph2.Node.isTypeAliasDeclaration(node)) return "type_alias";
+    if (import_ts_morph2.Node.isEnumDeclaration(node)) return "enum";
+    if (import_ts_morph2.Node.isVariableDeclaration(node)) return "variable";
+    if (import_ts_morph2.Node.isMethodDeclaration(node)) return "method";
+    if (import_ts_morph2.Node.isPropertyDeclaration(node)) return "property";
+    if (import_ts_morph2.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(import_ts_morph2.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 (import_fs2.default.existsSync(cachePath)) {
+      try {
+        const cached = JSON.parse(
+          import_fs2.default.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] = import_fs2.default.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
+    };
+    import_fs2.default.mkdirSync(import_path3.default.dirname(cachePath), { recursive: true });
+    import_fs2.default.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(import_ts_morph2.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/adapters/typescript-adapter.ts
+init_security();
+var TypeScriptAdapter = class {
+  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 project2 = projectManager.ensureProject(tsconfig2);
+          const sourceFile2 = project2.addSourceFileAtPathIfExists(hit.file);
+          if (sourceFile2) {
+            const exported2 = sourceFile2.getExportedDeclarations().get(symbolName);
+            if (exported2 && exported2.length > 0) {
+              results.push(this.mapToDefinitionLocation(exported2[0]));
+              continue;
             }
           }
         }
+        results.push({
+          file: hit.file,
+          line: hit.line,
+          column: hit.column,
+          kind: hit.kind,
+          snippet: "",
+          documentation: void 0
+        });
+      }
+      return results;
+    }
+    if (import_fs3.default.statSync(path4).isDirectory()) {
+      return [];
+    }
+    const tsconfig = await projectManager.findNearestTsConfig(path4);
+    if (!tsconfig) return [];
+    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));
+  }
+  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 Promise.resolve().then(() => (init_search_code(), search_code_exports));
+      const searchResults = await searchCode2(
+        symbolName,
+        path4,
+        "*.{ts,tsx,js,jsx}",
+        1e3,
+        false
+      );
+      const filesToLoad = [...new Set(searchResults.map((r) => r.file))];
+      console.log("Search code files to load:", filesToLoad);
+      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 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 {
-      references: uniqueResults.slice(offset, offset + limit),
-      total_count: uniqueResults.length
+      references: unique.slice(offset, offset + limit),
+      total_count: unique.length
     };
   }
-  /**
-   * Find implementations for a symbol
-   */
-  async findImplementations(symbolName, path2, limit = 50, offset = 0) {
-    const projects = await projectManager.getProjectsForPath(path2);
+  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 };
+    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 (!import_ts_morph3.Node.isClassDeclaration(targetNode) && !import_ts_morph3.Node.isInterfaceDeclaration(targetNode)) {
+      return { implementations: [], total_count: 0 };
+    }
+    try {
+      const { searchCode: searchCode2 } = await Promise.resolve().then(() => (init_search_code(), search_code_exports));
+      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 = [];
-    for (const project of projects) {
-      const sourceFiles = project.getSourceFiles();
-      for (const sourceFile of sourceFiles) {
-        const nodes = sourceFile.getDescendantsOfKind(import_ts_morph2.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()
-            });
-          }
-        }
+    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 uniqueResults = this.deduplicateLocations(results);
+    const unique = this.deduplicateLocations(results);
     return {
-      implementations: uniqueResults.slice(offset, offset + limit),
-      total_count: uniqueResults.length
+      implementations: unique.slice(offset, offset + limit),
+      total_count: unique.length
     };
   }
-  /**
-   * Get file structure overview
-   */
   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())
@@ -273,9 +639,6 @@ var TypeScriptAdapter = class {
     };
     return structure;
   }
-  /**
-   * Helper: Map ts-morph Node (Declaration) to DefinitionLocation
-   */
   mapToDefinitionLocation(node) {
     const sourceFile = node.getSourceFile();
     const lineAndColumn = sourceFile.getLineAndColumnAtPos(node.getStart());
@@ -288,34 +651,25 @@ var TypeScriptAdapter = class {
       documentation: this.getJsDoc(node)
     };
   }
-  /**
-   * Helper: Map ts-morph Node to SymbolKind
-   */
   mapNodeToSymbolKind(node) {
-    if (import_ts_morph2.Node.isClassDeclaration(node)) return "class";
-    if (import_ts_morph2.Node.isFunctionDeclaration(node)) return "function";
-    if (import_ts_morph2.Node.isInterfaceDeclaration(node)) return "interface";
-    if (import_ts_morph2.Node.isTypeAliasDeclaration(node)) return "type_alias";
-    if (import_ts_morph2.Node.isEnumDeclaration(node)) return "enum";
-    if (import_ts_morph2.Node.isVariableDeclaration(node)) return "variable";
-    if (import_ts_morph2.Node.isMethodDeclaration(node)) return "method";
-    if (import_ts_morph2.Node.isPropertyDeclaration(node)) return "property";
-    if (import_ts_morph2.Node.isParameterDeclaration(node)) return "parameter";
+    if (import_ts_morph3.Node.isClassDeclaration(node)) return "class";
+    if (import_ts_morph3.Node.isFunctionDeclaration(node)) return "function";
+    if (import_ts_morph3.Node.isInterfaceDeclaration(node)) return "interface";
+    if (import_ts_morph3.Node.isTypeAliasDeclaration(node)) return "type_alias";
+    if (import_ts_morph3.Node.isEnumDeclaration(node)) return "enum";
+    if (import_ts_morph3.Node.isVariableDeclaration(node)) return "variable";
+    if (import_ts_morph3.Node.isMethodDeclaration(node)) return "method";
+    if (import_ts_morph3.Node.isPropertyDeclaration(node)) return "property";
+    if (import_ts_morph3.Node.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 (import_ts_morph2.Node.isJSDocable(node)) {
+    if (import_ts_morph3.Node.isJSDocable(node)) {
       const docs = node.getJsDocs();
       if (docs.length > 0) {
         return docs[0].getCommentText();
@@ -323,11 +677,8 @@ var TypeScriptAdapter = class {
     }
     return void 0;
   }
-  /**
-   * Helper: Get full JSDoc info (with tags)
-   */
   getSymbolDocs(node) {
-    if (import_ts_morph2.Node.isJSDocable(node)) {
+    if (import_ts_morph3.Node.isJSDocable(node)) {
       const docs = node.getJsDocs();
       if (docs.length > 0) {
         const doc = docs[0];
@@ -390,9 +741,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) => {
@@ -406,100 +754,59 @@ 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);
+init_cjs_shims();
+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) {
+init_cjs_shims();
+async function findImplementations(symbol, path4, limit = 50, offset = 0) {
   return await typescriptAdapter.findImplementations(
     symbol,
-    path2,
+    path4,
     limit,
     offset
   );
 }
 
 // src/tools/get-file-structure.ts
+init_cjs_shims();
 async function getFileStructure(file) {
   return await typescriptAdapter.getFileStructure(file);
 }
 
-// src/tools/search-code.ts
-var import_child_process = require("child_process");
-var import_util = require("util");
-var import_ripgrep = require("@vscode/ripgrep");
-var execFileAsync = (0, import_util.promisify)(import_child_process.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(import_ripgrep.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/index.ts
+init_search_code();
 
 // src/tools/get-symbol-docs.ts
-var import_ts_morph3 = require("ts-morph");
+init_cjs_shims();
+var import_ts_morph4 = require("ts-morph");
+init_security();
 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(import_ts_morph3.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
-            };
-          }
+  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(import_ts_morph4.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
+          };
         }
       }
     }
@@ -507,49 +814,10 @@ 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);
+init_cjs_shims();
+async function buildSymbolIndex(path4) {
+  return await symbolIndex.buildIndex(path4);
 }
 
 // src/index.ts
@@ -643,7 +911,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"]
             }
@@ -679,8 +948,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) }
@@ -688,8 +957,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) }
@@ -697,10 +966,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
             );
@@ -720,8 +989,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) }
@@ -729,15 +1004,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) }]
             };