typegraph-mcp 0.9.0 → 0.9.2

package/dist/cli.js

@@ -0,0 +1,2842 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// config.ts
+import * as path from "path";
+function resolveConfig(toolDir) {
+  const cwd = process.cwd();
+  const projectRoot2 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir)) === "plugins" ? path.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath2 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot2 + path.sep);
+  const toolRelPath = toolIsEmbedded ? path.relative(projectRoot2, toolDir) : toolDir;
+  return { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath };
+}
+var init_config = __esm({
+  "config.ts"() {
+  }
+});
+
+// check.ts
+var check_exports = {};
+__export(check_exports, {
+  main: () => main
+});
+import * as fs from "fs";
+import * as path2 from "path";
+import { createRequire } from "module";
+import { spawn } from "child_process";
+function findFirstTsFile(dir) {
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        return path2.join(dir, entry.name);
+      }
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
+        const found = findFirstTsFile(path2.join(dir, entry.name));
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function testTsserver(projectRoot2) {
+  return new Promise((resolve8) => {
+    let tsserverPath;
+    try {
+      const require2 = createRequire(path2.resolve(projectRoot2, "package.json"));
+      tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    } catch {
+      resolve8(false);
+      return;
+    }
+    const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+      cwd: projectRoot2,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve8(false);
+    }, 1e4);
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.includes('"success":true')) {
+        clearTimeout(timeout);
+        child.kill();
+        resolve8(true);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve8(false);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+    });
+    const request = JSON.stringify({
+      seq: 1,
+      type: "request",
+      command: "configure",
+      arguments: {
+        preferences: { disableSuggestions: true }
+      }
+    });
+    child.stdin.write(request + "\n");
+  });
+}
+async function main(configOverride) {
+  const { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  let passed = 0;
+  let failed = 0;
+  let warned = 0;
+  function pass(msg) {
+    console.log(`  \u2713 ${msg}`);
+    passed++;
+  }
+  function fail(msg, fix) {
+    console.log(`  \u2717 ${msg}`);
+    console.log(`    Fix: ${fix}`);
+    failed++;
+  }
+  function warn(msg, note2) {
+    console.log(`  ! ${msg}`);
+    console.log(`    ${note2}`);
+    warned++;
+  }
+  function skip(msg) {
+    console.log(`  - ${msg} (skipped)`);
+  }
+  console.log("");
+  console.log("typegraph-mcp Health Check");
+  console.log("=======================");
+  console.log(`Project root: ${projectRoot2}`);
+  console.log("");
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (nodeMajor >= 18) {
+    pass(`Node.js ${nodeVersion} (>= 18 required)`);
+  } else {
+    fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 18");
+  }
+  const tsxInRoot = fs.existsSync(path2.join(projectRoot2, "node_modules/.bin/tsx"));
+  const tsxInTool = fs.existsSync(path2.join(toolDir, "node_modules/.bin/tsx"));
+  if (tsxInRoot || tsxInTool) {
+    pass(`tsx available (in ${tsxInRoot ? "project" : "tool"} node_modules)`);
+  } else {
+    pass("tsx available (via npx/global)");
+  }
+  let tsVersion = null;
+  try {
+    const require2 = createRequire(path2.resolve(projectRoot2, "package.json"));
+    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    const tsPkgPath = path2.resolve(path2.dirname(tsserverPath), "..", "package.json");
+    const tsPkg = JSON.parse(fs.readFileSync(tsPkgPath, "utf-8"));
+    tsVersion = tsPkg.version;
+    pass(`TypeScript found (v${tsVersion})`);
+  } catch {
+    fail(
+      "TypeScript not found in project",
+      "Add `typescript` to devDependencies and run `pnpm install`"
+    );
+  }
+  const tsconfigAbs = path2.resolve(projectRoot2, tsconfigPath2);
+  if (fs.existsSync(tsconfigAbs)) {
+    pass(`tsconfig.json exists at ${tsconfigPath2}`);
+  } else {
+    fail(`tsconfig.json not found at ${tsconfigPath2}`, `Create a tsconfig.json at ${tsconfigPath2}`);
+  }
+  const pluginMcpPath = path2.join(toolDir, ".mcp.json");
+  const hasPluginMcp = fs.existsSync(pluginMcpPath) && fs.existsSync(path2.join(toolDir, ".claude-plugin/plugin.json"));
+  if (process.env.CLAUDE_PLUGIN_ROOT) {
+    pass("MCP registered via plugin (CLAUDE_PLUGIN_ROOT set)");
+  } else if (hasPluginMcp) {
+    pass("MCP registered via plugin (.mcp.json + .claude-plugin/ present)");
+  } else {
+    const mcpJsonPath = path2.resolve(projectRoot2, ".claude/mcp.json");
+    if (fs.existsSync(mcpJsonPath)) {
+      try {
+        const mcpJson = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
+        const tsNav = mcpJson?.mcpServers?.["typegraph"];
+        if (tsNav) {
+          const hasCommand = tsNav.command === "npx";
+          const hasArgs = Array.isArray(tsNav.args) && tsNav.args.includes("tsx");
+          const hasEnv = tsNav.env?.["TYPEGRAPH_PROJECT_ROOT"] && tsNav.env?.["TYPEGRAPH_TSCONFIG"];
+          if (hasCommand && hasArgs && hasEnv) {
+            pass("MCP registered in .claude/mcp.json");
+          } else {
+            const issues = [];
+            if (!hasCommand) issues.push("command should be 'npx'");
+            if (!hasArgs) issues.push("args should include 'tsx'");
+            if (!hasEnv) issues.push("env should set TYPEGRAPH_PROJECT_ROOT and TYPEGRAPH_TSCONFIG");
+            fail(
+              `MCP registration incomplete: ${issues.join(", ")}`,
+              "See README for correct .claude/mcp.json format"
+            );
+          }
+        } else {
+          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path2.resolve(toolDir, "server.ts");
+          fail(
+            "MCP entry 'typegraph' not found in .claude/mcp.json",
+            `Add to .claude/mcp.json:
+    {
+      "mcpServers": {
+        "typegraph": {
+          "command": "npx",
+          "args": ["tsx", "${serverPath}"],
+          "env": { "TYPEGRAPH_PROJECT_ROOT": ".", "TYPEGRAPH_TSCONFIG": "./tsconfig.json" }
+        }
+      }
+    }`
+          );
+        }
+      } catch (err) {
+        fail(
+          "Failed to parse .claude/mcp.json",
+          `Check JSON syntax: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      fail(".claude/mcp.json not found", `Create .claude/mcp.json with typegraph server registration`);
+    }
+  }
+  const toolNodeModules = path2.join(toolDir, "node_modules");
+  if (fs.existsSync(toolNodeModules)) {
+    const requiredPkgs = ["@modelcontextprotocol/sdk", "oxc-parser", "oxc-resolver", "zod"];
+    const missing = requiredPkgs.filter(
+      (pkg) => !fs.existsSync(path2.join(toolNodeModules, ...pkg.split("/")))
+    );
+    if (missing.length === 0) {
+      pass(`Dependencies installed (${requiredPkgs.length} packages)`);
+    } else {
+      fail(`Missing packages: ${missing.join(", ")}`, `Run \`cd ${toolRelPath} && pnpm install\``);
+    }
+  } else {
+    fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && pnpm install\``);
+  }
+  try {
+    const oxcParserReq = createRequire(path2.join(toolDir, "package.json"));
+    const { parseSync: parseSync2 } = await import(oxcParserReq.resolve("oxc-parser"));
+    const result = parseSync2("test.ts", 'import { x } from "./y";');
+    if (result.module?.staticImports?.length === 1) {
+      pass("oxc-parser working");
+    } else {
+      fail(
+        "oxc-parser parseSync returned unexpected result",
+        `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-parser failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+    );
+  }
+  try {
+    const oxcResolverReq = createRequire(path2.join(toolDir, "package.json"));
+    const { ResolverFactory: ResolverFactory2 } = await import(oxcResolverReq.resolve("oxc-resolver"));
+    const resolver = new ResolverFactory2({
+      tsconfig: { configFile: tsconfigAbs, references: "auto" },
+      extensions: [".ts", ".tsx", ".js"],
+      extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
+    });
+    let resolveOk = false;
+    const testFile = findFirstTsFile(projectRoot2);
+    if (testFile) {
+      const dir = path2.dirname(testFile);
+      const base = "./" + path2.basename(testFile);
+      const result = resolver.sync(dir, base);
+      resolveOk = !!result.path;
+    }
+    if (resolveOk) {
+      pass("oxc-resolver working");
+    } else {
+      warn(
+        "oxc-resolver loaded but couldn't resolve a test import",
+        "Check tsconfig.json is valid and has correct `references`"
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-resolver failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+    );
+  }
+  if (tsVersion) {
+    try {
+      const ok = await testTsserver(projectRoot2);
+      if (ok) {
+        pass("tsserver responds to configure");
+      } else {
+        fail(
+          "tsserver did not respond",
+          "Verify `typescript` is installed and tsconfig.json is valid"
+        );
+      }
+    } catch (err) {
+      fail(
+        `tsserver failed to start: ${err instanceof Error ? err.message : String(err)}`,
+        "Verify `typescript` is installed and tsconfig.json is valid"
+      );
+    }
+  } else {
+    skip("tsserver test (TypeScript not found)");
+  }
+  try {
+    const { buildGraph: buildGraph2 } = await import(path2.resolve(toolDir, "module-graph.js"));
+    const start2 = performance.now();
+    const { graph } = await buildGraph2(projectRoot2, tsconfigPath2);
+    const elapsed = (performance.now() - start2).toFixed(0);
+    const edgeCount = [...graph.forward.values()].reduce(
+      (s, e) => s + e.length,
+      0
+    );
+    if (graph.files.size > 0 && edgeCount > 0) {
+      pass(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+    } else if (graph.files.size > 0) {
+      warn(
+        `Module graph: ${graph.files.size} files but 0 edges`,
+        "Files found but no internal imports resolved. Check tsconfig references."
+      );
+    } else {
+      fail(
+        "Module graph: 0 files discovered",
+        "Check tsconfig.json includes source files and project root is correct"
+      );
+    }
+  } catch (err) {
+    fail(
+      `Module graph build failed: ${err instanceof Error ? err.message : String(err)}`,
+      "Check that oxc-parser and oxc-resolver are installed correctly"
+    );
+  }
+  if (toolIsEmbedded) {
+    const eslintConfigPath = path2.resolve(projectRoot2, "eslint.config.mjs");
+    if (fs.existsSync(eslintConfigPath)) {
+      const eslintContent = fs.readFileSync(eslintConfigPath, "utf-8");
+      const parentDir = path2.basename(path2.dirname(toolDir));
+      const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
+      const hasParentIgnore = parentIgnorePattern.test(eslintContent);
+      if (hasParentIgnore) {
+        pass(`ESLint ignores ${parentDir}/`);
+      } else {
+        fail(
+          `ESLint missing ignore: "${parentDir}/**"`,
+          `Add to the ignores array in eslint.config.mjs:
+    "${parentDir}/**",`
+        );
+      }
+    } else {
+      skip("ESLint config check (no eslint.config.mjs)");
+    }
+  } else {
+    skip("ESLint config check (typegraph-mcp is external to project)");
+  }
+  const gitignorePath = path2.resolve(projectRoot2, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    const lines = gitignoreContent.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+    const ignoresClaude = lines.some(
+      (l) => l === ".claude/" || l === ".claude" || l === "/.claude"
+    );
+    const parentDir = toolIsEmbedded ? path2.basename(path2.dirname(toolDir)) : null;
+    const ignoresParent = parentDir && lines.some((l) => l === `${parentDir}/` || l === parentDir || l === `/${parentDir}`);
+    if (!ignoresParent && !ignoresClaude) {
+      pass(".gitignore does not exclude .claude/" + (parentDir ? ` or ${parentDir}/` : ""));
+    } else {
+      const excluded = [];
+      if (ignoresParent) excluded.push(`${parentDir}/`);
+      if (ignoresClaude) excluded.push(".claude/");
+      warn(
+        `.gitignore excludes ${excluded.join(" and ")}`,
+        "Remove these entries so MCP config and tool source are tracked in git"
+      );
+    }
+  } else {
+    skip(".gitignore check (no .gitignore)");
+  }
+  console.log("");
+  const total = passed + failed;
+  if (failed === 0) {
+    console.log(
+      `${passed}/${total} checks passed` + (warned > 0 ? ` (${warned} warning${warned > 1 ? "s" : ""})` : "") + " -- typegraph-mcp is ready"
+    );
+  } else {
+    console.log(
+      `${passed}/${total} checks passed, ${failed} failed` + (warned > 0 ? `, ${warned} warning${warned > 1 ? "s" : ""}` : "") + " -- fix issues above"
+    );
+  }
+  console.log("");
+  return { passed, failed, warned };
+}
+var isDirectRun;
+var init_check = __esm({
+  "check.ts"() {
+    init_config();
+    isDirectRun = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url).pathname);
+    if (isDirectRun) {
+      main().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
+        console.error("Fatal error:", err);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// tsserver-client.ts
+import { spawn as spawn2 } from "child_process";
+import * as path3 from "path";
+import * as fs2 from "fs";
+import { createRequire as createRequire2 } from "module";
+var log, REQUEST_TIMEOUT_MS, TsServerClient;
+var init_tsserver_client = __esm({
+  "tsserver-client.ts"() {
+    log = (...args2) => console.error("[typegraph/tsserver]", ...args2);
+    REQUEST_TIMEOUT_MS = 1e4;
+    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 path3.isAbsolute(file) ? file : path3.resolve(this.projectRoot, file);
+      }
+      relativePath(file) {
+        return path3.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 = fs2.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 = createRequire2(path3.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 = spawn2("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 (fs2.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(command2, args2) {
+        if (!this.child?.stdin?.writable) {
+          return Promise.reject(new Error("tsserver not running"));
+        }
+        const seq = ++this.seq;
+        const request = {
+          seq,
+          type: "request",
+          command: command2,
+          arguments: args2
+        };
+        return new Promise((resolve8, reject) => {
+          const timer = setTimeout(() => {
+            this.pending.delete(seq);
+            reject(new Error(`tsserver ${command2} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+          }, REQUEST_TIMEOUT_MS);
+          this.pending.set(seq, { resolve: resolve8, reject, timer, command: command2 });
+          this.child.stdin.write(JSON.stringify(request) + "\n");
+        });
+      }
+      // Fire-and-forget — for commands like `open` that may not send a response
+      sendNotification(command2, args2) {
+        if (!this.child?.stdin?.writable) return;
+        const seq = ++this.seq;
+        const request = { seq, type: "request", command: command2, arguments: args2 };
+        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 args2 = {
+          searchValue,
+          maxResultCount: maxResults
+        };
+        if (file) args2["file"] = this.resolvePath(file);
+        const body = await this.sendRequest("navto", args2);
+        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 fs3 from "fs";
+import * as path4 from "path";
+function discoverFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs3.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(path4.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 = path4.extname(name);
+        if (TS_EXTENSIONS.has(ext)) {
+          files.push(path4.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;
+}
+function distToSource(resolvedPath, projectRoot2) {
+  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
+  const rel2 = path4.relative(projectRoot2, resolvedPath);
+  const distIdx = rel2.indexOf("dist" + path4.sep);
+  if (distIdx === -1) return resolvedPath;
+  const prefix = rel2.slice(0, distIdx);
+  const afterDist = rel2.slice(distIdx + 5);
+  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path4.resolve(projectRoot2, prefix, "src", withoutExt + ext);
+    if (fs3.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path4.resolve(projectRoot2, prefix, withoutExt + ext);
+    if (fs3.existsSync(candidate)) return candidate;
+  }
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path4.resolve(projectRoot2, prefix, "src", dirPath + ext);
+      if (fs3.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 = path4.extname(mapped);
+      if (!TS_EXTENSIONS.has(ext)) return null;
+      if (SKIP_FILES.has(path4.basename(mapped))) return null;
+      return mapped;
+    }
+  } catch {
+  }
+  return null;
+}
+function createResolver(projectRoot2, tsconfigPath2) {
+  return new ResolverFactory({
+    tsconfig: {
+      configFile: path4.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 = fs3.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    let rawImports;
+    try {
+      rawImports = parseFileImports(filePath, source);
+    } catch (err) {
+      parseFailures.push(filePath);
+      continue;
+    }
+    const edges = [];
+    const fromDir = path4.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 = fs3.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 = path4.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 = fs3.watch(
+      projectRoot2,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (!filename) return;
+        const ext = path4.extname(filename);
+        if (!TS_EXTENSIONS.has(ext)) return;
+        const parts = filename.split(path4.sep);
+        if (parts.some((p2) => SKIP_DIRS.has(p2))) return;
+        if (SKIP_FILES.has(path4.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath2 = path4.resolve(projectRoot2, filename);
+        if (fs3.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);
+  }
+}
+var log2, TS_EXTENSIONS, SKIP_DIRS, SKIP_FILES, SOURCE_EXTS;
+var init_module_graph = __esm({
+  "module-graph.ts"() {
+    log2 = (...args2) => console.error("[typegraph/graph]", ...args2);
+    TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".wrangler",
+      ".mf",
+      ".git",
+      ".next",
+      ".turbo",
+      "coverage"
+    ]);
+    SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+    SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+  }
+});
+
+// graph-queries.ts
+import * as fs4 from "fs";
+import * as path5 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 };
+}
+function findPackageName(filePath) {
+  let dir = path5.dirname(filePath);
+  while (dir !== path5.dirname(dir)) {
+    if (packageNameCache.has(dir)) return packageNameCache.get(dir);
+    const pkgJsonPath = path5.join(dir, "package.json");
+    try {
+      if (fs4.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkg.name ?? path5.basename(dir);
+        packageNameCache.set(dir, name);
+        return name;
+      }
+    } catch {
+    }
+    dir = path5.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 = path5.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 p2 = parent.get(filePath[i]);
+            chain.push({
+              file: filePath[i],
+              imports: p2?.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
+  };
+}
+var packageNameCache;
+var init_graph_queries = __esm({
+  "graph-queries.ts"() {
+    packageNameCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// smoke-test.ts
+var smoke_test_exports = {};
+__export(smoke_test_exports, {
+  main: () => main2
+});
+import * as fs5 from "fs";
+import * as path6 from "path";
+function rel(absPath2, projectRoot2) {
+  return path6.relative(projectRoot2, absPath2);
+}
+function findInNavBar(items, predicate) {
+  for (const item of items) {
+    if (predicate(item)) return item;
+    if (item.childItems?.length > 0) {
+      const found = findInNavBar(item.childItems, predicate);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function findTestFile(rootDir) {
+  const candidates = [];
+  function walk(dir, depth) {
+    if (depth > 5 || candidates.length >= 30) return;
+    let entries;
+    try {
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
+        walk(path6.join(dir, entry.name), depth + 1);
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (name.endsWith(".d.ts") || name.endsWith(".test.ts") || name.endsWith(".spec.ts"))
+          continue;
+        if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
+        try {
+          const stat = fs5.statSync(path6.join(dir, name));
+          if (stat.size > 200 && stat.size < 5e4) {
+            candidates.push({ file: path6.join(dir, name), size: stat.size });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  walk(rootDir, 0);
+  const preferred = candidates.find(
+    (c) => /service|handler|controller|repository|provider/i.test(path6.basename(c.file))
+  );
+  const fallback = candidates.sort((a, b) => b.size - a.size)[0];
+  return preferred?.file ?? fallback?.file ?? null;
+}
+function findImporter(graph, file) {
+  const revEdges = graph.reverse.get(file);
+  if (!revEdges || revEdges.length === 0) return null;
+  const preferred = revEdges.find(
+    (e) => !e.target.includes(".test.") && !e.target.endsWith("index.ts")
+  );
+  return (preferred ?? revEdges[0]).target;
+}
+async function main2(configOverride) {
+  const { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2 } = configOverride ?? resolveConfig(import.meta.dirname);
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  function pass(name, detail, ms) {
+    console.log(`  \u2713 ${name} [${ms.toFixed(0)}ms]`);
+    console.log(`    ${detail}`);
+    passed++;
+  }
+  function fail(name, detail, ms) {
+    console.log(`  \u2717 ${name} [${ms.toFixed(0)}ms]`);
+    console.log(`    ${detail}`);
+    failed++;
+  }
+  function skip(name, reason) {
+    console.log(`  - ${name} (skipped: ${reason})`);
+    skipped++;
+  }
+  console.log("");
+  console.log("typegraph-mcp Smoke Test");
+  console.log("=====================");
+  console.log(`Project root: ${projectRoot2}`);
+  console.log("");
+  const testFile = findTestFile(projectRoot2);
+  if (!testFile) {
+    console.log("  No suitable .ts file found in project. Cannot run smoke tests.");
+    return { passed, failed: failed + 1, skipped };
+  }
+  const testFileRel = rel(testFile, projectRoot2);
+  console.log(`Test subject: ${testFileRel}`);
+  console.log("");
+  console.log("\u2500\u2500 Module Graph \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  let graph;
+  let t0;
+  t0 = performance.now();
+  try {
+    const result = await buildGraph(projectRoot2, tsconfigPath2);
+    graph = result.graph;
+    const ms = performance.now() - t0;
+    const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
+    if (graph.files.size > 0) {
+      pass("graph build", `${graph.files.size} files, ${edgeCount} edges`, ms);
+    } else {
+      fail("graph build", "0 files discovered", ms);
+      console.log("\nCannot continue without module graph.");
+      return { passed, failed, skipped };
+    }
+  } catch (err) {
+    fail(
+      "graph build",
+      `Error: ${err instanceof Error ? err.message : String(err)}`,
+      performance.now() - t0
+    );
+    console.log("\nCannot continue without module graph.");
+    return { passed, failed, skipped };
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = dependencyTree(graph, testFile);
+    pass(
+      "dependency_tree",
+      `${result.nodes} transitive deps from ${testFileRel}`,
+      performance.now() - t0
+    );
+  } else {
+    skip("dependency_tree", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = dependents(graph, testFile);
+    pass(
+      "dependents",
+      `${result.nodes} dependents (${result.directCount} direct)`,
+      performance.now() - t0
+    );
+  } else {
+    skip("dependents", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  const cycles = importCycles(graph);
+  pass("import_cycles", `${cycles.count} cycle(s) detected`, performance.now() - t0);
+  t0 = performance.now();
+  const importer = findImporter(graph, testFile);
+  if (importer && graph.files.has(testFile)) {
+    const result = shortestPath(graph, importer, testFile);
+    const ms = performance.now() - t0;
+    if (result.path) {
+      pass("shortest_path", `${result.hops} hops: ${result.path.map((p2) => rel(p2, projectRoot2)).join(" -> ")}`, ms);
+    } else {
+      pass("shortest_path", `No path from ${rel(importer, projectRoot2)} (may be type-only)`, ms);
+    }
+  } else {
+    skip("shortest_path", "No importer found for test file");
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = subgraph(graph, [testFile], { depth: 1, direction: "both" });
+    pass(
+      "subgraph",
+      `${result.stats.nodeCount} nodes, ${result.stats.edgeCount} edges (depth 1)`,
+      performance.now() - t0
+    );
+  } else {
+    skip("subgraph", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  const dir = path6.dirname(testFile);
+  const siblings = [...graph.files].filter((f) => path6.dirname(f) === dir);
+  if (siblings.length >= 2) {
+    const result = moduleBoundary(graph, siblings);
+    pass(
+      "module_boundary",
+      `${siblings.length} files in ${rel(dir, projectRoot2)}/: ${result.internalEdges} internal, ${result.incomingEdges.length} in, ${result.outgoingEdges.length} out`,
+      performance.now() - t0
+    );
+  } else {
+    skip("module_boundary", `Only ${siblings.length} file(s) in ${rel(dir, projectRoot2)}/`);
+  }
+  console.log("");
+  console.log("\u2500\u2500 tsserver \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  const client2 = new TsServerClient(projectRoot2, tsconfigPath2);
+  t0 = performance.now();
+  await client2.start();
+  console.log(`  (started in ${(performance.now() - t0).toFixed(0)}ms)`);
+  t0 = performance.now();
+  const bar = await client2.navbar(testFileRel);
+  const navbarMs = performance.now() - t0;
+  const symbolKinds = /* @__PURE__ */ new Set([
+    "function",
+    "const",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "var",
+    "let",
+    "method"
+  ]);
+  const allSymbols = [];
+  function collectSymbols(items) {
+    for (const item of items) {
+      if (symbolKinds.has(item.kind) && item.text !== "<function>" && item.spans.length > 0) {
+        allSymbols.push(item);
+      }
+      if (item.childItems?.length > 0) collectSymbols(item.childItems);
+    }
+  }
+  collectSymbols(bar);
+  if (allSymbols.length > 0) {
+    pass("navbar", `${allSymbols.length} symbols in ${testFileRel}`, navbarMs);
+  } else {
+    fail("navbar", `No symbols found in ${testFileRel}`, navbarMs);
+  }
+  const concreteKinds = /* @__PURE__ */ new Set(["const", "function", "class", "var", "let", "enum"]);
+  const sym = allSymbols.find((s) => concreteKinds.has(s.kind)) ?? allSymbols[0];
+  if (!sym) {
+    const toolNames = [
+      "find_symbol",
+      "definition",
+      "references",
+      "type_info",
+      "navigate_to",
+      "blast_radius",
+      "module_exports",
+      "trace_chain"
+    ];
+    for (const name of toolNames) skip(name, "No symbol discovered");
+  } else {
+    const span = sym.spans[0];
+    t0 = performance.now();
+    const found = findInNavBar(bar, (item) => item.text === sym.text && item.kind === sym.kind);
+    if (found && found.spans.length > 0) {
+      pass(
+        "find_symbol",
+        `${sym.text} [${sym.kind}] at line ${found.spans[0].start.line}`,
+        performance.now() - t0
+      );
+    } else {
+      fail("find_symbol", `Could not re-find ${sym.text}`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const defs = await client2.definition(testFileRel, span.start.line, span.start.offset);
+    if (defs.length > 0) {
+      const def = defs[0];
+      pass("definition", `${sym.text} -> ${def.file}:${def.start.line}`, performance.now() - t0);
+    } else {
+      pass("definition", `${sym.text} is its own definition`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const refs = await client2.references(testFileRel, span.start.line, span.start.offset);
+    const refFiles = new Set(refs.map((r) => r.file));
+    pass(
+      "references",
+      `${refs.length} ref(s) across ${refFiles.size} file(s)`,
+      performance.now() - t0
+    );
+    t0 = performance.now();
+    const info = await client2.quickinfo(testFileRel, span.start.line, span.start.offset);
+    if (info) {
+      const typeStr = info.displayString.length > 80 ? info.displayString.slice(0, 80) + "..." : info.displayString;
+      pass("type_info", typeStr, performance.now() - t0);
+    } else {
+      fail("type_info", `No type info for ${sym.text}`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const navItems = await client2.navto(sym.text, 5);
+    if (navItems.length > 0) {
+      const files = new Set(navItems.map((i) => i.file));
+      pass(
+        "navigate_to",
+        `${navItems.length} match(es) for "${sym.text}" in ${files.size} file(s)`,
+        performance.now() - t0
+      );
+    } else {
+      pass(
+        "navigate_to",
+        `"${sym.text}" not indexed by navto (expected for some kinds)`,
+        performance.now() - t0
+      );
+    }
+    t0 = performance.now();
+    const callers = refs.filter((r) => !r.isDefinition);
+    const callerFiles = new Set(callers.map((r) => r.file));
+    pass(
+      "blast_radius",
+      `${callers.length} usage(s) across ${callerFiles.size} file(s)`,
+      performance.now() - t0
+    );
+    t0 = performance.now();
+    const moduleItem = bar.find((item) => item.kind === "module");
+    const topItems = moduleItem?.childItems ?? bar;
+    const exportSymbols = topItems.filter((item) => symbolKinds.has(item.kind));
+    pass("module_exports", `${exportSymbols.length} top-level symbol(s)`, performance.now() - t0);
+    t0 = performance.now();
+    const source = fs5.readFileSync(testFile, "utf-8");
+    const importMatch = source.match(/^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/m);
+    if (importMatch) {
+      const firstName = importMatch[1].split(",")[0].replace(/^type\s+/, "").trim();
+      const importSym = findInNavBar(bar, (item) => item.text === firstName);
+      if (importSym && importSym.spans.length > 0) {
+        const chain = [testFileRel];
+        let cur = {
+          file: testFileRel,
+          line: importSym.spans[0].start.line,
+          offset: importSym.spans[0].start.offset
+        };
+        for (let i = 0; i < 5; i++) {
+          const hopDefs = await client2.definition(cur.file, cur.line, cur.offset);
+          if (hopDefs.length === 0) break;
+          const hop = hopDefs[0];
+          if (hop.file === cur.file && hop.start.line === cur.line) break;
+          if (hop.file.includes("node_modules")) break;
+          chain.push(`${hop.file}:${hop.start.line}`);
+          cur = { file: hop.file, line: hop.start.line, offset: hop.start.offset };
+        }
+        if (chain.length > 1) {
+          pass(
+            "trace_chain",
+            `${chain.length - 1} hop(s): ${chain.join(" -> ")}`,
+            performance.now() - t0
+          );
+        } else {
+          pass(
+            "trace_chain",
+            `"${firstName}" resolved in-file (0 external hops)`,
+            performance.now() - t0
+          );
+        }
+      } else {
+        pass(
+          "trace_chain",
+          `"${firstName}" not in navbar (may be type-only)`,
+          performance.now() - t0
+        );
+      }
+    } else {
+      skip("trace_chain", "No brace imports in test file");
+    }
+  }
+  client2.shutdown();
+  console.log("");
+  const total = passed + failed;
+  if (failed === 0) {
+    console.log(
+      `${passed}/${total} passed` + (skipped > 0 ? ` (${skipped} skipped)` : "") + " -- all tools working"
+    );
+  } else {
+    console.log(
+      `${passed}/${total} passed, ${failed} failed` + (skipped > 0 ? `, ${skipped} skipped` : "") + " -- some tools may not work correctly"
+    );
+  }
+  console.log("");
+  return { passed, failed, skipped };
+}
+var SKIP_DIRS2, isDirectRun2;
+var init_smoke_test = __esm({
+  "smoke-test.ts"() {
+    init_tsserver_client();
+    init_module_graph();
+    init_graph_queries();
+    init_config();
+    SKIP_DIRS2 = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      ".git",
+      ".wrangler",
+      "coverage",
+      "out"
+    ]);
+    isDirectRun2 = process.argv[1] && fs5.realpathSync(process.argv[1]) === fs5.realpathSync(new URL(import.meta.url).pathname);
+    if (isDirectRun2) {
+      main2().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
+        console.error("Fatal:", err);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// server.ts
+var server_exports = {};
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs6 from "fs";
+import * as path7 from "path";
+function readPreview(file, line) {
+  try {
+    const absPath2 = client.resolvePath(file);
+    const content = fs6.readFileSync(absPath2, "utf-8");
+    return content.split("\n")[line - 1]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+function findInNavBar2(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 = findInNavBar2(item.childItems, symbol);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+async function resolveSymbol(file, symbol) {
+  const bar = await client.navbar(file);
+  const found = findInNavBar2(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;
+}
+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" };
+}
+function relPath(absPath2) {
+  return path7.relative(projectRoot, absPath2);
+}
+function absPath(file) {
+  return path7.isAbsolute(file) ? file : path7.resolve(projectRoot, file);
+}
+async function main3() {
+  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");
+}
+var projectRoot, tsconfigPath, log3, client, moduleGraph, mcpServer, locationOrSymbol;
+var init_server = __esm({
+  "server.ts"() {
+    init_tsserver_client();
+    init_module_graph();
+    init_graph_queries();
+    init_config();
+    ({ projectRoot, tsconfigPath } = resolveConfig(import.meta.dirname));
+    log3 = (...args2) => console.error("[typegraph]", ...args2);
+    client = new TsServerClient(projectRoot, tsconfigPath);
+    mcpServer = new McpServer({
+      name: "typegraph",
+      version: "1.0.0"
+    });
+    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.")
+    };
+    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 start2 = await resolveSymbol(file, symbol);
+        if (!start2) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: `Symbol "${symbol}" not found in ${file}` })
+              }
+            ]
+          };
+        }
+        const chain = [
+          {
+            file: start2.file,
+            line: start2.line,
+            column: start2.column,
+            preview: start2.preview
+          }
+        ];
+        let current = { file: start2.file, line: start2.line, offset: start2.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 start2 = await resolveSymbol(file, symbol);
+        if (!start2) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: `Symbol "${symbol}" not found in ${file}` })
+              }
+            ]
+          };
+        }
+        const refs = await client.references(start2.file, start2.line, start2.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 })
+            }
+          ]
+        };
+      }
+    );
+    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
+              })
+            }
+          ]
+        };
+      }
+    );
+    process.on("SIGINT", () => {
+      log3("Shutting down...");
+      client.shutdown();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      client.shutdown();
+      process.exit(0);
+    });
+    main3().catch((err) => {
+      log3("Fatal error:", err);
+      process.exit(1);
+    });
+  }
+});
+
+// cli.ts
+init_config();
+import * as fs7 from "fs";
+import * as path8 from "path";
+import { execSync } from "child_process";
+import * as p from "@clack/prompts";
+var AGENT_SNIPPET = `
+## TypeScript Navigation (typegraph-mcp)
+
+Use the \`ts_*\` MCP tools instead of grep/glob for navigating TypeScript code. They resolve through barrel files, re-exports, and project references \u2014 returning precise results, not string matches.
+
+- **Point queries** (tsserver): \`ts_find_symbol\`, \`ts_definition\`, \`ts_references\`, \`ts_type_info\`, \`ts_navigate_to\`, \`ts_trace_chain\`, \`ts_blast_radius\`, \`ts_module_exports\`
+- **Graph queries** (import graph): \`ts_dependency_tree\`, \`ts_dependents\`, \`ts_import_cycles\`, \`ts_shortest_path\`, \`ts_subgraph\`, \`ts_module_boundary\`
+`.trimStart();
+var SNIPPET_MARKER = "## TypeScript Navigation (typegraph-mcp)";
+var PLUGIN_DIR_NAME = "plugins/typegraph-mcp";
+var AGENT_IDS = ["claude-code", "cursor", "codex", "gemini", "copilot"];
+var AGENTS = {
+  "claude-code": {
+    name: "Claude Code",
+    pluginFiles: [
+      ".claude-plugin/plugin.json",
+      ".mcp.json",
+      "hooks/hooks.json",
+      "scripts/ensure-deps.sh",
+      "commands/check.md",
+      "commands/test.md"
+    ],
+    agentFile: "CLAUDE.md",
+    needsAgentsSkills: false,
+    detect: (root) => fs7.existsSync(path8.join(root, "CLAUDE.md")) || fs7.existsSync(path8.join(root, ".claude"))
+  },
+  cursor: {
+    name: "Cursor",
+    pluginFiles: [".cursor-plugin/plugin.json"],
+    agentFile: null,
+    needsAgentsSkills: false,
+    detect: (root) => fs7.existsSync(path8.join(root, ".cursor"))
+  },
+  codex: {
+    name: "Codex CLI",
+    pluginFiles: [],
+    agentFile: "AGENTS.md",
+    needsAgentsSkills: true,
+    detect: (root) => fs7.existsSync(path8.join(root, "AGENTS.md"))
+  },
+  gemini: {
+    name: "Gemini CLI",
+    pluginFiles: ["gemini-extension.json"],
+    agentFile: "GEMINI.md",
+    needsAgentsSkills: true,
+    detect: (root) => fs7.existsSync(path8.join(root, "GEMINI.md"))
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    pluginFiles: [],
+    agentFile: ".github/copilot-instructions.md",
+    needsAgentsSkills: true,
+    detect: (root) => fs7.existsSync(path8.join(root, ".github/copilot-instructions.md"))
+  }
+};
+var CORE_FILES = [
+  "server.ts",
+  "module-graph.ts",
+  "tsserver-client.ts",
+  "graph-queries.ts",
+  "config.ts",
+  "check.ts",
+  "smoke-test.ts",
+  "cli.ts",
+  "package.json",
+  "pnpm-lock.yaml"
+];
+var SKILL_FILES = [
+  "skills/tool-selection/SKILL.md",
+  "skills/impact-analysis/SKILL.md",
+  "skills/refactor-safety/SKILL.md",
+  "skills/dependency-audit/SKILL.md",
+  "skills/code-exploration/SKILL.md"
+];
+var SKILL_NAMES = [
+  "tool-selection",
+  "impact-analysis",
+  "refactor-safety",
+  "dependency-audit",
+  "code-exploration"
+];
+var HELP = `
+typegraph-mcp \u2014 Type-aware codebase navigation for AI coding agents.
+
+Usage: typegraph-mcp <command> [options]
+
+Commands:
+  setup    Install typegraph-mcp plugin into the current project
+  remove   Uninstall typegraph-mcp from the current project
+  check    Run health checks (12 checks)
+  test     Run smoke tests (all 14 tools)
+  start    Start the MCP server (stdin/stdout)
+
+Options:
+  --yes   Skip confirmation prompts (accept all defaults)
+  --help  Show this help
+`.trim();
+function copyFile(src, dest) {
+  const destDir = path8.dirname(dest);
+  if (!fs7.existsSync(destDir)) {
+    fs7.mkdirSync(destDir, { recursive: true });
+  }
+  fs7.copyFileSync(src, dest);
+  if (src.endsWith(".sh")) {
+    fs7.chmodSync(dest, 493);
+  }
+}
+var MCP_SERVER_ENTRY = {
+  command: "npx",
+  args: ["tsx", "./plugins/typegraph-mcp/server.ts"],
+  env: {
+    TYPEGRAPH_PROJECT_ROOT: ".",
+    TYPEGRAPH_TSCONFIG: "./tsconfig.json"
+  }
+};
+function registerMcpServers(projectRoot2, selectedAgents) {
+  if (selectedAgents.includes("cursor")) {
+    registerJsonMcp(projectRoot2, ".cursor/mcp.json", "mcpServers");
+  }
+  if (selectedAgents.includes("codex")) {
+    registerCodexMcp(projectRoot2);
+  }
+  if (selectedAgents.includes("copilot")) {
+    registerJsonMcp(projectRoot2, ".vscode/mcp.json", "servers");
+  }
+}
+function deregisterMcpServers(projectRoot2) {
+  deregisterJsonMcp(projectRoot2, ".cursor/mcp.json", "mcpServers");
+  deregisterCodexMcp(projectRoot2);
+  deregisterJsonMcp(projectRoot2, ".vscode/mcp.json", "servers");
+}
+function registerJsonMcp(projectRoot2, configPath, rootKey) {
+  const fullPath = path8.resolve(projectRoot2, configPath);
+  let config = {};
+  if (fs7.existsSync(fullPath)) {
+    try {
+      config = JSON.parse(fs7.readFileSync(fullPath, "utf-8"));
+    } catch {
+      p.log.warn(`Could not parse ${configPath} \u2014 skipping MCP registration`);
+      return;
+    }
+  }
+  const servers = config[rootKey] ?? {};
+  const entry = { ...MCP_SERVER_ENTRY };
+  if (rootKey === "servers") {
+    entry.type = "stdio";
+  }
+  servers["typegraph"] = entry;
+  config[rootKey] = servers;
+  const dir = path8.dirname(fullPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
+  }
+  fs7.writeFileSync(fullPath, JSON.stringify(config, null, 2) + "\n");
+  p.log.success(`${configPath}: registered typegraph MCP server`);
+}
+function deregisterJsonMcp(projectRoot2, configPath, rootKey) {
+  const fullPath = path8.resolve(projectRoot2, configPath);
+  if (!fs7.existsSync(fullPath)) return;
+  try {
+    const config = JSON.parse(fs7.readFileSync(fullPath, "utf-8"));
+    const servers = config[rootKey];
+    if (!servers || !servers["typegraph"]) return;
+    delete servers["typegraph"];
+    if (Object.keys(servers).length === 0) {
+      delete config[rootKey];
+    }
+    if (Object.keys(config).length === 0) {
+      fs7.unlinkSync(fullPath);
+    } else {
+      fs7.writeFileSync(fullPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    p.log.info(`${configPath}: removed typegraph MCP server`);
+  } catch {
+  }
+}
+function registerCodexMcp(projectRoot2) {
+  const configPath = ".codex/config.toml";
+  const fullPath = path8.resolve(projectRoot2, configPath);
+  let content = "";
+  if (fs7.existsSync(fullPath)) {
+    content = fs7.readFileSync(fullPath, "utf-8");
+    if (content.includes("[mcp_servers.typegraph]")) {
+      p.log.info(`${configPath}: typegraph MCP server already registered`);
+      return;
+    }
+  }
+  const block = [
+    "",
+    "[mcp_servers.typegraph]",
+    'command = "npx"',
+    'args = ["tsx", "./plugins/typegraph-mcp/server.ts"]',
+    'env = { TYPEGRAPH_PROJECT_ROOT = ".", TYPEGRAPH_TSCONFIG = "./tsconfig.json" }',
+    ""
+  ].join("\n");
+  const dir = path8.dirname(fullPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
+  }
+  const newContent = content ? content.trimEnd() + "\n" + block : block.trimStart();
+  fs7.writeFileSync(fullPath, newContent);
+  p.log.success(`${configPath}: registered typegraph MCP server`);
+}
+function deregisterCodexMcp(projectRoot2) {
+  const configPath = ".codex/config.toml";
+  const fullPath = path8.resolve(projectRoot2, configPath);
+  if (!fs7.existsSync(fullPath)) return;
+  let content = fs7.readFileSync(fullPath, "utf-8");
+  if (!content.includes("[mcp_servers.typegraph]")) return;
+  content = content.replace(
+    /\n?\[mcp_servers\.typegraph\]\n[\s\S]*?(?=\n\[|$)/,
+    ""
+  );
+  content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  if (content.trim() === "") {
+    fs7.unlinkSync(fullPath);
+  } else {
+    fs7.writeFileSync(fullPath, content);
+  }
+  p.log.info(`${configPath}: removed typegraph MCP server`);
+}
+function detectAgents(projectRoot2) {
+  return AGENT_IDS.filter((id) => AGENTS[id].detect(projectRoot2));
+}
+async function selectAgents(projectRoot2, yes2) {
+  const detected = detectAgents(projectRoot2);
+  if (yes2) {
+    const selected2 = detected.length > 0 ? detected : [...AGENT_IDS];
+    p.log.info(`Auto-selected: ${selected2.map((id) => AGENTS[id].name).join(", ")}`);
+    return selected2;
+  }
+  p.log.info("space = toggle  |  up/down = navigate  |  enter = confirm");
+  const result = await p.multiselect({
+    message: "Select which AI agents to configure:",
+    options: AGENT_IDS.map((id) => ({
+      value: id,
+      label: AGENTS[id].name,
+      hint: detected.includes(id) ? "detected" : void 0
+    })),
+    initialValues: detected.length > 0 ? detected : [...AGENT_IDS],
+    required: false
+  });
+  if (p.isCancel(result)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const selected = result.length > 0 ? result : detected.length > 0 ? detected : [...AGENT_IDS];
+  p.log.info(`Selected: ${selected.map((id) => AGENTS[id].name).join(", ")}`);
+  return selected;
+}
+async function setup(yes2) {
+  const sourceDir = path8.basename(import.meta.dirname) === "dist" ? path8.resolve(import.meta.dirname, "..") : import.meta.dirname;
+  const projectRoot2 = process.cwd();
+  process.stdout.write("\x1Bc");
+  p.intro("TypeGraph MCP Setup");
+  p.log.info(`Project: ${projectRoot2}`);
+  const pkgJsonPath = path8.resolve(projectRoot2, "package.json");
+  const tsconfigPath2 = path8.resolve(projectRoot2, "tsconfig.json");
+  if (!fs7.existsSync(pkgJsonPath)) {
+    p.cancel("No package.json found. Run this from the root of your TypeScript project.");
+    process.exit(1);
+  }
+  if (!fs7.existsSync(tsconfigPath2)) {
+    p.cancel("No tsconfig.json found. typegraph-mcp requires a TypeScript project.");
+    process.exit(1);
+  }
+  p.log.success("Found package.json and tsconfig.json");
+  const targetDir = path8.resolve(projectRoot2, PLUGIN_DIR_NAME);
+  const isUpdate = fs7.existsSync(targetDir);
+  if (isUpdate && !yes2) {
+    const action = await p.select({
+      message: `${PLUGIN_DIR_NAME}/ already exists.`,
+      options: [
+        { value: "update", label: "Update", hint: "reinstall plugin files" },
+        { value: "remove", label: "Remove", hint: "uninstall typegraph-mcp from this project" },
+        { value: "exit", label: "Exit", hint: "keep existing installation" }
+      ]
+    });
+    if (p.isCancel(action)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    if (action === "remove") {
+      await removePlugin(projectRoot2, targetDir);
+      return;
+    }
+    if (action === "exit") {
+      p.outro("No changes made.");
+      return;
+    }
+  }
+  const selectedAgents = await selectAgents(projectRoot2, yes2);
+  const needsPluginSkills = selectedAgents.includes("claude-code") || selectedAgents.includes("cursor");
+  const needsAgentsSkills = selectedAgents.some((id) => AGENTS[id].needsAgentsSkills);
+  p.log.step(`Installing to ${PLUGIN_DIR_NAME}/...`);
+  const s = p.spinner();
+  s.start("Copying files...");
+  const filesToCopy = [...CORE_FILES];
+  if (needsPluginSkills || needsAgentsSkills) {
+    filesToCopy.push(...SKILL_FILES);
+  }
+  for (const agentId of selectedAgents) {
+    filesToCopy.push(...AGENTS[agentId].pluginFiles);
+  }
+  let copied = 0;
+  for (const file of filesToCopy) {
+    const src = path8.join(sourceDir, file);
+    const dest = path8.join(targetDir, file);
+    if (fs7.existsSync(src)) {
+      copyFile(src, dest);
+      copied++;
+    } else {
+      p.log.warn(`Source file not found: ${file}`);
+    }
+  }
+  s.message("Installing dependencies...");
+  try {
+    execSync("npm install", { cwd: targetDir, stdio: "pipe" });
+    s.stop(`${isUpdate ? "Updated" : "Installed"} ${copied} files with dependencies`);
+  } catch (err) {
+    s.stop(`${isUpdate ? "Updated" : "Installed"} ${copied} files`);
+    p.log.warn(`Dependency install failed: ${err instanceof Error ? err.message : String(err)}`);
+    p.log.info(`Run manually: cd ${PLUGIN_DIR_NAME} && npm install`);
+  }
+  if (needsAgentsSkills) {
+    const agentsNames = selectedAgents.filter((id) => AGENTS[id].needsAgentsSkills).map((id) => AGENTS[id].name);
+    const agentsSkillsDir = path8.resolve(projectRoot2, ".agents/skills");
+    let copiedSkills = 0;
+    for (const skill of SKILL_NAMES) {
+      const src = path8.join(targetDir, "skills", skill, "SKILL.md");
+      const destDir = path8.join(agentsSkillsDir, skill);
+      const dest = path8.join(destDir, "SKILL.md");
+      if (!fs7.existsSync(src)) continue;
+      if (fs7.existsSync(dest)) {
+        const srcContent = fs7.readFileSync(src, "utf-8");
+        const destContent = fs7.readFileSync(dest, "utf-8");
+        if (srcContent === destContent) continue;
+      }
+      fs7.mkdirSync(destDir, { recursive: true });
+      fs7.copyFileSync(src, dest);
+      copiedSkills++;
+    }
+    if (copiedSkills > 0) {
+      p.log.success(`Copied ${copiedSkills} skills to .agents/skills/ (${agentsNames.join(", ")})`);
+    } else {
+      p.log.info(".agents/skills/ already up to date");
+    }
+  }
+  if (selectedAgents.includes("claude-code")) {
+    const mcpJsonPath = path8.resolve(projectRoot2, ".claude/mcp.json");
+    if (fs7.existsSync(mcpJsonPath)) {
+      try {
+        const mcpJson = JSON.parse(fs7.readFileSync(mcpJsonPath, "utf-8"));
+        if (mcpJson.mcpServers?.["typegraph"]) {
+          delete mcpJson.mcpServers["typegraph"];
+          fs7.writeFileSync(mcpJsonPath, JSON.stringify(mcpJson, null, 2) + "\n");
+          p.log.info("Removed old typegraph entry from .claude/mcp.json");
+        }
+      } catch {
+      }
+    }
+  }
+  await setupAgentInstructions(projectRoot2, selectedAgents);
+  registerMcpServers(projectRoot2, selectedAgents);
+  await runVerification(targetDir, selectedAgents);
+}
+async function removePlugin(projectRoot2, pluginDir) {
+  const s = p.spinner();
+  s.start("Removing typegraph-mcp...");
+  if (fs7.existsSync(pluginDir)) {
+    fs7.rmSync(pluginDir, { recursive: true });
+  }
+  const agentsSkillsDir = path8.resolve(projectRoot2, ".agents/skills");
+  for (const skill of SKILL_NAMES) {
+    const skillDir = path8.join(agentsSkillsDir, skill);
+    if (fs7.existsSync(skillDir)) {
+      fs7.rmSync(skillDir, { recursive: true });
+    }
+  }
+  if (fs7.existsSync(agentsSkillsDir) && fs7.readdirSync(agentsSkillsDir).length === 0) {
+    fs7.rmSync(agentsSkillsDir, { recursive: true });
+    const agentsDir = path8.resolve(projectRoot2, ".agents");
+    if (fs7.existsSync(agentsDir) && fs7.readdirSync(agentsDir).length === 0) {
+      fs7.rmSync(agentsDir, { recursive: true });
+    }
+  }
+  const allAgentFiles = AGENT_IDS.map((id) => AGENTS[id].agentFile).filter((f) => f !== null);
+  const seenRealPaths = /* @__PURE__ */ new Set();
+  for (const agentFile of allAgentFiles) {
+    const filePath = path8.resolve(projectRoot2, agentFile);
+    if (!fs7.existsSync(filePath)) continue;
+    const realPath = fs7.realpathSync(filePath);
+    if (seenRealPaths.has(realPath)) continue;
+    seenRealPaths.add(realPath);
+    let content = fs7.readFileSync(realPath, "utf-8");
+    if (content.includes(SNIPPET_MARKER)) {
+      content = content.replace(/\n?## TypeScript Navigation \(typegraph-mcp\)\n[\s\S]*?(?=\n## |\n# |$)/, "");
+      content = content.replace(/\n{3,}$/, "\n");
+      fs7.writeFileSync(realPath, content);
+    }
+  }
+  const claudeMdPath = path8.resolve(projectRoot2, "CLAUDE.md");
+  if (fs7.existsSync(claudeMdPath)) {
+    let content = fs7.readFileSync(claudeMdPath, "utf-8");
+    content = content.replace(/ --plugin-dir \.\/plugins\/typegraph-mcp/g, "");
+    fs7.writeFileSync(claudeMdPath, content);
+  }
+  s.stop("Removed typegraph-mcp");
+  deregisterMcpServers(projectRoot2);
+  p.outro("typegraph-mcp has been uninstalled from this project.");
+}
+async function setupAgentInstructions(projectRoot2, selectedAgents) {
+  const agentFiles = selectedAgents.map((id) => AGENTS[id].agentFile).filter((f) => f !== null);
+  if (agentFiles.length === 0) {
+    return;
+  }
+  const seenRealPaths = /* @__PURE__ */ new Map();
+  const existingFiles = [];
+  for (const agentFile of agentFiles) {
+    const filePath = path8.resolve(projectRoot2, agentFile);
+    if (!fs7.existsSync(filePath)) continue;
+    const realPath = fs7.realpathSync(filePath);
+    const previousFile = seenRealPaths.get(realPath);
+    if (previousFile) {
+      p.log.info(`${agentFile}: same file as ${previousFile} (skipped)`);
+      continue;
+    }
+    seenRealPaths.set(realPath, agentFile);
+    const content = fs7.readFileSync(filePath, "utf-8");
+    existingFiles.push({ file: agentFile, realPath, hasSnippet: content.includes(SNIPPET_MARKER) });
+  }
+  if (existingFiles.length === 0) {
+    p.log.warn(`No agent instruction files found (${agentFiles.join(", ")})`);
+    p.note(AGENT_SNIPPET, "Add this snippet to your agent instructions file");
+  } else if (existingFiles.some((f) => f.hasSnippet)) {
+    for (const f of existingFiles) {
+      if (f.hasSnippet) {
+        p.log.info(`${f.file}: already has typegraph-mcp instructions`);
+      }
+    }
+  } else {
+    const target = existingFiles[0];
+    const content = fs7.readFileSync(target.realPath, "utf-8");
+    const appendContent = (content.endsWith("\n") ? "" : "\n") + "\n" + AGENT_SNIPPET;
+    fs7.appendFileSync(target.realPath, appendContent);
+    p.log.success(`${target.file}: appended typegraph-mcp instructions`);
+  }
+  if (selectedAgents.includes("claude-code")) {
+    const claudeMdPath = path8.resolve(projectRoot2, "CLAUDE.md");
+    if (fs7.existsSync(claudeMdPath)) {
+      let content = fs7.readFileSync(claudeMdPath, "utf-8");
+      const pluginDirPattern = /(`claude\s+)((?:--plugin-dir\s+\S+\s*)+)(`)/;
+      const match = content.match(pluginDirPattern);
+      if (match && !match[2].includes("./plugins/typegraph-mcp")) {
+        const existingFlags = match[2].trimEnd();
+        content = content.replace(
+          pluginDirPattern,
+          `$1${existingFlags} --plugin-dir ./plugins/typegraph-mcp$3`
+        );
+        fs7.writeFileSync(claudeMdPath, content);
+        p.log.success("CLAUDE.md: added --plugin-dir ./plugins/typegraph-mcp");
+      } else if (match) {
+        p.log.info("CLAUDE.md: --plugin-dir already includes typegraph-mcp");
+      }
+    }
+  }
+}
+async function runVerification(pluginDir, selectedAgents) {
+  const config = resolveConfig(pluginDir);
+  console.log("");
+  const { main: checkMain } = await Promise.resolve().then(() => (init_check(), check_exports));
+  const checkResult = await checkMain(config);
+  console.log("");
+  if (checkResult.failed > 0) {
+    p.cancel("Health check has failures \u2014 fix the issues above before running smoke tests.");
+    process.exit(1);
+  }
+  const { main: testMain } = await Promise.resolve().then(() => (init_smoke_test(), smoke_test_exports));
+  const testResult = await testMain(config);
+  console.log("");
+  if (checkResult.failed === 0 && testResult.failed === 0) {
+    if (selectedAgents.includes("claude-code")) {
+      p.outro("Setup complete! Run: claude --plugin-dir ./plugins/typegraph-mcp");
+    } else {
+      p.outro("Setup complete! typegraph-mcp tools are now available to your agents.");
+    }
+  } else {
+    p.cancel("Setup completed with issues. Fix the failures above and re-run.");
+    process.exit(1);
+  }
+}
+async function remove(yes2) {
+  const projectRoot2 = process.cwd();
+  const pluginDir = path8.resolve(projectRoot2, PLUGIN_DIR_NAME);
+  process.stdout.write("\x1Bc");
+  p.intro("TypeGraph MCP Remove");
+  if (!fs7.existsSync(pluginDir)) {
+    p.cancel("typegraph-mcp is not installed in this project.");
+    process.exit(1);
+  }
+  if (!yes2) {
+    const confirmed = await p.confirm({ message: "Remove typegraph-mcp from this project?" });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("Removal cancelled.");
+      process.exit(0);
+    }
+  }
+  await removePlugin(projectRoot2, pluginDir);
+}
+async function check() {
+  const { main: checkMain } = await Promise.resolve().then(() => (init_check(), check_exports));
+  const result = await checkMain();
+  process.exit(result.failed > 0 ? 1 : 0);
+}
+async function test() {
+  const { main: testMain } = await Promise.resolve().then(() => (init_smoke_test(), smoke_test_exports));
+  const result = await testMain();
+  process.exit(result.failed > 0 ? 1 : 0);
+}
+async function start() {
+  await Promise.resolve().then(() => (init_server(), server_exports));
+}
+var args = process.argv.slice(2);
+var command = args.find((a) => !a.startsWith("-"));
+var yes = args.includes("--yes") || args.includes("-y");
+var help = args.includes("--help") || args.includes("-h");
+if (help || !command) {
+  console.log(HELP);
+  process.exit(0);
+}
+switch (command) {
+  case "setup":
+    setup(yes).catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
+  case "remove":
+    remove(yes).catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
+  case "check":
+    check().catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
+  case "test":
+    test().catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
+  case "start":
+    start().catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
+  default:
+    console.log(`Unknown command: ${command}`);
+    console.log("");
+    console.log(HELP);
+    process.exit(1);
+}