typegraph-mcp 0.9.0 → 0.9.2

package/dist/server.js

@@ -0,0 +1,1479 @@
+
+// server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// tsserver-client.ts
+import { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import { createRequire } from "module";
+var log = (...args) => console.error("[typegraph/tsserver]", ...args);
+var REQUEST_TIMEOUT_MS = 1e4;
+var TsServerClient = class {
+  constructor(projectRoot2, tsconfigPath2 = "./tsconfig.json") {
+    this.projectRoot = projectRoot2;
+    this.tsconfigPath = tsconfigPath2;
+  }
+  child = null;
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  openFiles = /* @__PURE__ */ new Set();
+  buffer = Buffer.alloc(0);
+  ready = false;
+  shuttingDown = false;
+  restartCount = 0;
+  maxRestarts = 3;
+  // ─── Path Resolution ────────────────────────────────────────────────────
+  resolvePath(file) {
+    return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
+  }
+  relativePath(file) {
+    return path.relative(this.projectRoot, file);
+  }
+  /** Read a line from a file (1-based line number). Returns trimmed content. */
+  readLine(file, line) {
+    try {
+      const absPath2 = this.resolvePath(file);
+      const content = fs.readFileSync(absPath2, "utf-8");
+      const lines = content.split("\n");
+      return lines[line - 1]?.trim() ?? "";
+    } catch {
+      return "";
+    }
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────
+  async start() {
+    if (this.child) return;
+    const require2 = createRequire(path.resolve(this.projectRoot, "package.json"));
+    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    log(`Spawning tsserver: ${tsserverPath}`);
+    log(`Project root: ${this.projectRoot}`);
+    log(`tsconfig: ${this.tsconfigPath}`);
+    this.child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+      cwd: this.projectRoot,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, TSS_LOG: void 0 }
+    });
+    this.child.stdout.on("data", (chunk) => this.onData(chunk));
+    this.child.stderr.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) log(`[stderr] ${text}`);
+    });
+    this.child.on("close", (code) => {
+      log(`tsserver exited with code ${code}`);
+      this.child = null;
+      this.rejectAllPending(new Error(`tsserver exited with code ${code}`));
+      this.tryRestart();
+    });
+    this.child.on("error", (err) => {
+      log(`tsserver error: ${err.message}`);
+      this.rejectAllPending(err);
+    });
+    await this.sendRequest("configure", {
+      preferences: {
+        disableSuggestions: true
+      }
+    });
+    const warmStart = performance.now();
+    const tsconfigAbs = this.resolvePath(this.tsconfigPath);
+    if (fs.existsSync(tsconfigAbs)) {
+      await this.sendRequest("compilerOptionsForInferredProjects", {
+        options: { allowJs: true, checkJs: false }
+      });
+    }
+    this.ready = true;
+    log(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
+  }
+  shutdown() {
+    this.shuttingDown = true;
+    if (this.child) {
+      this.child.kill("SIGTERM");
+      this.child = null;
+    }
+    this.rejectAllPending(new Error("Client shutdown"));
+  }
+  tryRestart() {
+    if (this.shuttingDown) return;
+    if (this.restartCount >= this.maxRestarts) {
+      log(`Max restarts (${this.maxRestarts}) reached, not restarting`);
+      return;
+    }
+    this.restartCount++;
+    log(`Restarting tsserver (attempt ${this.restartCount})...`);
+    this.buffer = Buffer.alloc(0);
+    const filesToReopen = [...this.openFiles];
+    this.openFiles.clear();
+    this.start().then(async () => {
+      for (const file of filesToReopen) {
+        await this.ensureOpen(file).catch(() => {
+        });
+      }
+    });
+  }
+  rejectAllPending(err) {
+    for (const [seq, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+  // ─── Protocol: Parsing ──────────────────────────────────────────────────
+  onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    this.processBuffer();
+  }
+  processBuffer() {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+      const header = this.buffer.subarray(0, headerEnd).toString("utf-8");
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.subarray(headerEnd + 4);
+        continue;
+      }
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      if (this.buffer.length < bodyStart + contentLength) {
+        return;
+      }
+      const bodyBytes = this.buffer.subarray(bodyStart, bodyStart + contentLength);
+      this.buffer = this.buffer.subarray(bodyStart + contentLength);
+      try {
+        const message = JSON.parse(bodyBytes.toString("utf-8"));
+        this.onMessage(message);
+      } catch {
+        log("Failed to parse tsserver message");
+      }
+    }
+  }
+  onMessage(message) {
+    if (message.type === "response" && message.request_seq !== void 0) {
+      const pending = this.pending.get(message.request_seq);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(message.request_seq);
+        if (message.success) {
+          pending.resolve(message.body);
+        } else {
+          pending.reject(
+            new Error(`tsserver ${pending.command} failed: ${message.message ?? "unknown error"}`)
+          );
+        }
+      }
+    }
+  }
+  // ─── Protocol: Sending ──────────────────────────────────────────────────
+  sendRequest(command, args) {
+    if (!this.child?.stdin?.writable) {
+      return Promise.reject(new Error("tsserver not running"));
+    }
+    const seq = ++this.seq;
+    const request = {
+      seq,
+      type: "request",
+      command,
+      arguments: args
+    };
+    return new Promise((resolve6, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`tsserver ${command} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(seq, { resolve: resolve6, reject, timer, command });
+      this.child.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+  // Fire-and-forget — for commands like `open` that may not send a response
+  sendNotification(command, args) {
+    if (!this.child?.stdin?.writable) return;
+    const seq = ++this.seq;
+    const request = { seq, type: "request", command, arguments: args };
+    this.child.stdin.write(JSON.stringify(request) + "\n");
+  }
+  // ─── File Management ───────────────────────────────────────────────────
+  async ensureOpen(file) {
+    const absPath2 = this.resolvePath(file);
+    if (this.openFiles.has(absPath2)) return;
+    this.openFiles.add(absPath2);
+    this.sendNotification("open", { file: absPath2 });
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  // ─── Public API ────────────────────────────────────────────────────────
+  async definition(file, line, offset) {
+    const absPath2 = this.resolvePath(file);
+    await this.ensureOpen(absPath2);
+    const body = await this.sendRequest("definition", {
+      file: absPath2,
+      line,
+      offset
+    });
+    if (!body || !Array.isArray(body)) return [];
+    return body.map((d) => ({
+      ...d,
+      file: this.relativePath(d.file)
+    }));
+  }
+  async references(file, line, offset) {
+    const absPath2 = this.resolvePath(file);
+    await this.ensureOpen(absPath2);
+    const body = await this.sendRequest("references", {
+      file: absPath2,
+      line,
+      offset
+    });
+    if (!body?.refs) return [];
+    return body.refs.map((r) => ({
+      ...r,
+      file: this.relativePath(r.file)
+    }));
+  }
+  async quickinfo(file, line, offset) {
+    const absPath2 = this.resolvePath(file);
+    await this.ensureOpen(absPath2);
+    try {
+      const body = await this.sendRequest("quickinfo", {
+        file: absPath2,
+        line,
+        offset
+      });
+      return body ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async navto(searchValue, maxResults = 10, file) {
+    if (file) await this.ensureOpen(file);
+    const args = {
+      searchValue,
+      maxResultCount: maxResults
+    };
+    if (file) args["file"] = this.resolvePath(file);
+    const body = await this.sendRequest("navto", args);
+    if (!body || !Array.isArray(body)) return [];
+    return body.map((item) => ({
+      ...item,
+      file: this.relativePath(item.file)
+    }));
+  }
+  async navbar(file) {
+    const absPath2 = this.resolvePath(file);
+    await this.ensureOpen(absPath2);
+    const body = await this.sendRequest("navbar", {
+      file: absPath2
+    });
+    return body ?? [];
+  }
+};
+
+// module-graph.ts
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var log2 = (...args) => console.error("[typegraph/graph]", ...args);
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".wrangler",
+  ".mf",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+function discoverFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && dir !== rootDir) continue;
+        walk(path2.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (SKIP_FILES.has(name)) continue;
+        if (name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts")) continue;
+        const ext = path2.extname(name);
+        if (TS_EXTENSIONS.has(ext)) {
+          files.push(path2.join(dir, name));
+        }
+      }
+    }
+  }
+  walk(rootDir);
+  return files;
+}
+function parseFileImports(filePath, source) {
+  const result = parseSync(filePath, source);
+  const imports = [];
+  for (const imp of result.module.staticImports) {
+    const specifier = imp.moduleRequest.value;
+    const names = [];
+    let allTypeOnly = true;
+    for (const entry of imp.entries) {
+      const kind = entry.importName.kind;
+      const name = kind === "Default" ? "default" : kind === "All" || kind === "AllButDefault" || kind === "NamespaceObject" ? "*" : entry.importName.name ?? entry.localName.value;
+      names.push(name);
+      if (!entry.isType) allTypeOnly = false;
+    }
+    if (names.length === 0) {
+      imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: false });
+    } else {
+      imports.push({ specifier, names, isTypeOnly: allTypeOnly, isDynamic: false });
+    }
+  }
+  for (const exp of result.module.staticExports) {
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (!moduleRequest) continue;
+      const specifier = moduleRequest.value;
+      const entryKind = entry.importName.kind;
+      const name = entryKind === "AllButDefault" || entryKind === "All" || entryKind === "NamespaceObject" ? "*" : entry.importName.name ?? "*";
+      const existing = imports.find((i) => i.specifier === specifier && !i.isDynamic);
+      if (existing) {
+        if (!existing.names.includes(name)) existing.names.push(name);
+      } else {
+        imports.push({ specifier, names: [name], isTypeOnly: false, isDynamic: false });
+      }
+    }
+  }
+  for (const di of result.module.dynamicImports) {
+    if (di.moduleRequest) {
+      const sliced = source.slice(di.moduleRequest.start, di.moduleRequest.end);
+      if (sliced.startsWith("'") || sliced.startsWith('"')) {
+        const specifier = sliced.slice(1, -1);
+        imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: true });
+      }
+    }
+  }
+  return imports;
+}
+var SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+function distToSource(resolvedPath, projectRoot2) {
+  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
+  const rel = path2.relative(projectRoot2, resolvedPath);
+  const distIdx = rel.indexOf("dist" + path2.sep);
+  if (distIdx === -1) return resolvedPath;
+  const prefix = rel.slice(0, distIdx);
+  const afterDist = rel.slice(distIdx + 5);
+  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, "src", withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path2.resolve(projectRoot2, prefix, "src", dirPath + ext);
+      if (fs2.existsSync(candidate)) return candidate;
+    }
+  }
+  return resolvedPath;
+}
+function resolveImport(resolver, fromDir, specifier, projectRoot2) {
+  try {
+    const result = resolver.sync(fromDir, specifier);
+    if (result.path && !result.path.includes("node_modules")) {
+      const mapped = distToSource(result.path, projectRoot2);
+      const ext = path2.extname(mapped);
+      if (!TS_EXTENSIONS.has(ext)) return null;
+      if (SKIP_FILES.has(path2.basename(mapped))) return null;
+      return mapped;
+    }
+  } catch {
+  }
+  return null;
+}
+function createResolver(projectRoot2, tsconfigPath2) {
+  return new ResolverFactory({
+    tsconfig: {
+      configFile: path2.resolve(projectRoot2, tsconfigPath2),
+      references: "auto"
+    },
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    extensionAlias: {
+      ".js": [".ts", ".tsx", ".js"],
+      ".jsx": [".tsx", ".jsx"],
+      ".mjs": [".mts", ".mjs"],
+      ".cjs": [".cts", ".cjs"]
+    },
+    conditionNames: ["import", "require"],
+    mainFields: ["module", "main"]
+  });
+}
+function buildForwardEdges(files, resolver, projectRoot2) {
+  const forward = /* @__PURE__ */ new Map();
+  const parseFailures = [];
+  for (const filePath of files) {
+    let source;
+    try {
+      source = fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    let rawImports;
+    try {
+      rawImports = parseFileImports(filePath, source);
+    } catch (err) {
+      parseFailures.push(filePath);
+      continue;
+    }
+    const edges = [];
+    const fromDir = path2.dirname(filePath);
+    for (const raw of rawImports) {
+      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+      if (target) {
+        edges.push({
+          target,
+          specifiers: raw.names,
+          isTypeOnly: raw.isTypeOnly,
+          isDynamic: raw.isDynamic
+        });
+      }
+    }
+    forward.set(filePath, edges);
+  }
+  return { forward, parseFailures };
+}
+function buildReverseMap(forward) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [source, edges] of forward) {
+    for (const edge of edges) {
+      let revEdges = reverse.get(edge.target);
+      if (!revEdges) {
+        revEdges = [];
+        reverse.set(edge.target, revEdges);
+      }
+      revEdges.push({
+        target: source,
+        // reverse: the "target" is the file that imports
+        specifiers: edge.specifiers,
+        isTypeOnly: edge.isTypeOnly,
+        isDynamic: edge.isDynamic
+      });
+    }
+  }
+  return reverse;
+}
+async function buildGraph(projectRoot2, tsconfigPath2) {
+  const startTime = performance.now();
+  const resolver = createResolver(projectRoot2, tsconfigPath2);
+  const fileList = discoverFiles(projectRoot2);
+  log2(`Discovered ${fileList.length} source files`);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot2);
+  const reverse = buildReverseMap(forward);
+  const files = new Set(fileList);
+  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
+  const elapsed = (performance.now() - startTime).toFixed(0);
+  log2(`Graph built: ${files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+  if (parseFailures.length > 0) {
+    log2(`Parse failures: ${parseFailures.length} files`);
+  }
+  return {
+    graph: { forward, reverse, files },
+    resolver
+  };
+}
+function updateFile(graph, filePath, resolver, projectRoot2) {
+  const oldEdges = graph.forward.get(filePath) ?? [];
+  for (const edge of oldEdges) {
+    const revEdges = graph.reverse.get(edge.target);
+    if (revEdges) {
+      const idx = revEdges.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges.splice(idx, 1);
+      if (revEdges.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  let source;
+  try {
+    source = fs2.readFileSync(filePath, "utf-8");
+  } catch {
+    removeFile(graph, filePath);
+    return;
+  }
+  let rawImports;
+  try {
+    rawImports = parseFileImports(filePath, source);
+  } catch {
+    log2(`Parse error on update: ${filePath}`);
+    graph.forward.set(filePath, []);
+    return;
+  }
+  const fromDir = path2.dirname(filePath);
+  const newEdges = [];
+  for (const raw of rawImports) {
+    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+    if (target) {
+      newEdges.push({
+        target,
+        specifiers: raw.names,
+        isTypeOnly: raw.isTypeOnly,
+        isDynamic: raw.isDynamic
+      });
+    }
+  }
+  graph.forward.set(filePath, newEdges);
+  graph.files.add(filePath);
+  for (const edge of newEdges) {
+    let revEdges = graph.reverse.get(edge.target);
+    if (!revEdges) {
+      revEdges = [];
+      graph.reverse.set(edge.target, revEdges);
+    }
+    revEdges.push({
+      target: filePath,
+      specifiers: edge.specifiers,
+      isTypeOnly: edge.isTypeOnly,
+      isDynamic: edge.isDynamic
+    });
+  }
+}
+function removeFile(graph, filePath) {
+  const edges = graph.forward.get(filePath) ?? [];
+  for (const edge of edges) {
+    const revEdges2 = graph.reverse.get(edge.target);
+    if (revEdges2) {
+      const idx = revEdges2.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges2.splice(idx, 1);
+      if (revEdges2.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  const revEdges = graph.reverse.get(filePath) ?? [];
+  for (const revEdge of revEdges) {
+    const fwdEdges = graph.forward.get(revEdge.target);
+    if (fwdEdges) {
+      const idx = fwdEdges.findIndex((e) => e.target === filePath);
+      if (idx !== -1) fwdEdges.splice(idx, 1);
+    }
+  }
+  graph.forward.delete(filePath);
+  graph.reverse.delete(filePath);
+  graph.files.delete(filePath);
+}
+function startWatcher(projectRoot2, graph, resolver) {
+  try {
+    const watcher = fs2.watch(
+      projectRoot2,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (!filename) return;
+        const ext = path2.extname(filename);
+        if (!TS_EXTENSIONS.has(ext)) return;
+        const parts = filename.split(path2.sep);
+        if (parts.some((p) => SKIP_DIRS.has(p))) return;
+        if (SKIP_FILES.has(path2.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath2 = path2.resolve(projectRoot2, filename);
+        if (fs2.existsSync(absPath2)) {
+          updateFile(graph, absPath2, resolver, projectRoot2);
+        } else {
+          removeFile(graph, absPath2);
+        }
+      }
+    );
+    process.on("SIGINT", () => watcher.close());
+    process.on("SIGTERM", () => watcher.close());
+    log2("File watcher started");
+  } catch (err) {
+    log2("Failed to start file watcher:", err);
+  }
+}
+
+// graph-queries.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function shouldIncludeEdge(edge, includeTypeOnly) {
+  if (!includeTypeOnly && edge.isTypeOnly) return false;
+  return true;
+}
+function dependencyTree(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  return { root: file, nodes: result.length, files: result };
+}
+var packageNameCache = /* @__PURE__ */ new Map();
+function findPackageName(filePath) {
+  let dir = path3.dirname(filePath);
+  while (dir !== path3.dirname(dir)) {
+    if (packageNameCache.has(dir)) return packageNameCache.get(dir);
+    const pkgJsonPath = path3.join(dir, "package.json");
+    try {
+      if (fs3.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkg.name ?? path3.basename(dir);
+        packageNameCache.set(dir, name);
+        return name;
+      }
+    } catch {
+    }
+    dir = path3.dirname(dir);
+  }
+  return "<root>";
+}
+function dependents(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let directCount = 0;
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.reverse.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        if (currentDepth === 0) directCount++;
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  const byPackage = {};
+  for (const f of result) {
+    const pkgName = findPackageName(f);
+    if (!byPackage[pkgName]) byPackage[pkgName] = [];
+    byPackage[pkgName].push(f);
+  }
+  return { root: file, nodes: result.length, directCount, files: result, byPackage };
+}
+function importCycles(graph, opts = {}) {
+  const { file, package: pkgDir } = opts;
+  let index = 0;
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const indices = /* @__PURE__ */ new Map();
+  const lowlinks = /* @__PURE__ */ new Map();
+  const sccs = [];
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    const edges = graph.forward.get(v) ?? [];
+    for (const edge of edges) {
+      const w = edge.target;
+      if (!graph.files.has(w)) continue;
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) {
+        sccs.push(scc);
+      }
+    }
+  }
+  for (const f of graph.files) {
+    if (!indices.has(f)) {
+      strongconnect(f);
+    }
+  }
+  let cycles = sccs;
+  if (file) {
+    cycles = cycles.filter((scc) => scc.includes(file));
+  }
+  if (pkgDir) {
+    const absPkgDir = path3.resolve(pkgDir);
+    cycles = cycles.filter(
+      (scc) => scc.every((f) => f.startsWith(absPkgDir))
+    );
+  }
+  return { count: cycles.length, cycles };
+}
+function shortestPath(graph, from, to, opts = {}) {
+  const { includeTypeOnly = false } = opts;
+  if (from === to) {
+    return { path: [from], hops: 0, chain: [{ file: from, imports: [] }] };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  visited.add(from);
+  let frontier = [from];
+  while (frontier.length > 0) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        parent.set(edge.target, { from: f, specifiers: edge.specifiers });
+        if (edge.target === to) {
+          const filePath = [to];
+          let current = to;
+          while (parent.has(current)) {
+            current = parent.get(current).from;
+            filePath.unshift(current);
+          }
+          const chain = [];
+          for (let i = 0; i < filePath.length; i++) {
+            const p = parent.get(filePath[i]);
+            chain.push({
+              file: filePath[i],
+              imports: p?.specifiers ?? []
+            });
+          }
+          return { path: filePath, hops: filePath.length - 1, chain };
+        }
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return { path: null, hops: -1, chain: [] };
+}
+function subgraph(graph, files, opts = {}) {
+  const { depth = 1, direction = "both" } = opts;
+  const visited = new Set(files);
+  let frontier = [...files];
+  for (let d = 0; d < depth && frontier.length > 0; d++) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      if (direction === "imports" || direction === "both") {
+        for (const edge of graph.forward.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+      if (direction === "dependents" || direction === "both") {
+        for (const edge of graph.reverse.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  const nodes = [...visited];
+  const edges = [];
+  for (const f of nodes) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (visited.has(edge.target)) {
+        edges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers,
+          isTypeOnly: edge.isTypeOnly
+        });
+      }
+    }
+  }
+  return { nodes, edges, stats: { nodeCount: nodes.length, edgeCount: edges.length } };
+}
+function moduleBoundary(graph, files) {
+  const fileSet = new Set(files);
+  let internalEdges = 0;
+  const incomingEdges = [];
+  const outgoingEdges = [];
+  const outgoingTargets = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (fileSet.has(edge.target)) {
+        internalEdges++;
+      } else {
+        outgoingEdges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers
+        });
+        outgoingTargets.add(edge.target);
+      }
+    }
+  }
+  for (const f of files) {
+    for (const edge of graph.reverse.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        incomingEdges.push({
+          from: edge.target,
+          to: f,
+          specifiers: edge.specifiers
+        });
+      }
+    }
+  }
+  const depCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        depCounts.set(edge.target, (depCounts.get(edge.target) ?? 0) + 1);
+      }
+    }
+  }
+  const sharedDependencies = [...depCounts.entries()].filter(([, count]) => count > 1).map(([dep]) => dep);
+  const total = internalEdges + incomingEdges.length + outgoingEdges.length;
+  const isolationScore = total === 0 ? 1 : internalEdges / total;
+  return {
+    internalEdges,
+    incomingEdges,
+    outgoingEdges,
+    sharedDependencies,
+    isolationScore
+  };
+}
+
+// server.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// config.ts
+import * as path4 from "path";
+function resolveConfig(toolDir) {
+  const cwd = process.cwd();
+  const projectRoot2 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path4.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path4.basename(path4.dirname(toolDir)) === "plugins" ? path4.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath2 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot2 + path4.sep);
+  const toolRelPath = toolIsEmbedded ? path4.relative(projectRoot2, toolDir) : toolDir;
+  return { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath };
+}
+
+// server.ts
+var { projectRoot, tsconfigPath } = resolveConfig(import.meta.dirname);
+var log3 = (...args) => console.error("[typegraph]", ...args);
+var client = new TsServerClient(projectRoot, tsconfigPath);
+var moduleGraph;
+var mcpServer = new McpServer({
+  name: "typegraph",
+  version: "1.0.0"
+});
+function readPreview(file, line) {
+  try {
+    const absPath2 = client.resolvePath(file);
+    const content = fs4.readFileSync(absPath2, "utf-8");
+    return content.split("\n")[line - 1]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+function findInNavBar(items, symbol) {
+  for (const item of items) {
+    if (item.text === symbol && item.spans.length > 0) {
+      const span = item.spans[0];
+      return { line: span.start.line, offset: span.start.offset, kind: item.kind };
+    }
+    if (item.childItems?.length > 0) {
+      const found = findInNavBar(item.childItems, symbol);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+async function resolveSymbol(file, symbol) {
+  const bar = await client.navbar(file);
+  const found = findInNavBar(bar, symbol);
+  if (found) {
+    return {
+      file,
+      line: found.line,
+      column: found.offset,
+      kind: found.kind,
+      preview: readPreview(file, found.line)
+    };
+  }
+  const items = await client.navto(symbol, 10, file);
+  const inFile = items.find((i) => i.name === symbol && i.file === file);
+  const best = inFile ?? items.find((i) => i.name === symbol) ?? items[0];
+  if (best) {
+    return {
+      file: best.file,
+      line: best.start.line,
+      column: best.start.offset,
+      kind: best.kind,
+      preview: readPreview(best.file, best.start.line)
+    };
+  }
+  return null;
+}
+var locationOrSymbol = {
+  file: z.string().describe("File path (relative to project root or absolute)"),
+  line: z.number().int().positive().optional().describe("Line number (1-based). Required if symbol is not provided."),
+  column: z.number().int().positive().optional().describe("Column/offset (1-based). Required if symbol is not provided."),
+  symbol: z.string().optional().describe("Symbol name to find. Alternative to line+column.")
+};
+async function resolveParams(params) {
+  if (params.line !== void 0 && params.column !== void 0) {
+    return { file: params.file, line: params.line, column: params.column };
+  }
+  if (params.symbol) {
+    const resolved = await resolveSymbol(params.file, params.symbol);
+    if (!resolved) {
+      return { error: `Symbol "${params.symbol}" not found in ${params.file}` };
+    }
+    return { file: resolved.file, line: resolved.line, column: resolved.column };
+  }
+  return { error: "Either line+column or symbol must be provided" };
+}
+mcpServer.tool(
+  "ts_find_symbol",
+  "Find a symbol's location in a file by name. Entry point for navigating without exact coordinates.",
+  {
+    file: z.string().describe("File to search in (relative or absolute path)"),
+    symbol: z.string().describe("Symbol name to find")
+  },
+  async ({ file, symbol }) => {
+    const result = await resolveSymbol(file, symbol);
+    if (!result) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Symbol "${symbol}" not found in ${file}` })
+          }
+        ]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_definition",
+  "Go to definition. Resolves through imports, re-exports, barrel files, interfaces, generics. Provide either line+column coordinates or a symbol name.",
+  locationOrSymbol,
+  async (params) => {
+    const loc = await resolveParams(params);
+    if ("error" in loc) {
+      return { content: [{ type: "text", text: JSON.stringify(loc) }] };
+    }
+    const defs = await client.definition(loc.file, loc.line, loc.column);
+    if (defs.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ definitions: [], source: readPreview(loc.file, loc.line) })
+          }
+        ]
+      };
+    }
+    const results = defs.map((d) => ({
+      file: d.file,
+      line: d.start.line,
+      column: d.start.offset,
+      preview: readPreview(d.file, d.start.line)
+    }));
+    return {
+      content: [{ type: "text", text: JSON.stringify({ definitions: results }) }]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_references",
+  "Find all references to a symbol. Returns semantic code references only (not string matches). Provide either line+column or symbol name.",
+  locationOrSymbol,
+  async (params) => {
+    const loc = await resolveParams(params);
+    if ("error" in loc) {
+      return { content: [{ type: "text", text: JSON.stringify(loc) }] };
+    }
+    const refs = await client.references(loc.file, loc.line, loc.column);
+    const results = refs.map((r) => ({
+      file: r.file,
+      line: r.start.line,
+      column: r.start.offset,
+      preview: r.lineText.trim(),
+      isDefinition: r.isDefinition
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ references: results, count: results.length })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_type_info",
+  "Get the TypeScript type and documentation for a symbol. Returns the same info you see when hovering in VS Code. Provide either line+column or symbol name.",
+  locationOrSymbol,
+  async (params) => {
+    const loc = await resolveParams(params);
+    if ("error" in loc) {
+      return { content: [{ type: "text", text: JSON.stringify(loc) }] };
+    }
+    const info = await client.quickinfo(loc.file, loc.line, loc.column);
+    if (!info) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              type: null,
+              documentation: null,
+              source: readPreview(loc.file, loc.line)
+            })
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            type: info.displayString,
+            documentation: info.documentation || null,
+            kind: info.kind
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_navigate_to",
+  "Search for a symbol across the entire project without knowing which file it's in. Returns matching declarations. Optionally provide a file hint to also search that file's navbar (useful for object literal keys like RPC handlers that navto doesn't index).",
+  {
+    symbol: z.string().describe("Symbol name to search for"),
+    file: z.string().optional().describe(
+      "Optional file to also search via navbar (covers object literal keys not indexed by navto)"
+    ),
+    maxResults: z.number().int().positive().optional().default(10).describe("Maximum results (default 10)")
+  },
+  async ({ symbol, file, maxResults }) => {
+    const items = await client.navto(symbol, maxResults);
+    const results = items.map((item) => ({
+      file: item.file,
+      line: item.start.line,
+      column: item.start.offset,
+      kind: item.kind,
+      containerName: item.containerName,
+      matchKind: item.matchKind
+    }));
+    if (file) {
+      const navbarHit = await resolveSymbol(file, symbol);
+      if (navbarHit) {
+        const alreadyFound = results.some(
+          (r) => r.file === navbarHit.file && r.line === navbarHit.line
+        );
+        if (!alreadyFound) {
+          results.unshift({
+            file: navbarHit.file,
+            line: navbarHit.line,
+            column: navbarHit.column,
+            kind: navbarHit.kind,
+            containerName: "",
+            matchKind: "navbar"
+          });
+        }
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ results, count: results.length })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_trace_chain",
+  "Automatically follow go-to-definition hops from a symbol, building a call chain from entry point to implementation. Stops when it reaches the bottom or a cycle.",
+  {
+    file: z.string().describe("Starting file"),
+    symbol: z.string().describe("Starting symbol name"),
+    maxHops: z.number().int().positive().optional().default(5).describe("Maximum hops to follow (default 5)")
+  },
+  async ({ file, symbol, maxHops }) => {
+    const start = await resolveSymbol(file, symbol);
+    if (!start) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Symbol "${symbol}" not found in ${file}` })
+          }
+        ]
+      };
+    }
+    const chain = [
+      {
+        file: start.file,
+        line: start.line,
+        column: start.column,
+        preview: start.preview
+      }
+    ];
+    let current = { file: start.file, line: start.line, offset: start.column };
+    for (let i = 0; i < maxHops; i++) {
+      const defs = await client.definition(current.file, current.line, current.offset);
+      if (defs.length === 0) break;
+      const def = defs[0];
+      if (def.file === current.file && def.start.line === current.line) break;
+      if (def.file.includes("node_modules")) break;
+      const preview = readPreview(def.file, def.start.line);
+      chain.push({
+        file: def.file,
+        line: def.start.line,
+        column: def.start.offset,
+        preview
+      });
+      current = { file: def.file, line: def.start.line, offset: def.start.offset };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ chain, hops: chain.length - 1 })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_blast_radius",
+  "Analyze the impact of changing a symbol. Finds all references, filters to usage sites, and reports affected files.",
+  {
+    file: z.string().describe("File containing the symbol"),
+    symbol: z.string().describe("Symbol to analyze")
+  },
+  async ({ file, symbol }) => {
+    const start = await resolveSymbol(file, symbol);
+    if (!start) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `Symbol "${symbol}" not found in ${file}` })
+          }
+        ]
+      };
+    }
+    const refs = await client.references(start.file, start.line, start.column);
+    const callers = refs.filter((r) => !r.isDefinition);
+    const filesAffected = [...new Set(callers.map((r) => r.file))];
+    const callerList = callers.map((r) => ({
+      file: r.file,
+      line: r.start.line,
+      preview: r.lineText.trim()
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            directCallers: callers.length,
+            filesAffected,
+            callers: callerList
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_module_exports",
+  "List all exported symbols from a module with their resolved types. Gives an at-a-glance understanding of what a file provides.",
+  {
+    file: z.string().describe("File to inspect")
+  },
+  async ({ file }) => {
+    const bar = await client.navbar(file);
+    if (bar.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: `No symbols found in ${file}` })
+          }
+        ]
+      };
+    }
+    const moduleItem = bar.find((item) => item.kind === "module");
+    const topItems = moduleItem?.childItems ?? bar;
+    const exportKinds = /* @__PURE__ */ new Set([
+      "function",
+      "const",
+      "class",
+      "interface",
+      "type",
+      "enum",
+      "var",
+      "let",
+      "method"
+    ]);
+    const candidates = topItems.filter((item) => exportKinds.has(item.kind));
+    const exports = [];
+    for (const item of candidates) {
+      if (!item.spans[0]) continue;
+      const span = item.spans[0];
+      const info = await client.quickinfo(file, span.start.line, span.start.offset);
+      exports.push({
+        symbol: item.text,
+        kind: item.kind,
+        line: span.start.line,
+        type: info?.displayString ?? null
+      });
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ file, exports, count: exports.length })
+        }
+      ]
+    };
+  }
+);
+function relPath(absPath2) {
+  return path5.relative(projectRoot, absPath2);
+}
+function absPath(file) {
+  return path5.isAbsolute(file) ? file : path5.resolve(projectRoot, file);
+}
+mcpServer.tool(
+  "ts_dependency_tree",
+  "Get the transitive dependency tree (imports) of a file. Shows what a file depends on, directly and transitively.",
+  {
+    file: z.string().describe("File to analyze (relative or absolute path)"),
+    depth: z.number().int().positive().optional().describe("Max traversal depth (default: unlimited)"),
+    includeTypeOnly: z.boolean().optional().default(false).describe("Include type-only imports (default: false)")
+  },
+  async ({ file, depth, includeTypeOnly }) => {
+    const result = dependencyTree(moduleGraph, absPath(file), { depth, includeTypeOnly });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            root: relPath(result.root),
+            nodes: result.nodes,
+            files: result.files.map(relPath)
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_dependents",
+  "Find all files that depend on (import) a given file, directly and transitively. Groups results by package.",
+  {
+    file: z.string().describe("File to analyze (relative or absolute path)"),
+    depth: z.number().int().positive().optional().describe("Max traversal depth (default: unlimited)"),
+    includeTypeOnly: z.boolean().optional().default(false).describe("Include type-only imports (default: false)")
+  },
+  async ({ file, depth, includeTypeOnly }) => {
+    const result = dependents(moduleGraph, absPath(file), { depth, includeTypeOnly });
+    const byPackageRel = {};
+    for (const [pkg, files] of Object.entries(result.byPackage)) {
+      byPackageRel[pkg] = files.map(relPath);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            root: relPath(result.root),
+            nodes: result.nodes,
+            directCount: result.directCount,
+            files: result.files.map(relPath),
+            byPackage: byPackageRel
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_import_cycles",
+  "Detect circular import dependencies in the project. Returns strongly connected components (cycles) in the import graph.",
+  {
+    file: z.string().optional().describe("Filter to cycles containing this file"),
+    package: z.string().optional().describe("Filter to cycles within this directory")
+  },
+  async ({ file, package: pkg }) => {
+    const result = importCycles(moduleGraph, {
+      file: file ? absPath(file) : void 0,
+      package: pkg ? absPath(pkg) : void 0
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            count: result.count,
+            cycles: result.cycles.map((cycle) => cycle.map(relPath))
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_shortest_path",
+  "Find the shortest import path between two files. Shows how one module reaches another through the import graph.",
+  {
+    from: z.string().describe("Source file (relative or absolute path)"),
+    to: z.string().describe("Target file (relative or absolute path)"),
+    includeTypeOnly: z.boolean().optional().default(false).describe("Include type-only imports (default: false)")
+  },
+  async ({ from, to, includeTypeOnly }) => {
+    const result = shortestPath(moduleGraph, absPath(from), absPath(to), { includeTypeOnly });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            path: result.path?.map(relPath) ?? null,
+            hops: result.hops,
+            chain: result.chain.map((c) => ({
+              file: relPath(c.file),
+              imports: c.imports
+            }))
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_subgraph",
+  "Extract a subgraph around seed files. Expands by depth hops in the specified direction (imports, dependents, or both).",
+  {
+    files: z.array(z.string()).describe("Seed files to expand from (relative or absolute paths)"),
+    depth: z.number().int().positive().optional().default(1).describe("Hops to expand (default: 1)"),
+    direction: z.enum(["imports", "dependents", "both"]).optional().default("both").describe("Direction to expand (default: both)")
+  },
+  async ({ files, depth, direction }) => {
+    const result = subgraph(moduleGraph, files.map(absPath), { depth, direction });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            nodes: result.nodes.map(relPath),
+            edges: result.edges.map((e) => ({
+              from: relPath(e.from),
+              to: relPath(e.to),
+              specifiers: e.specifiers,
+              isTypeOnly: e.isTypeOnly
+            })),
+            stats: result.stats
+          })
+        }
+      ]
+    };
+  }
+);
+mcpServer.tool(
+  "ts_module_boundary",
+  "Analyze the boundary of a set of files: incoming/outgoing edges, shared dependencies, and an isolation score. Useful for understanding module coupling.",
+  {
+    files: z.array(z.string()).describe("Files defining the module boundary (relative or absolute paths)")
+  },
+  async ({ files }) => {
+    const result = moduleBoundary(moduleGraph, files.map(absPath));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            internalEdges: result.internalEdges,
+            incomingEdges: result.incomingEdges.map((e) => ({
+              from: relPath(e.from),
+              to: relPath(e.to),
+              specifiers: e.specifiers
+            })),
+            outgoingEdges: result.outgoingEdges.map((e) => ({
+              from: relPath(e.from),
+              to: relPath(e.to),
+              specifiers: e.specifiers
+            })),
+            sharedDependencies: result.sharedDependencies.map(relPath),
+            isolationScore: Math.round(result.isolationScore * 1e3) / 1e3
+          })
+        }
+      ]
+    };
+  }
+);
+async function main() {
+  log3("Starting TypeGraph MCP server...");
+  log3(`Project root: ${projectRoot}`);
+  log3(`tsconfig: ${tsconfigPath}`);
+  const [, graphResult] = await Promise.all([
+    client.start(),
+    buildGraph(projectRoot, tsconfigPath)
+  ]);
+  moduleGraph = graphResult.graph;
+  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  log3("MCP server connected and ready");
+}
+process.on("SIGINT", () => {
+  log3("Shutting down...");
+  client.shutdown();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  client.shutdown();
+  process.exit(0);
+});
+main().catch((err) => {
+  log3("Fatal error:", err);
+  process.exit(1);
+});