typegraph-mcp 0.9.19 → 0.9.21

package/dist/cli.js

@@ -13,11 +13,11 @@ var __export = (target, all) => {
 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 };
+  const projectRoot3 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir)) === "plugins" ? path.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath3 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot3 + path.sep);
+  const toolRelPath = toolIsEmbedded ? path.relative(projectRoot3, toolDir) : toolDir;
+  return { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir, toolIsEmbedded, toolRelPath };
 }
 var init_config = __esm({
   "config.ts"() {
@@ -111,36 +111,36 @@ function parseFileImports(filePath, source) {
   }
   return imports;
 }
-function distToSource(resolvedPath, projectRoot2) {
-  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
-  const rel2 = path2.relative(projectRoot2, resolvedPath);
+function distToSource(resolvedPath, projectRoot3) {
+  if (!resolvedPath.startsWith(projectRoot3)) return resolvedPath;
+  const rel2 = path2.relative(projectRoot3, resolvedPath);
   const distIdx = rel2.indexOf("dist" + path2.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 = path2.resolve(projectRoot2, prefix, "src", withoutExt + ext);
+    const candidate = path2.resolve(projectRoot3, prefix, "src", withoutExt + ext);
     if (fs.existsSync(candidate)) return candidate;
   }
   for (const ext of SOURCE_EXTS) {
-    const candidate = path2.resolve(projectRoot2, prefix, withoutExt + ext);
+    const candidate = path2.resolve(projectRoot3, prefix, withoutExt + ext);
     if (fs.existsSync(candidate)) return candidate;
   }
   if (withoutExt.endsWith("/index")) {
     const dirPath = withoutExt.slice(0, -6);
     for (const ext of SOURCE_EXTS) {
-      const candidate = path2.resolve(projectRoot2, prefix, "src", dirPath + ext);
+      const candidate = path2.resolve(projectRoot3, prefix, "src", dirPath + ext);
       if (fs.existsSync(candidate)) return candidate;
     }
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot2) {
+function resolveImport(resolver, fromDir, specifier, projectRoot3) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
-      const mapped = distToSource(result.path, projectRoot2);
+      const mapped = distToSource(result.path, projectRoot3);
       const ext = path2.extname(mapped);
       if (!TS_EXTENSIONS.has(ext)) return null;
       if (SKIP_FILES.has(path2.basename(mapped))) return null;
@@ -150,10 +150,10 @@ function resolveImport(resolver, fromDir, specifier, projectRoot2) {
   }
   return null;
 }
-function createResolver(projectRoot2, tsconfigPath2) {
+function createResolver(projectRoot3, tsconfigPath3) {
   return new ResolverFactory({
     tsconfig: {
-      configFile: path2.resolve(projectRoot2, tsconfigPath2),
+      configFile: path2.resolve(projectRoot3, tsconfigPath3),
       references: "auto"
     },
     extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
@@ -167,7 +167,7 @@ function createResolver(projectRoot2, tsconfigPath2) {
     mainFields: ["module", "main"]
   });
 }
-function buildForwardEdges(files, resolver, projectRoot2) {
+function buildForwardEdges(files, resolver, projectRoot3) {
   const forward = /* @__PURE__ */ new Map();
   const parseFailures = [];
   for (const filePath of files) {
@@ -187,7 +187,7 @@ function buildForwardEdges(files, resolver, projectRoot2) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot3);
       if (target) {
         edges.push({
           target,
@@ -221,12 +221,12 @@ function buildReverseMap(forward) {
   }
   return reverse;
 }
-async function buildGraph(projectRoot2, tsconfigPath2) {
+async function buildGraph(projectRoot3, tsconfigPath3) {
   const startTime = performance.now();
-  const resolver = createResolver(projectRoot2, tsconfigPath2);
-  const fileList = discoverFiles(projectRoot2);
+  const resolver = createResolver(projectRoot3, tsconfigPath3);
+  const fileList = discoverFiles(projectRoot3);
   log(`Discovered ${fileList.length} source files`);
-  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot2);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot3);
   const reverse = buildReverseMap(forward);
   const files = new Set(fileList);
   const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
@@ -240,7 +240,7 @@ async function buildGraph(projectRoot2, tsconfigPath2) {
     resolver
   };
 }
-function updateFile(graph, filePath, resolver, projectRoot2) {
+function updateFile(graph, filePath, resolver, projectRoot3) {
   const oldEdges = graph.forward.get(filePath) ?? [];
   for (const edge of oldEdges) {
     const revEdges = graph.reverse.get(edge.target);
@@ -268,7 +268,7 @@ function updateFile(graph, filePath, resolver, projectRoot2) {
   const fromDir = path2.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot3);
     if (target) {
       newEdges.push({
         target,
@@ -316,10 +316,10 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot2, graph, resolver) {
+function startWatcher(projectRoot3, graph, resolver) {
   try {
     const watcher = fs.watch(
-      projectRoot2,
+      projectRoot3,
       { recursive: true },
       (_eventType, filename) => {
         if (!filename) return;
@@ -330,9 +330,9 @@ function startWatcher(projectRoot2, graph, resolver) {
         if (SKIP_FILES.has(path2.basename(filename))) return;
         if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
           return;
-        const absPath2 = path2.resolve(projectRoot2, filename);
+        const absPath2 = path2.resolve(projectRoot3, filename);
         if (fs.existsSync(absPath2)) {
-          updateFile(graph, absPath2, resolver, projectRoot2);
+          updateFile(graph, absPath2, resolver, projectRoot3);
         } else {
           removeFile(graph, absPath2);
         }
@@ -394,23 +394,23 @@ function findFirstTsFile(dir) {
   }
   return null;
 }
-function testTsserver(projectRoot2) {
-  return new Promise((resolve8) => {
+function testTsserver(projectRoot3) {
+  return new Promise((resolve9) => {
     let tsserverPath;
     try {
-      const require2 = createRequire(path3.resolve(projectRoot2, "package.json"));
+      const require2 = createRequire(path3.resolve(projectRoot3, "package.json"));
       tsserverPath = require2.resolve("typescript/lib/tsserver.js");
     } catch {
-      resolve8(false);
+      resolve9(false);
       return;
     }
     const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
-      cwd: projectRoot2,
+      cwd: projectRoot3,
       stdio: ["pipe", "pipe", "pipe"]
     });
     const timeout = setTimeout(() => {
       child.kill();
-      resolve8(false);
+      resolve9(false);
     }, 1e4);
     let buffer = "";
     child.stdout.on("data", (chunk) => {
@@ -418,12 +418,12 @@ function testTsserver(projectRoot2) {
       if (buffer.includes('"success":true')) {
         clearTimeout(timeout);
         child.kill();
-        resolve8(true);
+        resolve9(true);
       }
     });
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve8(false);
+      resolve9(false);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
@@ -440,7 +440,7 @@ function testTsserver(projectRoot2) {
   });
 }
 async function main(configOverride) {
-  const { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
   let passed = 0;
   let failed = 0;
   let warned = 0;
@@ -464,7 +464,7 @@ async function main(configOverride) {
   console.log("");
   console.log("typegraph-mcp Health Check");
   console.log("=======================");
-  console.log(`Project root: ${projectRoot2}`);
+  console.log(`Project root: ${projectRoot3}`);
   console.log("");
   const nodeVersion = process.version;
   const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
@@ -473,7 +473,7 @@ async function main(configOverride) {
   } else {
     fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 18");
   }
-  const tsxInRoot = fs2.existsSync(path3.join(projectRoot2, "node_modules/.bin/tsx"));
+  const tsxInRoot = fs2.existsSync(path3.join(projectRoot3, "node_modules/.bin/tsx"));
   const tsxInTool = fs2.existsSync(path3.join(toolDir, "node_modules/.bin/tsx"));
   if (tsxInRoot || tsxInTool) {
     pass(`tsx available (in ${tsxInRoot ? "project" : "tool"} node_modules)`);
@@ -482,7 +482,7 @@ async function main(configOverride) {
   }
   let tsVersion = null;
   try {
-    const require2 = createRequire(path3.resolve(projectRoot2, "package.json"));
+    const require2 = createRequire(path3.resolve(projectRoot3, "package.json"));
     const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
     const tsPkgPath = path3.resolve(path3.dirname(tsserverPath), "..", "package.json");
     const tsPkg = JSON.parse(fs2.readFileSync(tsPkgPath, "utf-8"));
@@ -494,11 +494,11 @@ async function main(configOverride) {
       "Add `typescript` to devDependencies and run `npm install`"
     );
   }
-  const tsconfigAbs = path3.resolve(projectRoot2, tsconfigPath2);
+  const tsconfigAbs = path3.resolve(projectRoot3, tsconfigPath3);
   if (fs2.existsSync(tsconfigAbs)) {
-    pass(`tsconfig.json exists at ${tsconfigPath2}`);
+    pass(`tsconfig.json exists at ${tsconfigPath3}`);
   } else {
-    fail(`tsconfig.json not found at ${tsconfigPath2}`, `Create a tsconfig.json at ${tsconfigPath2}`);
+    fail(`tsconfig.json not found at ${tsconfigPath3}`, `Create a tsconfig.json at ${tsconfigPath3}`);
   }
   const pluginMcpPath = path3.join(toolDir, ".mcp.json");
   const hasPluginMcp = fs2.existsSync(pluginMcpPath) && fs2.existsSync(path3.join(toolDir, ".claude-plugin/plugin.json"));
@@ -507,7 +507,7 @@ async function main(configOverride) {
   } else if (hasPluginMcp) {
     pass("MCP registered via plugin (.mcp.json + .claude-plugin/ present)");
   } else {
-    const mcpJsonPath = path3.resolve(projectRoot2, ".claude/mcp.json");
+    const mcpJsonPath = path3.resolve(projectRoot3, ".claude/mcp.json");
     if (fs2.existsSync(mcpJsonPath)) {
       try {
         const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
@@ -595,7 +595,7 @@ async function main(configOverride) {
       extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
     });
     let resolveOk = false;
-    const testFile = findFirstTsFile(projectRoot2);
+    const testFile = findFirstTsFile(projectRoot3);
     if (testFile) {
       const dir = path3.dirname(testFile);
       const base = "./" + path3.basename(testFile);
@@ -618,7 +618,7 @@ async function main(configOverride) {
   }
   if (tsVersion) {
     try {
-      const ok = await testTsserver(projectRoot2);
+      const ok = await testTsserver(projectRoot3);
       if (ok) {
         pass("tsserver responds to configure");
       } else {
@@ -644,7 +644,7 @@ async function main(configOverride) {
       ({ buildGraph: buildGraph2 } = await Promise.resolve().then(() => (init_module_graph(), module_graph_exports)));
     }
     const start2 = performance.now();
-    const { graph } = await buildGraph2(projectRoot2, tsconfigPath2);
+    const { graph } = await buildGraph2(projectRoot3, tsconfigPath3);
     const elapsed = (performance.now() - start2).toFixed(0);
     const edgeCount = [...graph.forward.values()].reduce(
       (s, e) => s + e.length,
@@ -670,7 +670,7 @@ async function main(configOverride) {
     );
   }
   if (toolIsEmbedded) {
-    const eslintConfigPath = path3.resolve(projectRoot2, "eslint.config.mjs");
+    const eslintConfigPath = path3.resolve(projectRoot3, "eslint.config.mjs");
     if (fs2.existsSync(eslintConfigPath)) {
       const eslintContent = fs2.readFileSync(eslintConfigPath, "utf-8");
       const parentDir = path3.basename(path3.dirname(toolDir));
@@ -691,7 +691,7 @@ async function main(configOverride) {
   } else {
     skip("ESLint config check (typegraph-mcp is external to project)");
   }
-  const gitignorePath = path3.resolve(projectRoot2, ".gitignore");
+  const gitignorePath = path3.resolve(projectRoot3, ".gitignore");
   if (fs2.existsSync(gitignorePath)) {
     const gitignoreContent = fs2.readFileSync(gitignorePath, "utf-8");
     const lines = gitignoreContent.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
@@ -745,9 +745,9 @@ var init_tsserver_client = __esm({
     log2 = (...args2) => console.error("[typegraph/tsserver]", ...args2);
     REQUEST_TIMEOUT_MS = 1e4;
     TsServerClient = class {
-      constructor(projectRoot2, tsconfigPath2 = "./tsconfig.json") {
-        this.projectRoot = projectRoot2;
-        this.tsconfigPath = tsconfigPath2;
+      constructor(projectRoot3, tsconfigPath3 = "./tsconfig.json") {
+        this.projectRoot = projectRoot3;
+        this.tsconfigPath = tsconfigPath3;
       }
       child = null;
       seq = 0;
@@ -910,12 +910,12 @@ var init_tsserver_client = __esm({
           command: command2,
           arguments: args2
         };
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, 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.pending.set(seq, { resolve: resolve9, reject, timer, command: command2 });
           this.child.stdin.write(JSON.stringify(request) + "\n");
         });
       }
@@ -1287,8 +1287,8 @@ __export(smoke_test_exports, {
 });
 import * as fs5 from "fs";
 import * as path6 from "path";
-function rel(absPath2, projectRoot2) {
-  return path6.relative(projectRoot2, absPath2);
+function rel(absPath2, projectRoot3) {
+  return path6.relative(projectRoot3, absPath2);
 }
 function findInNavBar(items, predicate) {
   for (const item of items) {
@@ -1345,7 +1345,7 @@ function findImporter(graph, file) {
   return (preferred ?? revEdges[0]).target;
 }
 async function main2(configOverride) {
-  const { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2 } = configOverride ?? resolveConfig(import.meta.dirname);
+  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3 } = configOverride ?? resolveConfig(import.meta.dirname);
   let passed = 0;
   let failed = 0;
   let skipped = 0;
@@ -1366,14 +1366,14 @@ async function main2(configOverride) {
   console.log("");
   console.log("typegraph-mcp Smoke Test");
   console.log("=====================");
-  console.log(`Project root: ${projectRoot2}`);
+  console.log(`Project root: ${projectRoot3}`);
   console.log("");
-  const testFile = findTestFile(projectRoot2);
+  const testFile = findTestFile(projectRoot3);
   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);
+  const testFileRel = rel(testFile, projectRoot3);
   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");
@@ -1381,7 +1381,7 @@ async function main2(configOverride) {
   let t0;
   t0 = performance.now();
   try {
-    const result = await buildGraph(projectRoot2, tsconfigPath2);
+    const result = await buildGraph(projectRoot3, tsconfigPath3);
     graph = result.graph;
     const ms = performance.now() - t0;
     const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
@@ -1432,9 +1432,9 @@ async function main2(configOverride) {
     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);
+      pass("shortest_path", `${result.hops} hops: ${result.path.map((p2) => rel(p2, projectRoot3)).join(" -> ")}`, ms);
     } else {
-      pass("shortest_path", `No path from ${rel(importer, projectRoot2)} (may be type-only)`, ms);
+      pass("shortest_path", `No path from ${rel(importer, projectRoot3)} (may be type-only)`, ms);
     }
   } else {
     skip("shortest_path", "No importer found for test file");
@@ -1457,15 +1457,15 @@ async function main2(configOverride) {
     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`,
+      `${siblings.length} files in ${rel(dir, projectRoot3)}/: ${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)}/`);
+    skip("module_boundary", `Only ${siblings.length} file(s) in ${rel(dir, projectRoot3)}/`);
   }
   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);
+  const client2 = new TsServerClient(projectRoot3, tsconfigPath3);
   t0 = performance.now();
   await client2.start();
   console.log(`  (started in ${(performance.now() - t0).toFixed(0)}ms)`);
@@ -1662,17 +1662,536 @@ var init_smoke_test = __esm({
   }
 });
 
+// benchmark.ts
+var benchmark_exports = {};
+__export(benchmark_exports, {
+  main: () => main3
+});
+import * as fs6 from "fs";
+import * as path7 from "path";
+import { execSync } from "child_process";
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function grepCount(pattern) {
+  try {
+    const result = execSync(
+      `grep -r --include='*.ts' --include='*.tsx' -l "${pattern}" . 2>/dev/null || true`,
+      { cwd: projectRoot, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    ).trim();
+    const files = result ? result.split("\n").filter(Boolean) : [];
+    const countResult = execSync(
+      `grep -r --include='*.ts' --include='*.tsx' -c "${pattern}" . 2>/dev/null || true`,
+      { cwd: projectRoot, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    ).trim();
+    const matches = countResult.split("\n").filter(Boolean).reduce((sum, line) => {
+      const count = parseInt(line.split(":").pop(), 10);
+      return sum + (isNaN(count) ? 0 : count);
+    }, 0);
+    let totalBytes = 0;
+    for (const file of files) {
+      try {
+        totalBytes += fs6.statSync(path7.resolve(projectRoot, file)).size;
+      } catch {
+      }
+    }
+    return { matches, files: files.length, totalBytes };
+  } catch {
+    return { matches: 0, files: 0, totalBytes: 0 };
+  }
+}
+function relPath(abs) {
+  return path7.relative(projectRoot, abs);
+}
+function percentile(sorted, p2) {
+  const idx = Math.ceil(p2 / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function flattenNavBar(items) {
+  const result = [];
+  for (const item of items) {
+    result.push(item);
+    if (item.childItems?.length > 0) result.push(...flattenNavBar(item.childItems));
+  }
+  return result;
+}
+function findBarrelChain(graph) {
+  const barrels = [...graph.files].filter((f) => path7.basename(f) === "index.ts");
+  for (const barrel of barrels) {
+    const edges = graph.forward.get(barrel) ?? [];
+    for (const edge of edges) {
+      if (edge.specifiers.length > 0 && !edge.specifiers.includes("*") && !edge.target.endsWith("index.ts") && !edge.isTypeOnly) {
+        const parentBarrels = (graph.reverse.get(barrel) ?? []).filter(
+          (e) => path7.basename(e.target) === "index.ts"
+        );
+        if (parentBarrels.length > 0) {
+          return { barrelFile: barrel, sourceFile: edge.target, specifiers: edge.specifiers };
+        }
+      }
+    }
+  }
+  for (const barrel of barrels) {
+    const edges = graph.forward.get(barrel) ?? [];
+    for (const edge of edges) {
+      if (edge.specifiers.length > 0 && !edge.specifiers.includes("*") && !edge.target.endsWith("index.ts")) {
+        return { barrelFile: barrel, sourceFile: edge.target, specifiers: edge.specifiers };
+      }
+    }
+  }
+  return null;
+}
+function findHighFanoutSymbol(graph) {
+  const specCounts = /* @__PURE__ */ new Map();
+  for (const edges of graph.forward.values()) {
+    for (const edge of edges) {
+      for (const spec of edge.specifiers) {
+        if (spec === "*" || spec === "default" || spec.length < 4) continue;
+        specCounts.set(spec, (specCounts.get(spec) ?? 0) + 1);
+      }
+    }
+  }
+  const sorted = [...specCounts.entries()].sort((a, b) => b[1] - a[1]);
+  return sorted[0]?.[0] ?? null;
+}
+function findPrefixSymbol(graph) {
+  const specCounts = /* @__PURE__ */ new Map();
+  for (const edges of graph.forward.values()) {
+    for (const edge of edges) {
+      for (const spec of edge.specifiers) {
+        if (spec === "*" || spec === "default" || spec.length < 5) continue;
+        specCounts.set(spec, (specCounts.get(spec) ?? 0) + 1);
+      }
+    }
+  }
+  const allSpecs = [...specCounts.keys()];
+  for (const [base, count] of [...specCounts.entries()].sort((a, b) => b[1] - a[1])) {
+    if (count < 3) continue;
+    const variants = allSpecs.filter((s) => s !== base && s.startsWith(base) && s[base.length]?.match(/[A-Z]/));
+    if (variants.length >= 2) {
+      return { base, variants: variants.slice(0, 5) };
+    }
+  }
+  return null;
+}
+function findMixedImportFile(graph) {
+  for (const [file, edges] of graph.forward) {
+    const hasTypeOnly = edges.some((e) => e.isTypeOnly);
+    const hasRuntime = edges.some((e) => !e.isTypeOnly);
+    if (hasTypeOnly && hasRuntime && edges.length >= 4) {
+      return file;
+    }
+  }
+  return null;
+}
+function findMostDependedFile(graph) {
+  let maxDeps = 0;
+  let maxFile = null;
+  for (const [file, revEdges] of graph.reverse) {
+    if (file.endsWith("index.ts")) continue;
+    if (revEdges.length > maxDeps) {
+      maxDeps = revEdges.length;
+      maxFile = file;
+    }
+  }
+  return maxFile;
+}
+function findChainFile(graph) {
+  for (const [file, edges] of graph.forward) {
+    if (file.endsWith("index.ts") || file.includes(".test.")) continue;
+    for (const edge of edges) {
+      if (edge.isTypeOnly || edge.specifiers.includes("*")) continue;
+      const targetEdges = graph.forward.get(edge.target) ?? [];
+      const nonTrivialTarget = targetEdges.filter((e) => !e.isTypeOnly && !e.specifiers.includes("*"));
+      if (nonTrivialTarget.length > 0 && edge.specifiers.length > 0) {
+        return { file, symbol: edge.specifiers[0] };
+      }
+    }
+  }
+  return null;
+}
+function findLatencyTestFile(graph) {
+  const candidates = [...graph.files].filter((f) => !f.endsWith("index.ts") && !f.includes(".test.") && !f.includes(".spec.")).map((f) => {
+    try {
+      return { file: f, size: fs6.statSync(f).size };
+    } catch {
+      return null;
+    }
+  }).filter((c) => c !== null && c.size > 500 && c.size < 3e4).sort((a, b) => b.size - a.size);
+  const preferred = candidates.find(
+    (c) => /service|handler|controller|repository|provider/i.test(path7.basename(c.file))
+  );
+  return preferred?.file ?? candidates[0]?.file ?? null;
+}
+async function benchmarkTokens(client2, graph) {
+  console.log("=== Benchmark 1: Token Comparison (grep vs typegraph-mcp) ===");
+  console.log("");
+  const scenarios = [];
+  const barrel = findBarrelChain(graph);
+  if (barrel) {
+    const symbol = barrel.specifiers[0];
+    const grep = grepCount(symbol);
+    const grepTokens = estimateTokens("x".repeat(Math.min(grep.totalBytes, 5e5)));
+    const navItems = await client2.navto(symbol, 5);
+    const def = navItems.find((i) => i.name === symbol);
+    let responseText = JSON.stringify({ results: navItems, count: navItems.length });
+    if (def) {
+      const defs = await client2.definition(def.file, def.start.line, def.start.offset);
+      responseText += JSON.stringify({ definitions: defs });
+    }
+    scenarios.push({
+      name: "Barrel re-export resolution",
+      symbol,
+      description: `Re-exported through ${relPath(barrel.barrelFile)}`,
+      grep: { matches: grep.matches, files: grep.files, tokensToRead: grepTokens },
+      typegraph: { responseTokens: estimateTokens(responseText), toolCalls: 2 },
+      reduction: grepTokens > 0 ? `${((1 - estimateTokens(responseText) / grepTokens) * 100).toFixed(0)}%` : "N/A"
+    });
+  }
+  const highFanout = findHighFanoutSymbol(graph);
+  if (highFanout) {
+    const grep = grepCount(highFanout);
+    const grepTokens = estimateTokens("x".repeat(Math.min(grep.totalBytes, 5e5)));
+    const navItems = await client2.navto(highFanout, 10);
+    const refs = navItems.length > 0 ? await client2.references(navItems[0].file, navItems[0].start.line, navItems[0].start.offset) : [];
+    const responseText = JSON.stringify({ results: navItems }) + JSON.stringify({ count: refs.length });
+    scenarios.push({
+      name: "High-fanout symbol lookup",
+      symbol: highFanout,
+      description: `Most-imported symbol in the project`,
+      grep: { matches: grep.matches, files: grep.files, tokensToRead: grepTokens },
+      typegraph: { responseTokens: estimateTokens(responseText), toolCalls: 2 },
+      reduction: grepTokens > 0 ? `${((1 - estimateTokens(responseText) / grepTokens) * 100).toFixed(0)}%` : "N/A"
+    });
+  }
+  const chainTarget = findChainFile(graph);
+  if (chainTarget) {
+    const grep = grepCount(chainTarget.symbol);
+    const grepTokens = estimateTokens("x".repeat(Math.min(grep.totalBytes, 5e5)));
+    const navItems = await client2.navto(chainTarget.symbol, 5);
+    let totalResponse = JSON.stringify({ results: navItems });
+    let hops = 0;
+    if (navItems.length > 0) {
+      let cur = { file: navItems[0].file, line: navItems[0].start.line, offset: navItems[0].start.offset };
+      for (let i = 0; i < 5; i++) {
+        const defs = await client2.definition(cur.file, cur.line, cur.offset);
+        if (defs.length === 0) break;
+        const hop = defs[0];
+        if (hop.file === cur.file && hop.start.line === cur.line) break;
+        if (hop.file.includes("node_modules")) break;
+        hops++;
+        totalResponse += JSON.stringify({ definitions: defs });
+        cur = { file: hop.file, line: hop.start.line, offset: hop.start.offset };
+      }
+    }
+    scenarios.push({
+      name: "Call chain tracing",
+      symbol: chainTarget.symbol,
+      description: `${hops} hop(s) from ${relPath(chainTarget.file)}`,
+      grep: { matches: grep.matches, files: grep.files, tokensToRead: grepTokens },
+      typegraph: { responseTokens: estimateTokens(totalResponse), toolCalls: 1 + hops },
+      reduction: grepTokens > 0 ? `${((1 - estimateTokens(totalResponse) / grepTokens) * 100).toFixed(0)}%` : "N/A"
+    });
+  }
+  const mostDepended = findMostDependedFile(graph);
+  if (mostDepended) {
+    const basename8 = path7.basename(mostDepended, path7.extname(mostDepended));
+    const grep = grepCount(basename8);
+    const grepTokens = estimateTokens("x".repeat(Math.min(grep.totalBytes, 5e5)));
+    const deps = dependents(graph, mostDepended);
+    const responseText = JSON.stringify({
+      root: relPath(mostDepended),
+      nodes: deps.nodes,
+      directCount: deps.directCount,
+      byPackage: deps.byPackage
+    });
+    scenarios.push({
+      name: "Impact analysis (most-depended file)",
+      symbol: basename8,
+      description: `${relPath(mostDepended)} \u2014 ${deps.directCount} direct, ${deps.nodes} transitive`,
+      grep: { matches: grep.matches, files: grep.files, tokensToRead: grepTokens },
+      typegraph: { responseTokens: estimateTokens(responseText), toolCalls: 1 },
+      reduction: grepTokens > 0 ? `${((1 - estimateTokens(responseText) / grepTokens) * 100).toFixed(0)}%` : "N/A"
+    });
+  }
+  if (scenarios.length > 0) {
+    console.log("| Scenario | Symbol | grep matches | grep files | grep tokens | tg tokens | tg calls | reduction |");
+    console.log("|----------|--------|-------------|-----------|-------------|-----------|----------|-----------|");
+    for (const s of scenarios) {
+      console.log(
+        `| ${s.name} | \`${s.symbol}\` | ${s.grep.matches} | ${s.grep.files} | ${s.grep.tokensToRead.toLocaleString()} | ${s.typegraph.responseTokens.toLocaleString()} | ${s.typegraph.toolCalls} | ${s.reduction} |`
+      );
+    }
+  } else {
+    console.log("  No suitable scenarios discovered for this codebase.");
+  }
+  console.log("");
+  return scenarios;
+}
+async function benchmarkLatency(client2, graph) {
+  console.log("=== Benchmark 2: Latency (ms per tool call) ===");
+  console.log("");
+  const results = [];
+  const RUNS = 5;
+  const testFile = findLatencyTestFile(graph);
+  if (!testFile) {
+    console.log("  No suitable test file found for latency benchmark.");
+    console.log("");
+    return results;
+  }
+  const testFileRel = relPath(testFile);
+  console.log(`Test file: ${testFileRel}`);
+  console.log(`Runs per tool: ${RUNS}`);
+  console.log("");
+  const bar = await client2.navbar(testFileRel);
+  const allSymbols = flattenNavBar(bar);
+  const concreteKinds = /* @__PURE__ */ new Set(["const", "function", "class", "var", "let", "enum"]);
+  const sym = allSymbols.find(
+    (item) => concreteKinds.has(item.kind) && item.text !== "<function>" && item.spans.length > 0
+  );
+  if (!sym) {
+    console.log("  No concrete symbol found in test file.");
+    console.log("");
+    return results;
+  }
+  const span = sym.spans[0];
+  console.log(`Test symbol: ${sym.text} [${sym.kind}]`);
+  console.log("");
+  const tsserverTools = [
+    { name: "ts_find_symbol", fn: () => client2.navbar(testFileRel) },
+    { name: "ts_definition", fn: () => client2.definition(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_references", fn: () => client2.references(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_type_info", fn: () => client2.quickinfo(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_navigate_to", fn: () => client2.navto(sym.text, 10) },
+    { name: "ts_module_exports", fn: () => client2.navbar(testFileRel) }
+  ];
+  for (const tool of tsserverTools) {
+    const times = [];
+    for (let i = 0; i < RUNS; i++) {
+      const t0 = performance.now();
+      await tool.fn();
+      times.push(performance.now() - t0);
+    }
+    times.sort((a, b) => a - b);
+    results.push({
+      tool: tool.name,
+      runs: RUNS,
+      p50: percentile(times, 50),
+      p95: percentile(times, 95),
+      avg: times.reduce((a, b) => a + b, 0) / times.length,
+      min: times[0],
+      max: times[times.length - 1]
+    });
+  }
+  const graphTools = [
+    { name: "ts_dependency_tree", fn: () => dependencyTree(graph, testFile) },
+    { name: "ts_dependents", fn: () => dependents(graph, testFile) },
+    { name: "ts_import_cycles", fn: () => importCycles(graph) },
+    {
+      name: "ts_shortest_path",
+      fn: () => {
+        const rev = graph.reverse.get(testFile);
+        if (rev && rev.length > 0) return shortestPath(graph, rev[0].target, testFile);
+        return null;
+      }
+    },
+    { name: "ts_subgraph", fn: () => subgraph(graph, [testFile], { depth: 2, direction: "both" }) },
+    {
+      name: "ts_module_boundary",
+      fn: () => {
+        const dir = path7.dirname(testFile);
+        const siblings = [...graph.files].filter((f) => path7.dirname(f) === dir);
+        return moduleBoundary(graph, siblings);
+      }
+    }
+  ];
+  for (const tool of graphTools) {
+    const times = [];
+    for (let i = 0; i < RUNS; i++) {
+      const t0 = performance.now();
+      tool.fn();
+      times.push(performance.now() - t0);
+    }
+    times.sort((a, b) => a - b);
+    results.push({
+      tool: tool.name,
+      runs: RUNS,
+      p50: percentile(times, 50),
+      p95: percentile(times, 95),
+      avg: times.reduce((a, b) => a + b, 0) / times.length,
+      min: times[0],
+      max: times[times.length - 1]
+    });
+  }
+  console.log("| Tool | p50 | p95 | avg | min | max |");
+  console.log("|------|-----|-----|-----|-----|-----|");
+  for (const r of results) {
+    console.log(
+      `| ${r.tool} | ${r.p50.toFixed(1)}ms | ${r.p95.toFixed(1)}ms | ${r.avg.toFixed(1)}ms | ${r.min.toFixed(1)}ms | ${r.max.toFixed(1)}ms |`
+    );
+  }
+  console.log("");
+  return results;
+}
+async function benchmarkAccuracy(client2, graph) {
+  console.log("=== Benchmark 3: Accuracy (grep vs typegraph-mcp) ===");
+  console.log("");
+  const scenarios = [];
+  const barrel = findBarrelChain(graph);
+  if (barrel) {
+    const symbol = barrel.specifiers[0];
+    const grep = grepCount(symbol);
+    const navItems = await client2.navto(symbol, 10);
+    const defItem = navItems.find((i) => i.name === symbol && i.matchKind === "exact");
+    let defLocation = "";
+    if (defItem) {
+      const defs = await client2.definition(defItem.file, defItem.start.line, defItem.start.offset);
+      if (defs.length > 0) {
+        defLocation = `${defs[0].file}:${defs[0].start.line}`;
+      }
+    }
+    scenarios.push({
+      name: "Barrel file resolution",
+      description: `Find where \`${symbol}\` is actually defined (not re-exported)`,
+      grepResult: `${grep.matches} matches across ${grep.files} files \u2014 agent must read files to distinguish definition from re-exports`,
+      typegraphResult: defLocation ? `Direct: ${defLocation} (1 tool call)` : `Found ${navItems.length} declarations via navto`,
+      verdict: "typegraph wins"
+    });
+  }
+  const prefixSymbol = findPrefixSymbol(graph);
+  if (prefixSymbol) {
+    const grep = grepCount(prefixSymbol.base);
+    const grepVariants = grepCount(`${prefixSymbol.base}[A-Z]`);
+    const navItems = await client2.navto(prefixSymbol.base, 10);
+    const exactMatches = navItems.filter((i) => i.name === prefixSymbol.base);
+    scenarios.push({
+      name: "Same-name disambiguation",
+      description: `Distinguish \`${prefixSymbol.base}\` from ${prefixSymbol.variants.map((v) => `\`${v}\``).join(", ")}`,
+      grepResult: `${grep.matches} total matches (includes ${grepVariants.matches} variant-name matches sharing the prefix)`,
+      typegraphResult: `${exactMatches.length} exact match(es): ${exactMatches.map((i) => `${i.file}:${i.start.line} [${i.kind}]`).join(", ")}`,
+      verdict: "typegraph wins"
+    });
+  }
+  const mixedFile = findMixedImportFile(graph);
+  if (mixedFile) {
+    const fwdEdges = graph.forward.get(mixedFile) ?? [];
+    const typeOnly = fwdEdges.filter((e) => e.isTypeOnly);
+    const runtime = fwdEdges.filter((e) => !e.isTypeOnly);
+    scenarios.push({
+      name: "Type-only vs runtime imports",
+      description: `In \`${relPath(mixedFile)}\`, distinguish type-only from runtime imports`,
+      grepResult: `grep "import" shows all imports without distinguishing \`import type\` \u2014 agent must parse each line manually`,
+      typegraphResult: `${typeOnly.length} type-only imports, ${runtime.length} runtime imports (module graph distinguishes automatically)`,
+      verdict: "typegraph wins"
+    });
+  }
+  const mostDepended = findMostDependedFile(graph);
+  if (mostDepended) {
+    const basename8 = path7.basename(mostDepended, path7.extname(mostDepended));
+    const grep = grepCount(basename8);
+    const deps = dependents(graph, mostDepended);
+    const byPackageSummary = Object.entries(deps.byPackage).map(([pkg, files]) => `${pkg}: ${files.length}`).join(", ");
+    scenarios.push({
+      name: "Cross-package impact analysis",
+      description: `Find everything that depends on \`${relPath(mostDepended)}\``,
+      grepResult: `grep for "${basename8}" finds ${grep.matches} matches \u2014 cannot distinguish direct vs transitive, cannot follow re-exports`,
+      typegraphResult: `${deps.directCount} direct dependents, ${deps.nodes} total (transitive)${byPackageSummary ? `. By package: ${byPackageSummary}` : ""}`,
+      verdict: "typegraph wins"
+    });
+  }
+  {
+    const cycles = importCycles(graph);
+    const cycleDetail = cycles.cycles.length > 0 ? cycles.cycles.slice(0, 3).map((c) => c.map(relPath).join(" -> ")).join("; ") : "none";
+    scenarios.push({
+      name: "Circular dependency detection",
+      description: "Find all circular import chains in the project",
+      grepResult: "Impossible with grep \u2014 requires full graph analysis",
+      typegraphResult: `${cycles.count} cycle(s)${cycles.count > 0 ? `: ${cycleDetail}` : ""}`,
+      verdict: "typegraph wins"
+    });
+  }
+  for (const s of scenarios) {
+    console.log(`### ${s.name}`);
+    console.log(`${s.description}`);
+    console.log(`  grep:      ${s.grepResult}`);
+    console.log(`  typegraph: ${s.typegraphResult}`);
+    console.log(`  verdict:   ${s.verdict}`);
+    console.log("");
+  }
+  return scenarios;
+}
+async function main3(config) {
+  ({ projectRoot, tsconfigPath } = config ?? resolveConfig(import.meta.dirname));
+  console.log("");
+  console.log("typegraph-mcp Benchmark");
+  console.log("=======================");
+  console.log(`Project: ${projectRoot}`);
+  console.log("");
+  const graphStart = performance.now();
+  const { graph } = await buildGraph(projectRoot, tsconfigPath);
+  const graphMs = performance.now() - graphStart;
+  const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
+  console.log(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${graphMs.toFixed(0)}ms]`);
+  console.log("");
+  const client2 = new TsServerClient(projectRoot, tsconfigPath);
+  const tsStart = performance.now();
+  await client2.start();
+  console.log(`tsserver ready [${(performance.now() - tsStart).toFixed(0)}ms]`);
+  const warmFile = [...graph.files][0];
+  await client2.navbar(relPath(warmFile));
+  console.log("");
+  const tokenResults = await benchmarkTokens(client2, graph);
+  const latencyResults = await benchmarkLatency(client2, graph);
+  const accuracyResults = await benchmarkAccuracy(client2, graph);
+  console.log("=== Summary ===");
+  console.log("");
+  if (tokenResults.length > 0) {
+    const avgReduction = tokenResults.reduce((sum, s) => {
+      const pct = parseFloat(s.reduction);
+      return sum + (isNaN(pct) ? 0 : pct);
+    }, 0) / tokenResults.length;
+    console.log(`Average token reduction: ${avgReduction.toFixed(0)}%`);
+  }
+  const tsserverLatencies = latencyResults.filter(
+    (r) => ["ts_find_symbol", "ts_definition", "ts_references", "ts_type_info", "ts_navigate_to", "ts_module_exports"].includes(r.tool)
+  );
+  const graphLatencies = latencyResults.filter((r) => !tsserverLatencies.includes(r));
+  if (tsserverLatencies.length > 0) {
+    const tsAvg = tsserverLatencies.reduce((s, r) => s + r.avg, 0) / tsserverLatencies.length;
+    console.log(`Average tsserver query: ${tsAvg.toFixed(1)}ms`);
+  }
+  if (graphLatencies.length > 0) {
+    const graphAvg = graphLatencies.reduce((s, r) => s + r.avg, 0) / graphLatencies.length;
+    console.log(`Average graph query: ${graphAvg.toFixed(1)}ms`);
+  }
+  console.log(`Accuracy scenarios: ${accuracyResults.filter((s) => s.verdict === "typegraph wins").length}/${accuracyResults.length} typegraph wins`);
+  console.log("");
+  client2.shutdown();
+}
+var projectRoot, tsconfigPath;
+var init_benchmark = __esm({
+  "benchmark.ts"() {
+    init_tsserver_client();
+    init_module_graph();
+    init_graph_queries();
+    init_config();
+    main3().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";
+import * as fs7 from "fs";
+import * as path8 from "path";
 function readPreview(file, line) {
   try {
     const absPath2 = client.resolvePath(file);
-    const content = fs6.readFileSync(absPath2, "utf-8");
+    const content = fs7.readFileSync(absPath2, "utf-8");
     return content.split("\n")[line - 1]?.trim() ?? "";
   } catch {
     return "";
@@ -1730,36 +2249,36 @@ async function resolveParams(params) {
   }
   return { error: "Either line+column or symbol must be provided" };
 }
-function relPath(absPath2) {
-  return path7.relative(projectRoot, absPath2);
+function relPath2(absPath2) {
+  return path8.relative(projectRoot2, absPath2);
 }
 function absPath(file) {
-  return path7.isAbsolute(file) ? file : path7.resolve(projectRoot, file);
+  return path8.isAbsolute(file) ? file : path8.resolve(projectRoot2, file);
 }
-async function main3() {
+async function main4() {
   log3("Starting TypeGraph MCP server...");
-  log3(`Project root: ${projectRoot}`);
-  log3(`tsconfig: ${tsconfigPath}`);
+  log3(`Project root: ${projectRoot2}`);
+  log3(`tsconfig: ${tsconfigPath2}`);
   const [, graphResult] = await Promise.all([
     client.start(),
-    buildGraph(projectRoot, tsconfigPath)
+    buildGraph(projectRoot2, tsconfigPath2)
   ]);
   moduleGraph = graphResult.graph;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot2, 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 projectRoot2, tsconfigPath2, 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));
+    ({ projectRoot: projectRoot2, tsconfigPath: tsconfigPath2 } = resolveConfig(import.meta.dirname));
     log3 = (...args2) => console.error("[typegraph]", ...args2);
-    client = new TsServerClient(projectRoot, tsconfigPath);
+    client = new TsServerClient(projectRoot2, tsconfigPath2);
     mcpServer = new McpServer({
       name: "typegraph",
       version: "1.0.0"
@@ -2102,9 +2621,9 @@ var init_server = __esm({
             {
               type: "text",
               text: JSON.stringify({
-                root: relPath(result.root),
+                root: relPath2(result.root),
                 nodes: result.nodes,
-                files: result.files.map(relPath)
+                files: result.files.map(relPath2)
               })
             }
           ]
@@ -2123,17 +2642,17 @@ var init_server = __esm({
         const result = dependents(moduleGraph, absPath(file), { depth, includeTypeOnly });
         const byPackageRel = {};
         for (const [pkg, files] of Object.entries(result.byPackage)) {
-          byPackageRel[pkg] = files.map(relPath);
+          byPackageRel[pkg] = files.map(relPath2);
         }
         return {
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                root: relPath(result.root),
+                root: relPath2(result.root),
                 nodes: result.nodes,
                 directCount: result.directCount,
-                files: result.files.map(relPath),
+                files: result.files.map(relPath2),
                 byPackage: byPackageRel
               })
             }
@@ -2159,7 +2678,7 @@ var init_server = __esm({
               type: "text",
               text: JSON.stringify({
                 count: result.count,
-                cycles: result.cycles.map((cycle) => cycle.map(relPath))
+                cycles: result.cycles.map((cycle) => cycle.map(relPath2))
               })
             }
           ]
@@ -2181,10 +2700,10 @@ var init_server = __esm({
             {
               type: "text",
               text: JSON.stringify({
-                path: result.path?.map(relPath) ?? null,
+                path: result.path?.map(relPath2) ?? null,
                 hops: result.hops,
                 chain: result.chain.map((c) => ({
-                  file: relPath(c.file),
+                  file: relPath2(c.file),
                   imports: c.imports
                 }))
               })
@@ -2208,10 +2727,10 @@ var init_server = __esm({
             {
               type: "text",
               text: JSON.stringify({
-                nodes: result.nodes.map(relPath),
+                nodes: result.nodes.map(relPath2),
                 edges: result.edges.map((e) => ({
-                  from: relPath(e.from),
-                  to: relPath(e.to),
+                  from: relPath2(e.from),
+                  to: relPath2(e.to),
                   specifiers: e.specifiers,
                   isTypeOnly: e.isTypeOnly
                 })),
@@ -2237,16 +2756,16 @@ var init_server = __esm({
               text: JSON.stringify({
                 internalEdges: result.internalEdges,
                 incomingEdges: result.incomingEdges.map((e) => ({
-                  from: relPath(e.from),
-                  to: relPath(e.to),
+                  from: relPath2(e.from),
+                  to: relPath2(e.to),
                   specifiers: e.specifiers
                 })),
                 outgoingEdges: result.outgoingEdges.map((e) => ({
-                  from: relPath(e.from),
-                  to: relPath(e.to),
+                  from: relPath2(e.from),
+                  to: relPath2(e.to),
                   specifiers: e.specifiers
                 })),
-                sharedDependencies: result.sharedDependencies.map(relPath),
+                sharedDependencies: result.sharedDependencies.map(relPath2),
                 isolationScore: Math.round(result.isolationScore * 1e3) / 1e3
               })
             }
@@ -2263,7 +2782,7 @@ var init_server = __esm({
       client.shutdown();
       process.exit(0);
     });
-    main3().catch((err) => {
+    main4().catch((err) => {
       log3("Fatal error:", err);
       process.exit(1);
     });
@@ -2272,9 +2791,9 @@ var init_server = __esm({
 
 // cli.ts
 init_config();
-import * as fs7 from "fs";
-import * as path8 from "path";
-import { execSync } from "child_process";
+import * as fs8 from "fs";
+import * as path9 from "path";
+import { execSync as execSync2 } from "child_process";
 import * as p from "@clack/prompts";
 var AGENT_SNIPPET = `
 ## TypeScript Navigation (typegraph-mcp)
@@ -2300,35 +2819,35 @@ var AGENTS = {
     ],
     agentFile: "CLAUDE.md",
     needsAgentsSkills: false,
-    detect: (root) => fs7.existsSync(path8.join(root, "CLAUDE.md")) || fs7.existsSync(path8.join(root, ".claude"))
+    detect: (root) => fs8.existsSync(path9.join(root, "CLAUDE.md")) || fs8.existsSync(path9.join(root, ".claude"))
   },
   cursor: {
     name: "Cursor",
     pluginFiles: [".cursor-plugin/plugin.json"],
     agentFile: null,
     needsAgentsSkills: false,
-    detect: (root) => fs7.existsSync(path8.join(root, ".cursor"))
+    detect: (root) => fs8.existsSync(path9.join(root, ".cursor"))
   },
   codex: {
     name: "Codex CLI",
     pluginFiles: [],
     agentFile: "AGENTS.md",
     needsAgentsSkills: true,
-    detect: (root) => fs7.existsSync(path8.join(root, "AGENTS.md"))
+    detect: (root) => fs8.existsSync(path9.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"))
+    detect: (root) => fs8.existsSync(path9.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"))
+    detect: (root) => fs8.existsSync(path9.join(root, ".github/copilot-instructions.md"))
   }
 };
 var CORE_FILES = [
@@ -2366,6 +2885,7 @@ Commands:
   remove   Uninstall typegraph-mcp from the current project
   check    Run health checks (12 checks)
   test     Run smoke tests (all 14 tools)
+  bench    Run benchmarks (token, latency, accuracy)
   start    Start the MCP server (stdin/stdout)
 
 Options:
@@ -2373,13 +2893,13 @@ Options:
   --help  Show this help
 `.trim();
 function copyFile(src, dest) {
-  const destDir = path8.dirname(dest);
-  if (!fs7.existsSync(destDir)) {
-    fs7.mkdirSync(destDir, { recursive: true });
+  const destDir = path9.dirname(dest);
+  if (!fs8.existsSync(destDir)) {
+    fs8.mkdirSync(destDir, { recursive: true });
   }
-  fs7.copyFileSync(src, dest);
+  fs8.copyFileSync(src, dest);
   if (src.endsWith(".sh")) {
-    fs7.chmodSync(dest, 493);
+    fs8.chmodSync(dest, 493);
   }
 }
 var MCP_SERVER_ENTRY = {
@@ -2390,28 +2910,28 @@ var MCP_SERVER_ENTRY = {
     TYPEGRAPH_TSCONFIG: "./tsconfig.json"
   }
 };
-function registerMcpServers(projectRoot2, selectedAgents) {
+function registerMcpServers(projectRoot3, selectedAgents) {
   if (selectedAgents.includes("cursor")) {
-    registerJsonMcp(projectRoot2, ".cursor/mcp.json", "mcpServers");
+    registerJsonMcp(projectRoot3, ".cursor/mcp.json", "mcpServers");
   }
   if (selectedAgents.includes("codex")) {
-    registerCodexMcp(projectRoot2);
+    registerCodexMcp(projectRoot3);
   }
   if (selectedAgents.includes("copilot")) {
-    registerJsonMcp(projectRoot2, ".vscode/mcp.json", "servers");
+    registerJsonMcp(projectRoot3, ".vscode/mcp.json", "servers");
   }
 }
-function deregisterMcpServers(projectRoot2) {
-  deregisterJsonMcp(projectRoot2, ".cursor/mcp.json", "mcpServers");
-  deregisterCodexMcp(projectRoot2);
-  deregisterJsonMcp(projectRoot2, ".vscode/mcp.json", "servers");
+function deregisterMcpServers(projectRoot3) {
+  deregisterJsonMcp(projectRoot3, ".cursor/mcp.json", "mcpServers");
+  deregisterCodexMcp(projectRoot3);
+  deregisterJsonMcp(projectRoot3, ".vscode/mcp.json", "servers");
 }
-function registerJsonMcp(projectRoot2, configPath, rootKey) {
-  const fullPath = path8.resolve(projectRoot2, configPath);
+function registerJsonMcp(projectRoot3, configPath, rootKey) {
+  const fullPath = path9.resolve(projectRoot3, configPath);
   let config = {};
-  if (fs7.existsSync(fullPath)) {
+  if (fs8.existsSync(fullPath)) {
     try {
-      config = JSON.parse(fs7.readFileSync(fullPath, "utf-8"));
+      config = JSON.parse(fs8.readFileSync(fullPath, "utf-8"));
     } catch {
       p.log.warn(`Could not parse ${configPath} \u2014 skipping MCP registration`);
       return;
@@ -2424,18 +2944,18 @@ function registerJsonMcp(projectRoot2, configPath, rootKey) {
   }
   servers["typegraph"] = entry;
   config[rootKey] = servers;
-  const dir = path8.dirname(fullPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path9.dirname(fullPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
-  fs7.writeFileSync(fullPath, JSON.stringify(config, null, 2) + "\n");
+  fs8.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;
+function deregisterJsonMcp(projectRoot3, configPath, rootKey) {
+  const fullPath = path9.resolve(projectRoot3, configPath);
+  if (!fs8.existsSync(fullPath)) return;
   try {
-    const config = JSON.parse(fs7.readFileSync(fullPath, "utf-8"));
+    const config = JSON.parse(fs8.readFileSync(fullPath, "utf-8"));
     const servers = config[rootKey];
     if (!servers || !servers["typegraph"]) return;
     delete servers["typegraph"];
@@ -2443,20 +2963,20 @@ function deregisterJsonMcp(projectRoot2, configPath, rootKey) {
       delete config[rootKey];
     }
     if (Object.keys(config).length === 0) {
-      fs7.unlinkSync(fullPath);
+      fs8.unlinkSync(fullPath);
     } else {
-      fs7.writeFileSync(fullPath, JSON.stringify(config, null, 2) + "\n");
+      fs8.writeFileSync(fullPath, JSON.stringify(config, null, 2) + "\n");
     }
     p.log.info(`${configPath}: removed typegraph MCP server`);
   } catch {
   }
 }
-function registerCodexMcp(projectRoot2) {
+function registerCodexMcp(projectRoot3) {
   const configPath = ".codex/config.toml";
-  const fullPath = path8.resolve(projectRoot2, configPath);
+  const fullPath = path9.resolve(projectRoot3, configPath);
   let content = "";
-  if (fs7.existsSync(fullPath)) {
-    content = fs7.readFileSync(fullPath, "utf-8");
+  if (fs8.existsSync(fullPath)) {
+    content = fs8.readFileSync(fullPath, "utf-8");
     if (content.includes("[mcp_servers.typegraph]")) {
       p.log.info(`${configPath}: typegraph MCP server already registered`);
       return;
@@ -2470,19 +2990,19 @@ function registerCodexMcp(projectRoot2) {
     '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 dir = path9.dirname(fullPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
   const newContent = content ? content.trimEnd() + "\n" + block : block.trimStart();
-  fs7.writeFileSync(fullPath, newContent);
+  fs8.writeFileSync(fullPath, newContent);
   p.log.success(`${configPath}: registered typegraph MCP server`);
 }
-function deregisterCodexMcp(projectRoot2) {
+function deregisterCodexMcp(projectRoot3) {
   const configPath = ".codex/config.toml";
-  const fullPath = path8.resolve(projectRoot2, configPath);
-  if (!fs7.existsSync(fullPath)) return;
-  let content = fs7.readFileSync(fullPath, "utf-8");
+  const fullPath = path9.resolve(projectRoot3, configPath);
+  if (!fs8.existsSync(fullPath)) return;
+  let content = fs8.readFileSync(fullPath, "utf-8");
   if (!content.includes("[mcp_servers.typegraph]")) return;
   content = content.replace(
     /\n?\[mcp_servers\.typegraph\]\n[\s\S]*?(?=\n\[|$)/,
@@ -2490,17 +3010,17 @@ function deregisterCodexMcp(projectRoot2) {
   );
   content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
   if (content.trim() === "") {
-    fs7.unlinkSync(fullPath);
+    fs8.unlinkSync(fullPath);
   } else {
-    fs7.writeFileSync(fullPath, content);
+    fs8.writeFileSync(fullPath, content);
   }
   p.log.info(`${configPath}: removed typegraph MCP server`);
 }
-function ensureTsconfigExclude(projectRoot2) {
-  const tsconfigPath2 = path8.resolve(projectRoot2, "tsconfig.json");
-  if (!fs7.existsSync(tsconfigPath2)) return;
+function ensureTsconfigExclude(projectRoot3) {
+  const tsconfigPath3 = path9.resolve(projectRoot3, "tsconfig.json");
+  if (!fs8.existsSync(tsconfigPath3)) return;
   try {
-    const raw = fs7.readFileSync(tsconfigPath2, "utf-8");
+    const raw = fs8.readFileSync(tsconfigPath3, "utf-8");
     const stripped = raw.replace(/\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
     const tsconfig = JSON.parse(stripped);
     const exclude = tsconfig.exclude || [];
@@ -2517,7 +3037,7 @@ function ensureTsconfigExclude(projectRoot2) {
     "plugins/**"${close}`;
         }
       );
-      fs7.writeFileSync(tsconfigPath2, updated);
+      fs8.writeFileSync(tsconfigPath3, updated);
     } else {
       const lastBrace = raw.lastIndexOf("}");
       if (lastBrace !== -1) {
@@ -2527,7 +3047,7 @@ function ensureTsconfigExclude(projectRoot2) {
   "exclude": ["plugins/**"]
 }
 `;
-        fs7.writeFileSync(tsconfigPath2, patched);
+        fs8.writeFileSync(tsconfigPath3, patched);
       }
     }
     p.log.success('Added "plugins/**" to tsconfig.json exclude (prevents build errors)');
@@ -2535,11 +3055,11 @@ function ensureTsconfigExclude(projectRoot2) {
     p.log.warn('Could not update tsconfig.json \u2014 manually add "plugins/**" to the exclude array to prevent build errors');
   }
 }
-function detectAgents(projectRoot2) {
-  return AGENT_IDS.filter((id) => AGENTS[id].detect(projectRoot2));
+function detectAgents(projectRoot3) {
+  return AGENT_IDS.filter((id) => AGENTS[id].detect(projectRoot3));
 }
-async function selectAgents(projectRoot2, yes2) {
-  const detected = detectAgents(projectRoot2);
+async function selectAgents(projectRoot3, yes2) {
+  const detected = detectAgents(projectRoot3);
   if (yes2) {
     const selected2 = detected.length > 0 ? detected : [...AGENT_IDS];
     p.log.info(`Auto-selected: ${selected2.map((id) => AGENTS[id].name).join(", ")}`);
@@ -2565,24 +3085,24 @@ async function selectAgents(projectRoot2, yes2) {
   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();
+  const sourceDir = path9.basename(import.meta.dirname) === "dist" ? path9.resolve(import.meta.dirname, "..") : import.meta.dirname;
+  const projectRoot3 = 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.log.info(`Project: ${projectRoot3}`);
+  const pkgJsonPath = path9.resolve(projectRoot3, "package.json");
+  const tsconfigPath3 = path9.resolve(projectRoot3, "tsconfig.json");
+  if (!fs8.existsSync(pkgJsonPath)) {
     p.cancel("No package.json found. Run this from the root of your TypeScript project.");
     process.exit(1);
   }
-  if (!fs7.existsSync(tsconfigPath2)) {
+  if (!fs8.existsSync(tsconfigPath3)) {
     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);
+  const targetDir = path9.resolve(projectRoot3, PLUGIN_DIR_NAME);
+  const isUpdate = fs8.existsSync(targetDir);
   if (isUpdate && !yes2) {
     const action = await p.select({
       message: `${PLUGIN_DIR_NAME}/ already exists.`,
@@ -2597,7 +3117,7 @@ async function setup(yes2) {
       process.exit(0);
     }
     if (action === "remove") {
-      await removePlugin(projectRoot2, targetDir);
+      await removePlugin(projectRoot3, targetDir);
       return;
     }
     if (action === "exit") {
@@ -2605,7 +3125,7 @@ async function setup(yes2) {
       return;
     }
   }
-  const selectedAgents = await selectAgents(projectRoot2, yes2);
+  const selectedAgents = await selectAgents(projectRoot3, 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}/...`);
@@ -2620,9 +3140,9 @@ async function setup(yes2) {
   }
   let copied = 0;
   for (const file of filesToCopy) {
-    const src = path8.join(sourceDir, file);
-    const dest = path8.join(targetDir, file);
-    if (fs7.existsSync(src)) {
+    const src = path9.join(sourceDir, file);
+    const dest = path9.join(targetDir, file);
+    if (fs8.existsSync(src)) {
       copyFile(src, dest);
       copied++;
     } else {
@@ -2631,7 +3151,7 @@ async function setup(yes2) {
   }
   s.message("Installing dependencies...");
   try {
-    execSync("npm install", { cwd: targetDir, stdio: "pipe" });
+    execSync2("npm install", { cwd: targetDir, stdio: "pipe" });
     s.stop(`${isUpdate ? "Updated" : "Installed"} ${copied} files with dependencies`);
   } catch (err) {
     s.stop(`${isUpdate ? "Updated" : "Installed"} ${copied} files`);
@@ -2640,20 +3160,20 @@ async function setup(yes2) {
   }
   if (needsAgentsSkills) {
     const agentsNames = selectedAgents.filter((id) => AGENTS[id].needsAgentsSkills).map((id) => AGENTS[id].name);
-    const agentsSkillsDir = path8.resolve(projectRoot2, ".agents/skills");
+    const agentsSkillsDir = path9.resolve(projectRoot3, ".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");
+      const src = path9.join(targetDir, "skills", skill, "SKILL.md");
+      const destDir = path9.join(agentsSkillsDir, skill);
+      const dest = path9.join(destDir, "SKILL.md");
+      if (!fs8.existsSync(src)) continue;
+      if (fs8.existsSync(dest)) {
+        const srcContent = fs8.readFileSync(src, "utf-8");
+        const destContent = fs8.readFileSync(dest, "utf-8");
         if (srcContent === destContent) continue;
       }
-      fs7.mkdirSync(destDir, { recursive: true });
-      fs7.copyFileSync(src, dest);
+      fs8.mkdirSync(destDir, { recursive: true });
+      fs8.copyFileSync(src, dest);
       copiedSkills++;
     }
     if (copiedSkills > 0) {
@@ -2663,70 +3183,70 @@ async function setup(yes2) {
     }
   }
   if (selectedAgents.includes("claude-code")) {
-    const mcpJsonPath = path8.resolve(projectRoot2, ".claude/mcp.json");
-    if (fs7.existsSync(mcpJsonPath)) {
+    const mcpJsonPath = path9.resolve(projectRoot3, ".claude/mcp.json");
+    if (fs8.existsSync(mcpJsonPath)) {
       try {
-        const mcpJson = JSON.parse(fs7.readFileSync(mcpJsonPath, "utf-8"));
+        const mcpJson = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
         if (mcpJson.mcpServers?.["typegraph"]) {
           delete mcpJson.mcpServers["typegraph"];
-          fs7.writeFileSync(mcpJsonPath, JSON.stringify(mcpJson, null, 2) + "\n");
+          fs8.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);
-  ensureTsconfigExclude(projectRoot2);
+  await setupAgentInstructions(projectRoot3, selectedAgents);
+  registerMcpServers(projectRoot3, selectedAgents);
+  ensureTsconfigExclude(projectRoot3);
   await runVerification(targetDir, selectedAgents);
 }
-async function removePlugin(projectRoot2, pluginDir) {
+async function removePlugin(projectRoot3, pluginDir) {
   const s = p.spinner();
   s.start("Removing typegraph-mcp...");
-  if (fs7.existsSync(pluginDir)) {
-    fs7.rmSync(pluginDir, { recursive: true });
+  if (fs8.existsSync(pluginDir)) {
+    fs8.rmSync(pluginDir, { recursive: true });
   }
-  const agentsSkillsDir = path8.resolve(projectRoot2, ".agents/skills");
+  const agentsSkillsDir = path9.resolve(projectRoot3, ".agents/skills");
   for (const skill of SKILL_NAMES) {
-    const skillDir = path8.join(agentsSkillsDir, skill);
-    if (fs7.existsSync(skillDir)) {
-      fs7.rmSync(skillDir, { recursive: true });
+    const skillDir = path9.join(agentsSkillsDir, skill);
+    if (fs8.existsSync(skillDir)) {
+      fs8.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 });
+  if (fs8.existsSync(agentsSkillsDir) && fs8.readdirSync(agentsSkillsDir).length === 0) {
+    fs8.rmSync(agentsSkillsDir, { recursive: true });
+    const agentsDir = path9.resolve(projectRoot3, ".agents");
+    if (fs8.existsSync(agentsDir) && fs8.readdirSync(agentsDir).length === 0) {
+      fs8.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);
+    const filePath = path9.resolve(projectRoot3, agentFile);
+    if (!fs8.existsSync(filePath)) continue;
+    const realPath = fs8.realpathSync(filePath);
     if (seenRealPaths.has(realPath)) continue;
     seenRealPaths.add(realPath);
-    let content = fs7.readFileSync(realPath, "utf-8");
+    let content = fs8.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);
+      fs8.writeFileSync(realPath, content);
     }
   }
-  const claudeMdPath = path8.resolve(projectRoot2, "CLAUDE.md");
-  if (fs7.existsSync(claudeMdPath)) {
-    let content = fs7.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path9.resolve(projectRoot3, "CLAUDE.md");
+  if (fs8.existsSync(claudeMdPath)) {
+    let content = fs8.readFileSync(claudeMdPath, "utf-8");
     content = content.replace(/ --plugin-dir \.\/plugins\/typegraph-mcp/g, "");
-    fs7.writeFileSync(claudeMdPath, content);
+    fs8.writeFileSync(claudeMdPath, content);
   }
   s.stop("Removed typegraph-mcp");
-  deregisterMcpServers(projectRoot2);
+  deregisterMcpServers(projectRoot3);
   p.outro("typegraph-mcp has been uninstalled from this project.");
 }
-async function setupAgentInstructions(projectRoot2, selectedAgents) {
+async function setupAgentInstructions(projectRoot3, selectedAgents) {
   const agentFiles = selectedAgents.map((id) => AGENTS[id].agentFile).filter((f) => f !== null);
   if (agentFiles.length === 0) {
     return;
@@ -2734,16 +3254,16 @@ async function setupAgentInstructions(projectRoot2, selectedAgents) {
   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 filePath = path9.resolve(projectRoot3, agentFile);
+    if (!fs8.existsSync(filePath)) continue;
+    const realPath = fs8.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");
+    const content = fs8.readFileSync(filePath, "utf-8");
     existingFiles.push({ file: agentFile, realPath, hasSnippet: content.includes(SNIPPET_MARKER) });
   }
   if (existingFiles.length === 0) {
@@ -2757,15 +3277,15 @@ async function setupAgentInstructions(projectRoot2, selectedAgents) {
     }
   } else {
     const target = existingFiles[0];
-    const content = fs7.readFileSync(target.realPath, "utf-8");
+    const content = fs8.readFileSync(target.realPath, "utf-8");
     const appendContent = (content.endsWith("\n") ? "" : "\n") + "\n" + AGENT_SNIPPET;
-    fs7.appendFileSync(target.realPath, appendContent);
+    fs8.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 claudeMdPath = path9.resolve(projectRoot3, "CLAUDE.md");
+    if (fs8.existsSync(claudeMdPath)) {
+      let content = fs8.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")) {
@@ -2774,7 +3294,7 @@ async function setupAgentInstructions(projectRoot2, selectedAgents) {
           pluginDirPattern,
           `$1${existingFlags} --plugin-dir ./plugins/typegraph-mcp$3`
         );
-        fs7.writeFileSync(claudeMdPath, content);
+        fs8.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");
@@ -2797,9 +3317,9 @@ async function runVerification(pluginDir, selectedAgents) {
   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");
+      p.outro("Setup complete! Run: claude --plugin-dir ./plugins/typegraph-mcp\n  Slash commands: /typegraph:check, /typegraph:test, /typegraph:bench");
     } else {
-      p.outro("Setup complete! typegraph-mcp tools are now available to your agents.");
+      p.outro("Setup complete! typegraph-mcp tools are now available to your agents.\n  CLI: npx typegraph-mcp check | test | bench");
     }
   } else {
     p.cancel("Setup completed with issues. Fix the failures above and re-run.");
@@ -2807,11 +3327,11 @@ async function runVerification(pluginDir, selectedAgents) {
   }
 }
 async function remove(yes2) {
-  const projectRoot2 = process.cwd();
-  const pluginDir = path8.resolve(projectRoot2, PLUGIN_DIR_NAME);
+  const projectRoot3 = process.cwd();
+  const pluginDir = path9.resolve(projectRoot3, PLUGIN_DIR_NAME);
   process.stdout.write("\x1Bc");
   p.intro("TypeGraph MCP Remove");
-  if (!fs7.existsSync(pluginDir)) {
+  if (!fs8.existsSync(pluginDir)) {
     p.cancel("typegraph-mcp is not installed in this project.");
     process.exit(1);
   }
@@ -2822,12 +3342,12 @@ async function remove(yes2) {
       process.exit(0);
     }
   }
-  await removePlugin(projectRoot2, pluginDir);
+  await removePlugin(projectRoot3, pluginDir);
 }
 function resolvePluginDir() {
-  const installed = path8.resolve(process.cwd(), PLUGIN_DIR_NAME);
-  if (fs7.existsSync(installed)) return installed;
-  return path8.basename(import.meta.dirname) === "dist" ? path8.resolve(import.meta.dirname, "..") : import.meta.dirname;
+  const installed = path9.resolve(process.cwd(), PLUGIN_DIR_NAME);
+  if (fs8.existsSync(installed)) return installed;
+  return path9.basename(import.meta.dirname) === "dist" ? path9.resolve(import.meta.dirname, "..") : import.meta.dirname;
 }
 async function check() {
   const config = resolveConfig(resolvePluginDir());
@@ -2841,6 +3361,11 @@ async function test() {
   const result = await testMain(config);
   process.exit(result.failed > 0 ? 1 : 0);
 }
+async function benchmark() {
+  const config = resolveConfig(resolvePluginDir());
+  const { main: benchMain } = await Promise.resolve().then(() => (init_benchmark(), benchmark_exports));
+  await benchMain(config);
+}
 async function start() {
   await Promise.resolve().then(() => (init_server(), server_exports));
 }
@@ -2877,6 +3402,13 @@ switch (command) {
       process.exit(1);
     });
     break;
+  case "bench":
+  case "benchmark":
+    benchmark().catch((err) => {
+      console.error("Fatal:", err);
+      process.exit(1);
+    });
+    break;
   case "start":
     start().catch((err) => {
       console.error("Fatal:", err);