typegraph-mcp 0.9.1 → 0.9.3

package/dist/smoke-test.js

@@ -0,0 +1,1148 @@
+
+// smoke-test.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// 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(projectRoot, tsconfigPath = "./tsconfig.json") {
+    this.projectRoot = projectRoot;
+    this.tsconfigPath = tsconfigPath;
+  }
+  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((resolve5, 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: resolve5, 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, projectRoot) {
+  if (!resolvedPath.startsWith(projectRoot)) return resolvedPath;
+  const rel2 = path2.relative(projectRoot, 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(projectRoot, prefix, "src", withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot, 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(projectRoot, prefix, "src", dirPath + ext);
+      if (fs2.existsSync(candidate)) return candidate;
+    }
+  }
+  return resolvedPath;
+}
+function resolveImport(resolver, fromDir, specifier, projectRoot) {
+  try {
+    const result = resolver.sync(fromDir, specifier);
+    if (result.path && !result.path.includes("node_modules")) {
+      const mapped = distToSource(result.path, projectRoot);
+      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(projectRoot, tsconfigPath) {
+  return new ResolverFactory({
+    tsconfig: {
+      configFile: path2.resolve(projectRoot, tsconfigPath),
+      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, projectRoot) {
+  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, projectRoot);
+      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(projectRoot, tsconfigPath) {
+  const startTime = performance.now();
+  const resolver = createResolver(projectRoot, tsconfigPath);
+  const fileList = discoverFiles(projectRoot);
+  log2(`Discovered ${fileList.length} source files`);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot);
+  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 projectRoot = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path4.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path4.basename(path4.dirname(toolDir)) === "plugins" ? path4.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot + path4.sep);
+  const toolRelPath = toolIsEmbedded ? path4.relative(projectRoot, toolDir) : toolDir;
+  return { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath };
+}
+
+// smoke-test.ts
+function rel(absPath, projectRoot) {
+  return path5.relative(projectRoot, absPath);
+}
+function findInNavBar(items, predicate) {
+  for (const item of items) {
+    if (predicate(item)) return item;
+    if (item.childItems?.length > 0) {
+      const found = findInNavBar(item.childItems, predicate);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  ".wrangler",
+  "coverage",
+  "out"
+]);
+function findTestFile(rootDir) {
+  const candidates = [];
+  function walk(dir, depth) {
+    if (depth > 5 || candidates.length >= 30) return;
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
+        walk(path5.join(dir, entry.name), depth + 1);
+      } else if (entry.isFile()) {
+        const name = entry.name;
+        if (name.endsWith(".d.ts") || name.endsWith(".test.ts") || name.endsWith(".spec.ts"))
+          continue;
+        if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
+        try {
+          const stat = fs4.statSync(path5.join(dir, name));
+          if (stat.size > 200 && stat.size < 5e4) {
+            candidates.push({ file: path5.join(dir, name), size: stat.size });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  walk(rootDir, 0);
+  const preferred = candidates.find(
+    (c) => /service|handler|controller|repository|provider/i.test(path5.basename(c.file))
+  );
+  const fallback = candidates.sort((a, b) => b.size - a.size)[0];
+  return preferred?.file ?? fallback?.file ?? null;
+}
+function findImporter(graph, file) {
+  const revEdges = graph.reverse.get(file);
+  if (!revEdges || revEdges.length === 0) return null;
+  const preferred = revEdges.find(
+    (e) => !e.target.includes(".test.") && !e.target.endsWith("index.ts")
+  );
+  return (preferred ?? revEdges[0]).target;
+}
+async function main(configOverride) {
+  const { projectRoot, tsconfigPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  function pass(name, detail, ms) {
+    console.log(`  \u2713 ${name} [${ms.toFixed(0)}ms]`);
+    console.log(`    ${detail}`);
+    passed++;
+  }
+  function fail(name, detail, ms) {
+    console.log(`  \u2717 ${name} [${ms.toFixed(0)}ms]`);
+    console.log(`    ${detail}`);
+    failed++;
+  }
+  function skip(name, reason) {
+    console.log(`  - ${name} (skipped: ${reason})`);
+    skipped++;
+  }
+  console.log("");
+  console.log("typegraph-mcp Smoke Test");
+  console.log("=====================");
+  console.log(`Project root: ${projectRoot}`);
+  console.log("");
+  const testFile = findTestFile(projectRoot);
+  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, projectRoot);
+  console.log(`Test subject: ${testFileRel}`);
+  console.log("");
+  console.log("\u2500\u2500 Module Graph \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  let graph;
+  let t0;
+  t0 = performance.now();
+  try {
+    const result = await buildGraph(projectRoot, tsconfigPath);
+    graph = result.graph;
+    const ms = performance.now() - t0;
+    const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
+    if (graph.files.size > 0) {
+      pass("graph build", `${graph.files.size} files, ${edgeCount} edges`, ms);
+    } else {
+      fail("graph build", "0 files discovered", ms);
+      console.log("\nCannot continue without module graph.");
+      return { passed, failed, skipped };
+    }
+  } catch (err) {
+    fail(
+      "graph build",
+      `Error: ${err instanceof Error ? err.message : String(err)}`,
+      performance.now() - t0
+    );
+    console.log("\nCannot continue without module graph.");
+    return { passed, failed, skipped };
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = dependencyTree(graph, testFile);
+    pass(
+      "dependency_tree",
+      `${result.nodes} transitive deps from ${testFileRel}`,
+      performance.now() - t0
+    );
+  } else {
+    skip("dependency_tree", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = dependents(graph, testFile);
+    pass(
+      "dependents",
+      `${result.nodes} dependents (${result.directCount} direct)`,
+      performance.now() - t0
+    );
+  } else {
+    skip("dependents", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  const cycles = importCycles(graph);
+  pass("import_cycles", `${cycles.count} cycle(s) detected`, performance.now() - t0);
+  t0 = performance.now();
+  const importer = findImporter(graph, testFile);
+  if (importer && graph.files.has(testFile)) {
+    const result = shortestPath(graph, importer, testFile);
+    const ms = performance.now() - t0;
+    if (result.path) {
+      pass("shortest_path", `${result.hops} hops: ${result.path.map((p) => rel(p, projectRoot)).join(" -> ")}`, ms);
+    } else {
+      pass("shortest_path", `No path from ${rel(importer, projectRoot)} (may be type-only)`, ms);
+    }
+  } else {
+    skip("shortest_path", "No importer found for test file");
+  }
+  t0 = performance.now();
+  if (graph.files.has(testFile)) {
+    const result = subgraph(graph, [testFile], { depth: 1, direction: "both" });
+    pass(
+      "subgraph",
+      `${result.stats.nodeCount} nodes, ${result.stats.edgeCount} edges (depth 1)`,
+      performance.now() - t0
+    );
+  } else {
+    skip("subgraph", `${testFileRel} not in graph`);
+  }
+  t0 = performance.now();
+  const dir = path5.dirname(testFile);
+  const siblings = [...graph.files].filter((f) => path5.dirname(f) === dir);
+  if (siblings.length >= 2) {
+    const result = moduleBoundary(graph, siblings);
+    pass(
+      "module_boundary",
+      `${siblings.length} files in ${rel(dir, projectRoot)}/: ${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, projectRoot)}/`);
+  }
+  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 client = new TsServerClient(projectRoot, tsconfigPath);
+  t0 = performance.now();
+  await client.start();
+  console.log(`  (started in ${(performance.now() - t0).toFixed(0)}ms)`);
+  t0 = performance.now();
+  const bar = await client.navbar(testFileRel);
+  const navbarMs = performance.now() - t0;
+  const symbolKinds = /* @__PURE__ */ new Set([
+    "function",
+    "const",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "var",
+    "let",
+    "method"
+  ]);
+  const allSymbols = [];
+  function collectSymbols(items) {
+    for (const item of items) {
+      if (symbolKinds.has(item.kind) && item.text !== "<function>" && item.spans.length > 0) {
+        allSymbols.push(item);
+      }
+      if (item.childItems?.length > 0) collectSymbols(item.childItems);
+    }
+  }
+  collectSymbols(bar);
+  if (allSymbols.length > 0) {
+    pass("navbar", `${allSymbols.length} symbols in ${testFileRel}`, navbarMs);
+  } else {
+    fail("navbar", `No symbols found in ${testFileRel}`, navbarMs);
+  }
+  const concreteKinds = /* @__PURE__ */ new Set(["const", "function", "class", "var", "let", "enum"]);
+  const sym = allSymbols.find((s) => concreteKinds.has(s.kind)) ?? allSymbols[0];
+  if (!sym) {
+    const toolNames = [
+      "find_symbol",
+      "definition",
+      "references",
+      "type_info",
+      "navigate_to",
+      "blast_radius",
+      "module_exports",
+      "trace_chain"
+    ];
+    for (const name of toolNames) skip(name, "No symbol discovered");
+  } else {
+    const span = sym.spans[0];
+    t0 = performance.now();
+    const found = findInNavBar(bar, (item) => item.text === sym.text && item.kind === sym.kind);
+    if (found && found.spans.length > 0) {
+      pass(
+        "find_symbol",
+        `${sym.text} [${sym.kind}] at line ${found.spans[0].start.line}`,
+        performance.now() - t0
+      );
+    } else {
+      fail("find_symbol", `Could not re-find ${sym.text}`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const defs = await client.definition(testFileRel, span.start.line, span.start.offset);
+    if (defs.length > 0) {
+      const def = defs[0];
+      pass("definition", `${sym.text} -> ${def.file}:${def.start.line}`, performance.now() - t0);
+    } else {
+      pass("definition", `${sym.text} is its own definition`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const refs = await client.references(testFileRel, span.start.line, span.start.offset);
+    const refFiles = new Set(refs.map((r) => r.file));
+    pass(
+      "references",
+      `${refs.length} ref(s) across ${refFiles.size} file(s)`,
+      performance.now() - t0
+    );
+    t0 = performance.now();
+    const info = await client.quickinfo(testFileRel, span.start.line, span.start.offset);
+    if (info) {
+      const typeStr = info.displayString.length > 80 ? info.displayString.slice(0, 80) + "..." : info.displayString;
+      pass("type_info", typeStr, performance.now() - t0);
+    } else {
+      fail("type_info", `No type info for ${sym.text}`, performance.now() - t0);
+    }
+    t0 = performance.now();
+    const navItems = await client.navto(sym.text, 5);
+    if (navItems.length > 0) {
+      const files = new Set(navItems.map((i) => i.file));
+      pass(
+        "navigate_to",
+        `${navItems.length} match(es) for "${sym.text}" in ${files.size} file(s)`,
+        performance.now() - t0
+      );
+    } else {
+      pass(
+        "navigate_to",
+        `"${sym.text}" not indexed by navto (expected for some kinds)`,
+        performance.now() - t0
+      );
+    }
+    t0 = performance.now();
+    const callers = refs.filter((r) => !r.isDefinition);
+    const callerFiles = new Set(callers.map((r) => r.file));
+    pass(
+      "blast_radius",
+      `${callers.length} usage(s) across ${callerFiles.size} file(s)`,
+      performance.now() - t0
+    );
+    t0 = performance.now();
+    const moduleItem = bar.find((item) => item.kind === "module");
+    const topItems = moduleItem?.childItems ?? bar;
+    const exportSymbols = topItems.filter((item) => symbolKinds.has(item.kind));
+    pass("module_exports", `${exportSymbols.length} top-level symbol(s)`, performance.now() - t0);
+    t0 = performance.now();
+    const source = fs4.readFileSync(testFile, "utf-8");
+    const importMatch = source.match(/^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/m);
+    if (importMatch) {
+      const firstName = importMatch[1].split(",")[0].replace(/^type\s+/, "").trim();
+      const importSym = findInNavBar(bar, (item) => item.text === firstName);
+      if (importSym && importSym.spans.length > 0) {
+        const chain = [testFileRel];
+        let cur = {
+          file: testFileRel,
+          line: importSym.spans[0].start.line,
+          offset: importSym.spans[0].start.offset
+        };
+        for (let i = 0; i < 5; i++) {
+          const hopDefs = await client.definition(cur.file, cur.line, cur.offset);
+          if (hopDefs.length === 0) break;
+          const hop = hopDefs[0];
+          if (hop.file === cur.file && hop.start.line === cur.line) break;
+          if (hop.file.includes("node_modules")) break;
+          chain.push(`${hop.file}:${hop.start.line}`);
+          cur = { file: hop.file, line: hop.start.line, offset: hop.start.offset };
+        }
+        if (chain.length > 1) {
+          pass(
+            "trace_chain",
+            `${chain.length - 1} hop(s): ${chain.join(" -> ")}`,
+            performance.now() - t0
+          );
+        } else {
+          pass(
+            "trace_chain",
+            `"${firstName}" resolved in-file (0 external hops)`,
+            performance.now() - t0
+          );
+        }
+      } else {
+        pass(
+          "trace_chain",
+          `"${firstName}" not in navbar (may be type-only)`,
+          performance.now() - t0
+        );
+      }
+    } else {
+      skip("trace_chain", "No brace imports in test file");
+    }
+  }
+  client.shutdown();
+  console.log("");
+  const total = passed + failed;
+  if (failed === 0) {
+    console.log(
+      `${passed}/${total} passed` + (skipped > 0 ? ` (${skipped} skipped)` : "") + " -- all tools working"
+    );
+  } else {
+    console.log(
+      `${passed}/${total} passed, ${failed} failed` + (skipped > 0 ? `, ${skipped} skipped` : "") + " -- some tools may not work correctly"
+    );
+  }
+  console.log("");
+  return { passed, failed, skipped };
+}
+var isDirectRun = process.argv[1] && fs4.realpathSync(process.argv[1]) === fs4.realpathSync(new URL(import.meta.url).pathname);
+if (isDirectRun) {
+  main().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+  });
+}
+export {
+  main
+};