@aiready/ast-mcp-server 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1046 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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(
+    "Symbol name to resolve (function, class, type, interface, etc.)"
+  ),
+  path: import_zod.z.string().describe("Project root or target directory")
+});
+var FindReferencesSchema = import_zod.z.object({
+  symbol: import_zod.z.string().describe("Symbol name to find references for"),
+  path: import_zod.z.string().describe("Project root directory"),
+  limit: import_zod.z.number().optional().default(50).describe("Max results per page (default 50)"),
+  offset: import_zod.z.number().optional().default(0).describe("Pagination offset")
+});
+var FindImplementationsSchema = import_zod.z.object({
+  symbol: import_zod.z.string().describe("Interface or abstract class name to find implementations for"),
+  path: import_zod.z.string().describe("Project root directory"),
+  limit: import_zod.z.number().optional().default(50).describe("Max results per page"),
+  offset: import_zod.z.number().optional().default(0).describe("Pagination offset")
+});
+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 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"),
+  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"),
+  path: import_zod.z.string().describe("Project root directory")
+});
+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
+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_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) {
+    const safeRoot = validateWorkspacePath(rootDir);
+    if (this.tsconfigCache.has(safeRoot)) {
+      return this.tsconfigCache.get(safeRoot);
+    }
+    const configs = await (0, import_glob.glob)("**/tsconfig.json", {
+      cwd: safeRoot,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/dist/**"]
+    });
+    this.tsconfigCache.set(safeRoot, configs);
+    return configs;
+  }
+  /**
+   * Ensure a Project exists for a given tsconfig path, managing LRU cache
+   */
+  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: 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) {
+    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_path2.default.join(currentDir, "tsconfig.json");
+      if (import_fs.default.existsSync(tsconfigPath)) {
+        return tsconfigPath;
+      }
+      currentDir = import_path2.default.dirname(currentDir);
+    }
+    return void 0;
+  }
+  /**
+   * Get all tsconfigs for a path
+   */
+  async getProjectsForPath(rootDir) {
+    return this.findTsConfigs(rootDir);
+  }
+  /**
+   * Dispose all projects to free memory
+   */
+  disposeAll() {
+    for (const [key] of this.projects) {
+      this.disposeProject(key);
+    }
+    this.accessOrder = [];
+  }
+};
+var projectManager = new ProjectManager();
+
+// 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";
+  }
+  /**
+   * Build/Warm the index for a given path
+   */
+  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);
+          }
+        }
+      }
+    }
+    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));
+  }
+  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 unique = this.deduplicateLocations(results);
+    return {
+      references: unique.slice(offset, offset + limit),
+      total_count: unique.length
+    };
+  }
+  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 = [];
+    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 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: safePath,
+      imports: sourceFile.getImportDeclarations().map((imp) => ({
+        module: imp.getModuleSpecifierValue(),
+        names: imp.getNamedImports().map((ni) => ni.getName())
+      })),
+      exports: sourceFile.getExportSymbols().map((sym) => ({
+        name: sym.getName(),
+        kind: this.mapSymbolKind(sym)
+      })),
+      classes: sourceFile.getClasses().map((cls) => this.mapToClassInfo(cls)),
+      functions: sourceFile.getFunctions().map((fn) => this.mapToFunctionInfo(fn)),
+      interfaces: sourceFile.getInterfaces().map((itf) => this.mapToInterfaceInfo(itf)),
+      typeAliases: sourceFile.getTypeAliases().map((ta) => this.mapToTypeAliasInfo(ta)),
+      enums: sourceFile.getEnums().map((enm) => this.mapToEnumInfo(enm))
+    };
+    return structure;
+  }
+  mapToDefinitionLocation(node) {
+    const sourceFile = node.getSourceFile();
+    const lineAndColumn = sourceFile.getLineAndColumnAtPos(node.getStart());
+    return {
+      file: sourceFile.getFilePath(),
+      line: lineAndColumn.line,
+      column: lineAndColumn.column,
+      kind: this.mapNodeToSymbolKind(node),
+      snippet: node.getText(),
+      documentation: this.getJsDoc(node)
+    };
+  }
+  mapNodeToSymbolKind(node) {
+    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";
+  }
+  mapSymbolKind(symbol) {
+    const decls = symbol.getDeclarations();
+    if (decls.length > 0) return this.mapNodeToSymbolKind(decls[0]);
+    return "variable";
+  }
+  getJsDoc(node) {
+    if (import_ts_morph3.Node.isJSDocable(node)) {
+      const docs = node.getJsDocs();
+      if (docs.length > 0) {
+        return docs[0].getCommentText();
+      }
+    }
+    return void 0;
+  }
+  getSymbolDocs(node) {
+    if (import_ts_morph3.Node.isJSDocable(node)) {
+      const docs = node.getJsDocs();
+      if (docs.length > 0) {
+        const doc = docs[0];
+        return {
+          documentation: doc.getCommentText(),
+          tags: doc.getTags().map((tag) => ({
+            name: tag.getTagName(),
+            text: tag.getCommentText() || ""
+          }))
+        };
+      }
+    }
+    return void 0;
+  }
+  mapToClassInfo(cls) {
+    return {
+      name: cls.getName() || "anonymous",
+      ...this.getSymbolDocs(cls),
+      methods: cls.getMethods().map((m) => this.mapToFunctionInfo(m)),
+      properties: cls.getProperties().map((p) => this.mapToPropertyInfo(p))
+    };
+  }
+  mapToFunctionInfo(fn) {
+    return {
+      name: fn.getName() || "anonymous",
+      ...this.getSymbolDocs(fn),
+      params: fn.getParameters().map((p) => ({
+        name: p.getName(),
+        type: p.getType().getText()
+      })),
+      returnType: fn.getReturnType().getText()
+    };
+  }
+  mapToPropertyInfo(p) {
+    return {
+      name: p.getName(),
+      type: p.getType().getText(),
+      ...this.getSymbolDocs(p)
+    };
+  }
+  mapToInterfaceInfo(itf) {
+    return {
+      name: itf.getName(),
+      ...this.getSymbolDocs(itf),
+      properties: itf.getProperties().map((p) => this.mapToPropertyInfo(p)),
+      methods: itf.getMethods().map((m) => this.mapToFunctionInfo(m))
+    };
+  }
+  mapToTypeAliasInfo(ta) {
+    return {
+      name: ta.getName(),
+      type: ta.getType().getText(),
+      ...this.getSymbolDocs(ta)
+    };
+  }
+  mapToEnumInfo(enm) {
+    return {
+      name: enm.getName(),
+      ...this.getSymbolDocs(enm),
+      members: enm.getMembers().map((m) => m.getName())
+    };
+  }
+  deduplicateLocations(locations) {
+    const seen = /* @__PURE__ */ new Set();
+    return locations.filter((loc) => {
+      const key = `${loc.file}:${loc.line}:${loc.column}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+};
+var typescriptAdapter = new TypeScriptAdapter();
+
+// src/tools/resolve-definition.ts
+async function resolveDefinition(symbol, path4) {
+  return await typescriptAdapter.resolveDefinition(symbol, path4);
+}
+
+// src/tools/find-references.ts
+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
+init_cjs_shims();
+async function findImplementations(symbol, path4, limit = 50, offset = 0) {
+  return await typescriptAdapter.findImplementations(
+    symbol,
+    path4,
+    limit,
+    offset
+  );
+}
+
+// src/tools/get-file-structure.ts
+init_cjs_shims();
+async function getFileStructure(file) {
+  return await typescriptAdapter.getFileStructure(file);
+}
+
+// src/index.ts
+init_search_code();
+
+// src/tools/get-symbol-docs.ts
+init_cjs_shims();
+var import_ts_morph4 = require("ts-morph");
+init_security();
+async function getSymbolDocs(symbol, 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) {
+    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
+          };
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/tools/build-symbol-index.ts
+init_cjs_shims();
+async function buildSymbolIndex(path4) {
+  return await symbolIndex.buildIndex(path4);
+}
+
+// src/index.ts
+var ASTExplorerServer = class {
+  server;
+  version = "0.1.0";
+  constructor() {
+    this.server = new import_server.Server(
+      {
+        name: "ast-explorer-server",
+        version: this.version
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "resolve_definition",
+            description: "Find where a symbol is defined using TypeScript AST.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                symbol: {
+                  type: "string",
+                  description: "Symbol name (e.g., function, class)"
+                },
+                path: {
+                  type: "string",
+                  description: "Project root or target directory"
+                }
+              },
+              required: ["symbol", "path"]
+            }
+          },
+          {
+            name: "find_references",
+            description: "Find all usages of a symbol across the project.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                symbol: { type: "string", description: "Symbol name" },
+                path: { type: "string", description: "Project root" },
+                limit: { type: "number", default: 50 },
+                offset: { type: "number", default: 0 }
+              },
+              required: ["symbol", "path"]
+            }
+          },
+          {
+            name: "find_implementations",
+            description: "Find implementations of interfaces or abstract classes.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                symbol: { type: "string", description: "Interface/Class name" },
+                path: { type: "string", description: "Project root" },
+                limit: { type: "number", default: 50 },
+                offset: { type: "number", default: 0 }
+              },
+              required: ["symbol", "path"]
+            }
+          },
+          {
+            name: "get_file_structure",
+            description: "Get structural overview of a file (imports, exports, symbols).",
+            inputSchema: {
+              type: "object",
+              properties: {
+                file: { type: "string", description: "Absolute path to file" }
+              },
+              required: ["file"]
+            }
+          },
+          {
+            name: "search_code",
+            description: "Fast regex search via bundled ripgrep.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                pattern: { type: "string", description: "Search pattern" },
+                path: { type: "string", description: "Directory to search" },
+                filePattern: { type: "string", description: "Glob filter" },
+                limit: { type: "number", default: 50 },
+                regex: { type: "boolean", default: true }
+              },
+              required: ["pattern", "path"]
+            }
+          },
+          {
+            name: "get_symbol_docs",
+            description: "Get JSDoc/TSDoc for a specific symbol.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                symbol: { type: "string", description: "Symbol name" },
+                path: { type: "string", description: "Project root" }
+              },
+              required: ["symbol", "path"]
+            }
+          },
+          {
+            name: "build_symbol_index",
+            description: "Warm the symbol index for faster navigation.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                path: { type: "string", description: "Project root to index" }
+              },
+              required: ["path"]
+            }
+          }
+        ]
+      };
+    });
+    this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        switch (name) {
+          case "resolve_definition": {
+            const { symbol, path: path4 } = ResolveDefinitionSchema.parse(args);
+            const results = await resolveDefinition(symbol, path4);
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(results, null, 2) }
+              ]
+            };
+          }
+          case "find_references": {
+            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) }
+              ]
+            };
+          }
+          case "find_implementations": {
+            const { symbol, path: path4, limit, offset } = FindImplementationsSchema.parse(args);
+            const results = await findImplementations(
+              symbol,
+              path4,
+              limit,
+              offset
+            );
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(results, null, 2) }
+              ]
+            };
+          }
+          case "get_file_structure": {
+            const { file } = GetFileStructureSchema.parse(args);
+            const structure = await getFileStructure(file);
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(structure, null, 2) }
+              ]
+            };
+          }
+          case "search_code": {
+            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) }
+              ]
+            };
+          }
+          case "get_symbol_docs": {
+            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: path4 } = BuildSymbolIndexSchema.parse(args);
+            const stats = await buildSymbolIndex(path4);
+            return {
+              content: [{ type: "text", text: JSON.stringify(stats, null, 2) }]
+            };
+          }
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    });
+  }
+  async run() {
+    const transport = new import_stdio.StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("AST Explorer MCP Server started");
+  }
+};
+var server = new ASTExplorerServer();
+server.run().catch((error) => {
+  console.error("Fatal error starting AST Explorer MCP Server:", error);
+  process.exit(1);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASTExplorerServer
+});
+//# sourceMappingURL=index.cjs.map