typegraph-mcp 0.9.19 → 0.9.21

package/dist/benchmark.js

@@ -0,0 +1,1284 @@
+
+// benchmark.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { execSync } from "child_process";
+
+// tsserver-client.ts
+import { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import { createRequire } from "module";
+var log = (...args) => console.error("[typegraph/tsserver]", ...args);
+var REQUEST_TIMEOUT_MS = 1e4;
+var TsServerClient = class {
+  constructor(projectRoot2, tsconfigPath2 = "./tsconfig.json") {
+    this.projectRoot = projectRoot2;
+    this.tsconfigPath = tsconfigPath2;
+  }
+  child = null;
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  openFiles = /* @__PURE__ */ new Set();
+  buffer = Buffer.alloc(0);
+  ready = false;
+  shuttingDown = false;
+  restartCount = 0;
+  maxRestarts = 3;
+  // ─── Path Resolution ────────────────────────────────────────────────────
+  resolvePath(file) {
+    return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
+  }
+  relativePath(file) {
+    return path.relative(this.projectRoot, file);
+  }
+  /** Read a line from a file (1-based line number). Returns trimmed content. */
+  readLine(file, line) {
+    try {
+      const absPath = this.resolvePath(file);
+      const content = fs.readFileSync(absPath, "utf-8");
+      const lines = content.split("\n");
+      return lines[line - 1]?.trim() ?? "";
+    } catch {
+      return "";
+    }
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────
+  async start() {
+    if (this.child) return;
+    const require2 = createRequire(path.resolve(this.projectRoot, "package.json"));
+    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    log(`Spawning tsserver: ${tsserverPath}`);
+    log(`Project root: ${this.projectRoot}`);
+    log(`tsconfig: ${this.tsconfigPath}`);
+    this.child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+      cwd: this.projectRoot,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, TSS_LOG: void 0 }
+    });
+    this.child.stdout.on("data", (chunk) => this.onData(chunk));
+    this.child.stderr.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) log(`[stderr] ${text}`);
+    });
+    this.child.on("close", (code) => {
+      log(`tsserver exited with code ${code}`);
+      this.child = null;
+      this.rejectAllPending(new Error(`tsserver exited with code ${code}`));
+      this.tryRestart();
+    });
+    this.child.on("error", (err) => {
+      log(`tsserver error: ${err.message}`);
+      this.rejectAllPending(err);
+    });
+    await this.sendRequest("configure", {
+      preferences: {
+        disableSuggestions: true
+      }
+    });
+    const warmStart = performance.now();
+    const tsconfigAbs = this.resolvePath(this.tsconfigPath);
+    if (fs.existsSync(tsconfigAbs)) {
+      await this.sendRequest("compilerOptionsForInferredProjects", {
+        options: { allowJs: true, checkJs: false }
+      });
+    }
+    this.ready = true;
+    log(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
+  }
+  shutdown() {
+    this.shuttingDown = true;
+    if (this.child) {
+      this.child.kill("SIGTERM");
+      this.child = null;
+    }
+    this.rejectAllPending(new Error("Client shutdown"));
+  }
+  tryRestart() {
+    if (this.shuttingDown) return;
+    if (this.restartCount >= this.maxRestarts) {
+      log(`Max restarts (${this.maxRestarts}) reached, not restarting`);
+      return;
+    }
+    this.restartCount++;
+    log(`Restarting tsserver (attempt ${this.restartCount})...`);
+    this.buffer = Buffer.alloc(0);
+    const filesToReopen = [...this.openFiles];
+    this.openFiles.clear();
+    this.start().then(async () => {
+      for (const file of filesToReopen) {
+        await this.ensureOpen(file).catch(() => {
+        });
+      }
+    });
+  }
+  rejectAllPending(err) {
+    for (const [seq, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+  // ─── Protocol: Parsing ──────────────────────────────────────────────────
+  onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    this.processBuffer();
+  }
+  processBuffer() {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+      const header = this.buffer.subarray(0, headerEnd).toString("utf-8");
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.subarray(headerEnd + 4);
+        continue;
+      }
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      if (this.buffer.length < bodyStart + contentLength) {
+        return;
+      }
+      const bodyBytes = this.buffer.subarray(bodyStart, bodyStart + contentLength);
+      this.buffer = this.buffer.subarray(bodyStart + contentLength);
+      try {
+        const message = JSON.parse(bodyBytes.toString("utf-8"));
+        this.onMessage(message);
+      } catch {
+        log("Failed to parse tsserver message");
+      }
+    }
+  }
+  onMessage(message) {
+    if (message.type === "response" && message.request_seq !== void 0) {
+      const pending = this.pending.get(message.request_seq);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(message.request_seq);
+        if (message.success) {
+          pending.resolve(message.body);
+        } else {
+          pending.reject(
+            new Error(`tsserver ${pending.command} failed: ${message.message ?? "unknown error"}`)
+          );
+        }
+      }
+    }
+  }
+  // ─── Protocol: Sending ──────────────────────────────────────────────────
+  sendRequest(command, args) {
+    if (!this.child?.stdin?.writable) {
+      return Promise.reject(new Error("tsserver not running"));
+    }
+    const seq = ++this.seq;
+    const request = {
+      seq,
+      type: "request",
+      command,
+      arguments: args
+    };
+    return new Promise((resolve6, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`tsserver ${command} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(seq, { resolve: resolve6, reject, timer, command });
+      this.child.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+  // Fire-and-forget — for commands like `open` that may not send a response
+  sendNotification(command, args) {
+    if (!this.child?.stdin?.writable) return;
+    const seq = ++this.seq;
+    const request = { seq, type: "request", command, arguments: args };
+    this.child.stdin.write(JSON.stringify(request) + "\n");
+  }
+  // ─── File Management ───────────────────────────────────────────────────
+  async ensureOpen(file) {
+    const absPath = this.resolvePath(file);
+    if (this.openFiles.has(absPath)) return;
+    this.openFiles.add(absPath);
+    this.sendNotification("open", { file: absPath });
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  // ─── Public API ────────────────────────────────────────────────────────
+  async definition(file, line, offset) {
+    const absPath = this.resolvePath(file);
+    await this.ensureOpen(absPath);
+    const body = await this.sendRequest("definition", {
+      file: absPath,
+      line,
+      offset
+    });
+    if (!body || !Array.isArray(body)) return [];
+    return body.map((d) => ({
+      ...d,
+      file: this.relativePath(d.file)
+    }));
+  }
+  async references(file, line, offset) {
+    const absPath = this.resolvePath(file);
+    await this.ensureOpen(absPath);
+    const body = await this.sendRequest("references", {
+      file: absPath,
+      line,
+      offset
+    });
+    if (!body?.refs) return [];
+    return body.refs.map((r) => ({
+      ...r,
+      file: this.relativePath(r.file)
+    }));
+  }
+  async quickinfo(file, line, offset) {
+    const absPath = this.resolvePath(file);
+    await this.ensureOpen(absPath);
+    try {
+      const body = await this.sendRequest("quickinfo", {
+        file: absPath,
+        line,
+        offset
+      });
+      return body ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async navto(searchValue, maxResults = 10, file) {
+    if (file) await this.ensureOpen(file);
+    const args = {
+      searchValue,
+      maxResultCount: maxResults
+    };
+    if (file) args["file"] = this.resolvePath(file);
+    const body = await this.sendRequest("navto", args);
+    if (!body || !Array.isArray(body)) return [];
+    return body.map((item) => ({
+      ...item,
+      file: this.relativePath(item.file)
+    }));
+  }
+  async navbar(file) {
+    const absPath = this.resolvePath(file);
+    await this.ensureOpen(absPath);
+    const body = await this.sendRequest("navbar", {
+      file: absPath
+    });
+    return body ?? [];
+  }
+};
+
+// module-graph.ts
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var log2 = (...args) => console.error("[typegraph/graph]", ...args);
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".wrangler",
+  ".mf",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+function discoverFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && dir !== rootDir) continue;
+        walk(path2.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (SKIP_FILES.has(name)) continue;
+        if (name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts")) continue;
+        const ext = path2.extname(name);
+        if (TS_EXTENSIONS.has(ext)) {
+          files.push(path2.join(dir, name));
+        }
+      }
+    }
+  }
+  walk(rootDir);
+  return files;
+}
+function parseFileImports(filePath, source) {
+  const result = parseSync(filePath, source);
+  const imports = [];
+  for (const imp of result.module.staticImports) {
+    const specifier = imp.moduleRequest.value;
+    const names = [];
+    let allTypeOnly = true;
+    for (const entry of imp.entries) {
+      const kind = entry.importName.kind;
+      const name = kind === "Default" ? "default" : kind === "All" || kind === "AllButDefault" || kind === "NamespaceObject" ? "*" : entry.importName.name ?? entry.localName.value;
+      names.push(name);
+      if (!entry.isType) allTypeOnly = false;
+    }
+    if (names.length === 0) {
+      imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: false });
+    } else {
+      imports.push({ specifier, names, isTypeOnly: allTypeOnly, isDynamic: false });
+    }
+  }
+  for (const exp of result.module.staticExports) {
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (!moduleRequest) continue;
+      const specifier = moduleRequest.value;
+      const entryKind = entry.importName.kind;
+      const name = entryKind === "AllButDefault" || entryKind === "All" || entryKind === "NamespaceObject" ? "*" : entry.importName.name ?? "*";
+      const existing = imports.find((i) => i.specifier === specifier && !i.isDynamic);
+      if (existing) {
+        if (!existing.names.includes(name)) existing.names.push(name);
+      } else {
+        imports.push({ specifier, names: [name], isTypeOnly: false, isDynamic: false });
+      }
+    }
+  }
+  for (const di of result.module.dynamicImports) {
+    if (di.moduleRequest) {
+      const sliced = source.slice(di.moduleRequest.start, di.moduleRequest.end);
+      if (sliced.startsWith("'") || sliced.startsWith('"')) {
+        const specifier = sliced.slice(1, -1);
+        imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: true });
+      }
+    }
+  }
+  return imports;
+}
+var SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+function distToSource(resolvedPath, projectRoot2) {
+  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
+  const rel = path2.relative(projectRoot2, resolvedPath);
+  const distIdx = rel.indexOf("dist" + path2.sep);
+  if (distIdx === -1) return resolvedPath;
+  const prefix = rel.slice(0, distIdx);
+  const afterDist = rel.slice(distIdx + 5);
+  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, "src", withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path2.resolve(projectRoot2, prefix, "src", dirPath + ext);
+      if (fs2.existsSync(candidate)) return candidate;
+    }
+  }
+  return resolvedPath;
+}
+function resolveImport(resolver, fromDir, specifier, projectRoot2) {
+  try {
+    const result = resolver.sync(fromDir, specifier);
+    if (result.path && !result.path.includes("node_modules")) {
+      const mapped = distToSource(result.path, projectRoot2);
+      const ext = path2.extname(mapped);
+      if (!TS_EXTENSIONS.has(ext)) return null;
+      if (SKIP_FILES.has(path2.basename(mapped))) return null;
+      return mapped;
+    }
+  } catch {
+  }
+  return null;
+}
+function createResolver(projectRoot2, tsconfigPath2) {
+  return new ResolverFactory({
+    tsconfig: {
+      configFile: path2.resolve(projectRoot2, tsconfigPath2),
+      references: "auto"
+    },
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    extensionAlias: {
+      ".js": [".ts", ".tsx", ".js"],
+      ".jsx": [".tsx", ".jsx"],
+      ".mjs": [".mts", ".mjs"],
+      ".cjs": [".cts", ".cjs"]
+    },
+    conditionNames: ["import", "require"],
+    mainFields: ["module", "main"]
+  });
+}
+function buildForwardEdges(files, resolver, projectRoot2) {
+  const forward = /* @__PURE__ */ new Map();
+  const parseFailures = [];
+  for (const filePath of files) {
+    let source;
+    try {
+      source = fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    let rawImports;
+    try {
+      rawImports = parseFileImports(filePath, source);
+    } catch (err) {
+      parseFailures.push(filePath);
+      continue;
+    }
+    const edges = [];
+    const fromDir = path2.dirname(filePath);
+    for (const raw of rawImports) {
+      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+      if (target) {
+        edges.push({
+          target,
+          specifiers: raw.names,
+          isTypeOnly: raw.isTypeOnly,
+          isDynamic: raw.isDynamic
+        });
+      }
+    }
+    forward.set(filePath, edges);
+  }
+  return { forward, parseFailures };
+}
+function buildReverseMap(forward) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [source, edges] of forward) {
+    for (const edge of edges) {
+      let revEdges = reverse.get(edge.target);
+      if (!revEdges) {
+        revEdges = [];
+        reverse.set(edge.target, revEdges);
+      }
+      revEdges.push({
+        target: source,
+        // reverse: the "target" is the file that imports
+        specifiers: edge.specifiers,
+        isTypeOnly: edge.isTypeOnly,
+        isDynamic: edge.isDynamic
+      });
+    }
+  }
+  return reverse;
+}
+async function buildGraph(projectRoot2, tsconfigPath2) {
+  const startTime = performance.now();
+  const resolver = createResolver(projectRoot2, tsconfigPath2);
+  const fileList = discoverFiles(projectRoot2);
+  log2(`Discovered ${fileList.length} source files`);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot2);
+  const reverse = buildReverseMap(forward);
+  const files = new Set(fileList);
+  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
+  const elapsed = (performance.now() - startTime).toFixed(0);
+  log2(`Graph built: ${files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+  if (parseFailures.length > 0) {
+    log2(`Parse failures: ${parseFailures.length} files`);
+  }
+  return {
+    graph: { forward, reverse, files },
+    resolver
+  };
+}
+
+// graph-queries.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function shouldIncludeEdge(edge, includeTypeOnly) {
+  if (!includeTypeOnly && edge.isTypeOnly) return false;
+  return true;
+}
+function dependencyTree(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  return { root: file, nodes: result.length, files: result };
+}
+var packageNameCache = /* @__PURE__ */ new Map();
+function findPackageName(filePath) {
+  let dir = path3.dirname(filePath);
+  while (dir !== path3.dirname(dir)) {
+    if (packageNameCache.has(dir)) return packageNameCache.get(dir);
+    const pkgJsonPath = path3.join(dir, "package.json");
+    try {
+      if (fs3.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        const name = pkg.name ?? path3.basename(dir);
+        packageNameCache.set(dir, name);
+        return name;
+      }
+    } catch {
+    }
+    dir = path3.dirname(dir);
+  }
+  return "<root>";
+}
+function dependents(graph, file, opts = {}) {
+  const { depth = Infinity, includeTypeOnly = false } = opts;
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  let directCount = 0;
+  let frontier = [file];
+  visited.add(file);
+  let currentDepth = 0;
+  while (frontier.length > 0 && currentDepth < depth) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.reverse.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        result.push(edge.target);
+        if (currentDepth === 0) directCount++;
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+    currentDepth++;
+  }
+  const byPackage = {};
+  for (const f of result) {
+    const pkgName = findPackageName(f);
+    if (!byPackage[pkgName]) byPackage[pkgName] = [];
+    byPackage[pkgName].push(f);
+  }
+  return { root: file, nodes: result.length, directCount, files: result, byPackage };
+}
+function importCycles(graph, opts = {}) {
+  const { file, package: pkgDir } = opts;
+  let index = 0;
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const indices = /* @__PURE__ */ new Map();
+  const lowlinks = /* @__PURE__ */ new Map();
+  const sccs = [];
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    const edges = graph.forward.get(v) ?? [];
+    for (const edge of edges) {
+      const w = edge.target;
+      if (!graph.files.has(w)) continue;
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) {
+        sccs.push(scc);
+      }
+    }
+  }
+  for (const f of graph.files) {
+    if (!indices.has(f)) {
+      strongconnect(f);
+    }
+  }
+  let cycles = sccs;
+  if (file) {
+    cycles = cycles.filter((scc) => scc.includes(file));
+  }
+  if (pkgDir) {
+    const absPkgDir = path3.resolve(pkgDir);
+    cycles = cycles.filter(
+      (scc) => scc.every((f) => f.startsWith(absPkgDir))
+    );
+  }
+  return { count: cycles.length, cycles };
+}
+function shortestPath(graph, from, to, opts = {}) {
+  const { includeTypeOnly = false } = opts;
+  if (from === to) {
+    return { path: [from], hops: 0, chain: [{ file: from, imports: [] }] };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  visited.add(from);
+  let frontier = [from];
+  while (frontier.length > 0) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      const edges = graph.forward.get(f) ?? [];
+      for (const edge of edges) {
+        if (!shouldIncludeEdge(edge, includeTypeOnly)) continue;
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        parent.set(edge.target, { from: f, specifiers: edge.specifiers });
+        if (edge.target === to) {
+          const filePath = [to];
+          let current = to;
+          while (parent.has(current)) {
+            current = parent.get(current).from;
+            filePath.unshift(current);
+          }
+          const chain = [];
+          for (let i = 0; i < filePath.length; i++) {
+            const p = parent.get(filePath[i]);
+            chain.push({
+              file: filePath[i],
+              imports: p?.specifiers ?? []
+            });
+          }
+          return { path: filePath, hops: filePath.length - 1, chain };
+        }
+        nextFrontier.push(edge.target);
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return { path: null, hops: -1, chain: [] };
+}
+function subgraph(graph, files, opts = {}) {
+  const { depth = 1, direction = "both" } = opts;
+  const visited = new Set(files);
+  let frontier = [...files];
+  for (let d = 0; d < depth && frontier.length > 0; d++) {
+    const nextFrontier = [];
+    for (const f of frontier) {
+      if (direction === "imports" || direction === "both") {
+        for (const edge of graph.forward.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+      if (direction === "dependents" || direction === "both") {
+        for (const edge of graph.reverse.get(f) ?? []) {
+          if (!visited.has(edge.target)) {
+            visited.add(edge.target);
+            nextFrontier.push(edge.target);
+          }
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  const nodes = [...visited];
+  const edges = [];
+  for (const f of nodes) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (visited.has(edge.target)) {
+        edges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers,
+          isTypeOnly: edge.isTypeOnly
+        });
+      }
+    }
+  }
+  return { nodes, edges, stats: { nodeCount: nodes.length, edgeCount: edges.length } };
+}
+function moduleBoundary(graph, files) {
+  const fileSet = new Set(files);
+  let internalEdges = 0;
+  const incomingEdges = [];
+  const outgoingEdges = [];
+  const outgoingTargets = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (fileSet.has(edge.target)) {
+        internalEdges++;
+      } else {
+        outgoingEdges.push({
+          from: f,
+          to: edge.target,
+          specifiers: edge.specifiers
+        });
+        outgoingTargets.add(edge.target);
+      }
+    }
+  }
+  for (const f of files) {
+    for (const edge of graph.reverse.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        incomingEdges.push({
+          from: edge.target,
+          to: f,
+          specifiers: edge.specifiers
+        });
+      }
+    }
+  }
+  const depCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    for (const edge of graph.forward.get(f) ?? []) {
+      if (!fileSet.has(edge.target)) {
+        depCounts.set(edge.target, (depCounts.get(edge.target) ?? 0) + 1);
+      }
+    }
+  }
+  const sharedDependencies = [...depCounts.entries()].filter(([, count]) => count > 1).map(([dep]) => dep);
+  const total = internalEdges + incomingEdges.length + outgoingEdges.length;
+  const isolationScore = total === 0 ? 1 : internalEdges / total;
+  return {
+    internalEdges,
+    incomingEdges,
+    outgoingEdges,
+    sharedDependencies,
+    isolationScore
+  };
+}
+
+// config.ts
+import * as path4 from "path";
+function resolveConfig(toolDir) {
+  const cwd = process.cwd();
+  const projectRoot2 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path4.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path4.basename(path4.dirname(toolDir)) === "plugins" ? path4.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath2 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot2 + path4.sep);
+  const toolRelPath = toolIsEmbedded ? path4.relative(projectRoot2, toolDir) : toolDir;
+  return { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath };
+}
+
+// benchmark.ts
+var projectRoot;
+var tsconfigPath;
+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 += fs4.statSync(path5.resolve(projectRoot, file)).size;
+      } catch {
+      }
+    }
+    return { matches, files: files.length, totalBytes };
+  } catch {
+    return { matches: 0, files: 0, totalBytes: 0 };
+  }
+}
+function relPath(abs) {
+  return path5.relative(projectRoot, abs);
+}
+function percentile(sorted, p) {
+  const idx = Math.ceil(p / 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) => path5.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) => path5.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: fs4.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(path5.basename(c.file))
+  );
+  return preferred?.file ?? candidates[0]?.file ?? null;
+}
+async function benchmarkTokens(client, 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 client.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 client.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 client.navto(highFanout, 10);
+    const refs = navItems.length > 0 ? await client.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 client.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 client.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 basename5 = path5.basename(mostDepended, path5.extname(mostDepended));
+    const grep = grepCount(basename5);
+    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: basename5,
+      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(client, 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 client.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: () => client.navbar(testFileRel) },
+    { name: "ts_definition", fn: () => client.definition(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_references", fn: () => client.references(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_type_info", fn: () => client.quickinfo(testFileRel, span.start.line, span.start.offset) },
+    { name: "ts_navigate_to", fn: () => client.navto(sym.text, 10) },
+    { name: "ts_module_exports", fn: () => client.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 = path5.dirname(testFile);
+        const siblings = [...graph.files].filter((f) => path5.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(client, 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 client.navto(symbol, 10);
+    const defItem = navItems.find((i) => i.name === symbol && i.matchKind === "exact");
+    let defLocation = "";
+    if (defItem) {
+      const defs = await client.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 client.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 basename5 = path5.basename(mostDepended, path5.extname(mostDepended));
+    const grep = grepCount(basename5);
+    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 "${basename5}" 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 main(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 client = new TsServerClient(projectRoot, tsconfigPath);
+  const tsStart = performance.now();
+  await client.start();
+  console.log(`tsserver ready [${(performance.now() - tsStart).toFixed(0)}ms]`);
+  const warmFile = [...graph.files][0];
+  await client.navbar(relPath(warmFile));
+  console.log("");
+  const tokenResults = await benchmarkTokens(client, graph);
+  const latencyResults = await benchmarkLatency(client, graph);
+  const accuracyResults = await benchmarkAccuracy(client, 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("");
+  client.shutdown();
+}
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});
+export {
+  main
+};