typegraph-mcp 0.9.3 → 0.9.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Type-aware TypeScript navigation — 14 MCP tools for go-to-definition, find-references, dependency graphs, cycle detection, and impact analysis",
   "author": {
     "name": "Owen Jones"

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Type-aware TypeScript navigation — 14 MCP tools for go-to-definition, find-references, dependency graphs, cycle detection, and impact analysis",
   "author": {
     "name": "Owen Jones"

package/check.ts

@@ -335,7 +335,13 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
 
   // 10. Module graph build test
   try {
-    const { buildGraph } = await import(path.resolve(toolDir, "module-graph.js"));
+    let buildGraph: (root: string, tsconfig: string) => Promise<{ graph: { files: Set<string>; forward: Map<string, unknown[]> } }>;
+    try {
+      ({ buildGraph } = await import(path.resolve(toolDir, "module-graph.js")));
+    } catch {
+      // Fallback: plugin dir has .ts files only (no tsx at runtime), use the co-bundled version
+      ({ buildGraph } = await import("./module-graph.js"));
+    }
     const start = performance.now();
     const { graph } = await buildGraph(projectRoot, tsconfigPath);
     const elapsed = (performance.now() - start).toFixed(0);
@@ -443,17 +449,3 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
   return { passed, failed, warned };
 }
 
-// ─── Self-run guard ──────────────────────────────────────────────────────────
-
-const isDirectRun =
-  process.argv[1] &&
-  fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url).pathname);
-
-if (isDirectRun) {
-  main()
-    .then((result) => process.exit(result.failed > 0 ? 1 : 0))
-    .catch((err) => {
-      console.error("Fatal error:", err);
-      process.exit(1);
-    });
-}

package/cli.ts

@@ -709,17 +709,29 @@ async function remove(yes: boolean): Promise<void> {
 
 // ─── Check Command ───────────────────────────────────────────────────────────
 
+function resolvePluginDir(): string {
+  // Prefer the installed plugin in the user's project over the npx cache
+  const installed = path.resolve(process.cwd(), PLUGIN_DIR_NAME);
+  if (fs.existsSync(installed)) return installed;
+  // Fall back to the source directory (running from the repo itself)
+  return path.basename(import.meta.dirname) === "dist"
+    ? path.resolve(import.meta.dirname, "..")
+    : import.meta.dirname;
+}
+
 async function check(): Promise<void> {
+  const config = resolveConfig(resolvePluginDir());
   const { main: checkMain } = await import("./check.js");
-  const result = await checkMain();
+  const result = await checkMain(config);
   process.exit(result.failed > 0 ? 1 : 0);
 }
 
 // ─── Test Command ────────────────────────────────────────────────────────────
 
 async function test(): Promise<void> {
+  const config = resolveConfig(resolvePluginDir());
   const { main: testMain } = await import("./smoke-test.js");
-  const result = await testMain();
+  const result = await testMain(config);
   process.exit(result.failed > 0 ? 1 : 0);
 }
 

package/dist/check.js

@@ -1,7 +1,359 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// check.ts
+// module-graph.ts
+var module_graph_exports = {};
+__export(module_graph_exports, {
+  buildGraph: () => buildGraph,
+  createResolver: () => createResolver,
+  discoverFiles: () => discoverFiles,
+  removeFile: () => removeFile,
+  startWatcher: () => startWatcher,
+  updateFile: () => updateFile
+});
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
 import * as fs from "fs";
 import * as path2 from "path";
+function discoverFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.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;
+}
+function distToSource(resolvedPath, projectRoot) {
+  if (!resolvedPath.startsWith(projectRoot)) return resolvedPath;
+  const rel = path2.relative(projectRoot, 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(projectRoot, prefix, "src", withoutExt + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot, 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(projectRoot, prefix, "src", dirPath + ext);
+      if (fs.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 = fs.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);
+  log(`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);
+  log(`Graph built: ${files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+  if (parseFailures.length > 0) {
+    log(`Parse failures: ${parseFailures.length} files`);
+  }
+  return {
+    graph: { forward, reverse, files },
+    resolver
+  };
+}
+function updateFile(graph, filePath, resolver, projectRoot) {
+  const oldEdges = graph.forward.get(filePath) ?? [];
+  for (const edge of oldEdges) {
+    const revEdges = graph.reverse.get(edge.target);
+    if (revEdges) {
+      const idx = revEdges.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges.splice(idx, 1);
+      if (revEdges.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  let source;
+  try {
+    source = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    removeFile(graph, filePath);
+    return;
+  }
+  let rawImports;
+  try {
+    rawImports = parseFileImports(filePath, source);
+  } catch {
+    log(`Parse error on update: ${filePath}`);
+    graph.forward.set(filePath, []);
+    return;
+  }
+  const fromDir = path2.dirname(filePath);
+  const newEdges = [];
+  for (const raw of rawImports) {
+    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+    if (target) {
+      newEdges.push({
+        target,
+        specifiers: raw.names,
+        isTypeOnly: raw.isTypeOnly,
+        isDynamic: raw.isDynamic
+      });
+    }
+  }
+  graph.forward.set(filePath, newEdges);
+  graph.files.add(filePath);
+  for (const edge of newEdges) {
+    let revEdges = graph.reverse.get(edge.target);
+    if (!revEdges) {
+      revEdges = [];
+      graph.reverse.set(edge.target, revEdges);
+    }
+    revEdges.push({
+      target: filePath,
+      specifiers: edge.specifiers,
+      isTypeOnly: edge.isTypeOnly,
+      isDynamic: edge.isDynamic
+    });
+  }
+}
+function removeFile(graph, filePath) {
+  const edges = graph.forward.get(filePath) ?? [];
+  for (const edge of edges) {
+    const revEdges2 = graph.reverse.get(edge.target);
+    if (revEdges2) {
+      const idx = revEdges2.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges2.splice(idx, 1);
+      if (revEdges2.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  const revEdges = graph.reverse.get(filePath) ?? [];
+  for (const revEdge of revEdges) {
+    const fwdEdges = graph.forward.get(revEdge.target);
+    if (fwdEdges) {
+      const idx = fwdEdges.findIndex((e) => e.target === filePath);
+      if (idx !== -1) fwdEdges.splice(idx, 1);
+    }
+  }
+  graph.forward.delete(filePath);
+  graph.reverse.delete(filePath);
+  graph.files.delete(filePath);
+}
+function startWatcher(projectRoot, graph, resolver) {
+  try {
+    const watcher = fs.watch(
+      projectRoot,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (!filename) return;
+        const ext = path2.extname(filename);
+        if (!TS_EXTENSIONS.has(ext)) return;
+        const parts = filename.split(path2.sep);
+        if (parts.some((p) => SKIP_DIRS.has(p))) return;
+        if (SKIP_FILES.has(path2.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath = path2.resolve(projectRoot, filename);
+        if (fs.existsSync(absPath)) {
+          updateFile(graph, absPath, resolver, projectRoot);
+        } else {
+          removeFile(graph, absPath);
+        }
+      }
+    );
+    process.on("SIGINT", () => watcher.close());
+    process.on("SIGTERM", () => watcher.close());
+    log("File watcher started");
+  } catch (err) {
+    log("Failed to start file watcher:", err);
+  }
+}
+var log, TS_EXTENSIONS, SKIP_DIRS, SKIP_FILES, SOURCE_EXTS;
+var init_module_graph = __esm({
+  "module-graph.ts"() {
+    log = (...args) => console.error("[typegraph/graph]", ...args);
+    TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".wrangler",
+      ".mf",
+      ".git",
+      ".next",
+      ".turbo",
+      "coverage"
+    ]);
+    SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+    SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+  }
+});
+
+// check.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
 import { createRequire } from "module";
 import { spawn } from "child_process";
 
@@ -20,14 +372,14 @@ function resolveConfig(toolDir) {
 function findFirstTsFile(dir) {
   const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
   try {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
-        return path2.join(dir, entry.name);
+        return path3.join(dir, entry.name);
       }
     }
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
-        const found = findFirstTsFile(path2.join(dir, entry.name));
+        const found = findFirstTsFile(path3.join(dir, entry.name));
         if (found) return found;
       }
     }
@@ -36,13 +388,13 @@ function findFirstTsFile(dir) {
   return null;
 }
 function testTsserver(projectRoot) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let tsserverPath;
     try {
-      const require2 = createRequire(path2.resolve(projectRoot, "package.json"));
+      const require2 = createRequire(path3.resolve(projectRoot, "package.json"));
       tsserverPath = require2.resolve("typescript/lib/tsserver.js");
     } catch {
-      resolve3(false);
+      resolve4(false);
       return;
     }
     const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
@@ -51,7 +403,7 @@ function testTsserver(projectRoot) {
     });
     const timeout = setTimeout(() => {
       child.kill();
-      resolve3(false);
+      resolve4(false);
     }, 1e4);
     let buffer = "";
     child.stdout.on("data", (chunk) => {
@@ -59,12 +411,12 @@ function testTsserver(projectRoot) {
       if (buffer.includes('"success":true')) {
         clearTimeout(timeout);
         child.kill();
-        resolve3(true);
+        resolve4(true);
       }
     });
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve3(false);
+      resolve4(false);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
@@ -114,8 +466,8 @@ async function main(configOverride) {
   } else {
     fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 18");
   }
-  const tsxInRoot = fs.existsSync(path2.join(projectRoot, "node_modules/.bin/tsx"));
-  const tsxInTool = fs.existsSync(path2.join(toolDir, "node_modules/.bin/tsx"));
+  const tsxInRoot = fs2.existsSync(path3.join(projectRoot, "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)`);
   } else {
@@ -123,10 +475,10 @@ async function main(configOverride) {
   }
   let tsVersion = null;
   try {
-    const require2 = createRequire(path2.resolve(projectRoot, "package.json"));
+    const require2 = createRequire(path3.resolve(projectRoot, "package.json"));
     const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    const tsPkgPath = path2.resolve(path2.dirname(tsserverPath), "..", "package.json");
-    const tsPkg = JSON.parse(fs.readFileSync(tsPkgPath, "utf-8"));
+    const tsPkgPath = path3.resolve(path3.dirname(tsserverPath), "..", "package.json");
+    const tsPkg = JSON.parse(fs2.readFileSync(tsPkgPath, "utf-8"));
     tsVersion = tsPkg.version;
     pass(`TypeScript found (v${tsVersion})`);
   } catch {
@@ -135,23 +487,23 @@ async function main(configOverride) {
       "Add `typescript` to devDependencies and run `npm install`"
     );
   }
-  const tsconfigAbs = path2.resolve(projectRoot, tsconfigPath);
-  if (fs.existsSync(tsconfigAbs)) {
+  const tsconfigAbs = path3.resolve(projectRoot, tsconfigPath);
+  if (fs2.existsSync(tsconfigAbs)) {
     pass(`tsconfig.json exists at ${tsconfigPath}`);
   } else {
     fail(`tsconfig.json not found at ${tsconfigPath}`, `Create a tsconfig.json at ${tsconfigPath}`);
   }
-  const pluginMcpPath = path2.join(toolDir, ".mcp.json");
-  const hasPluginMcp = fs.existsSync(pluginMcpPath) && fs.existsSync(path2.join(toolDir, ".claude-plugin/plugin.json"));
+  const pluginMcpPath = path3.join(toolDir, ".mcp.json");
+  const hasPluginMcp = fs2.existsSync(pluginMcpPath) && fs2.existsSync(path3.join(toolDir, ".claude-plugin/plugin.json"));
   if (process.env.CLAUDE_PLUGIN_ROOT) {
     pass("MCP registered via plugin (CLAUDE_PLUGIN_ROOT set)");
   } else if (hasPluginMcp) {
     pass("MCP registered via plugin (.mcp.json + .claude-plugin/ present)");
   } else {
-    const mcpJsonPath = path2.resolve(projectRoot, ".claude/mcp.json");
-    if (fs.existsSync(mcpJsonPath)) {
+    const mcpJsonPath = path3.resolve(projectRoot, ".claude/mcp.json");
+    if (fs2.existsSync(mcpJsonPath)) {
       try {
-        const mcpJson = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
+        const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
         const tsNav = mcpJson?.mcpServers?.["typegraph"];
         if (tsNav) {
           const hasCommand = tsNav.command === "npx";
@@ -170,7 +522,7 @@ async function main(configOverride) {
             );
           }
         } else {
-          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path2.resolve(toolDir, "server.ts");
+          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path3.resolve(toolDir, "server.ts");
           fail(
             "MCP entry 'typegraph' not found in .claude/mcp.json",
             `Add to .claude/mcp.json:
@@ -195,11 +547,11 @@ async function main(configOverride) {
       fail(".claude/mcp.json not found", `Create .claude/mcp.json with typegraph server registration`);
     }
   }
-  const toolNodeModules = path2.join(toolDir, "node_modules");
-  if (fs.existsSync(toolNodeModules)) {
+  const toolNodeModules = path3.join(toolDir, "node_modules");
+  if (fs2.existsSync(toolNodeModules)) {
     const requiredPkgs = ["@modelcontextprotocol/sdk", "oxc-parser", "oxc-resolver", "zod"];
     const missing = requiredPkgs.filter(
-      (pkg) => !fs.existsSync(path2.join(toolNodeModules, ...pkg.split("/")))
+      (pkg) => !fs2.existsSync(path3.join(toolNodeModules, ...pkg.split("/")))
     );
     if (missing.length === 0) {
       pass(`Dependencies installed (${requiredPkgs.length} packages)`);
@@ -210,9 +562,9 @@ async function main(configOverride) {
     fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && npm install\``);
   }
   try {
-    const oxcParserReq = createRequire(path2.join(toolDir, "package.json"));
-    const { parseSync } = await import(oxcParserReq.resolve("oxc-parser"));
-    const result = parseSync("test.ts", 'import { x } from "./y";');
+    const oxcParserReq = createRequire(path3.join(toolDir, "package.json"));
+    const { parseSync: parseSync2 } = await import(oxcParserReq.resolve("oxc-parser"));
+    const result = parseSync2("test.ts", 'import { x } from "./y";');
     if (result.module?.staticImports?.length === 1) {
       pass("oxc-parser working");
     } else {
@@ -228,9 +580,9 @@ async function main(configOverride) {
     );
   }
   try {
-    const oxcResolverReq = createRequire(path2.join(toolDir, "package.json"));
-    const { ResolverFactory } = await import(oxcResolverReq.resolve("oxc-resolver"));
-    const resolver = new ResolverFactory({
+    const oxcResolverReq = createRequire(path3.join(toolDir, "package.json"));
+    const { ResolverFactory: ResolverFactory2 } = await import(oxcResolverReq.resolve("oxc-resolver"));
+    const resolver = new ResolverFactory2({
       tsconfig: { configFile: tsconfigAbs, references: "auto" },
       extensions: [".ts", ".tsx", ".js"],
       extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
@@ -238,8 +590,8 @@ async function main(configOverride) {
     let resolveOk = false;
     const testFile = findFirstTsFile(projectRoot);
     if (testFile) {
-      const dir = path2.dirname(testFile);
-      const base = "./" + path2.basename(testFile);
+      const dir = path3.dirname(testFile);
+      const base = "./" + path3.basename(testFile);
       const result = resolver.sync(dir, base);
       resolveOk = !!result.path;
     }
@@ -278,9 +630,14 @@ async function main(configOverride) {
     skip("tsserver test (TypeScript not found)");
   }
   try {
-    const { buildGraph } = await import(path2.resolve(toolDir, "module-graph.js"));
+    let buildGraph2;
+    try {
+      ({ buildGraph: buildGraph2 } = await import(path3.resolve(toolDir, "module-graph.js")));
+    } catch {
+      ({ buildGraph: buildGraph2 } = await Promise.resolve().then(() => (init_module_graph(), module_graph_exports)));
+    }
     const start = performance.now();
-    const { graph } = await buildGraph(projectRoot, tsconfigPath);
+    const { graph } = await buildGraph2(projectRoot, tsconfigPath);
     const elapsed = (performance.now() - start).toFixed(0);
     const edgeCount = [...graph.forward.values()].reduce(
       (s, e) => s + e.length,
@@ -306,10 +663,10 @@ async function main(configOverride) {
     );
   }
   if (toolIsEmbedded) {
-    const eslintConfigPath = path2.resolve(projectRoot, "eslint.config.mjs");
-    if (fs.existsSync(eslintConfigPath)) {
-      const eslintContent = fs.readFileSync(eslintConfigPath, "utf-8");
-      const parentDir = path2.basename(path2.dirname(toolDir));
+    const eslintConfigPath = path3.resolve(projectRoot, "eslint.config.mjs");
+    if (fs2.existsSync(eslintConfigPath)) {
+      const eslintContent = fs2.readFileSync(eslintConfigPath, "utf-8");
+      const parentDir = path3.basename(path3.dirname(toolDir));
       const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
       const hasParentIgnore = parentIgnorePattern.test(eslintContent);
       if (hasParentIgnore) {
@@ -327,14 +684,14 @@ async function main(configOverride) {
   } else {
     skip("ESLint config check (typegraph-mcp is external to project)");
   }
-  const gitignorePath = path2.resolve(projectRoot, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path3.resolve(projectRoot, ".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("#"));
     const ignoresClaude = lines.some(
       (l) => l === ".claude/" || l === ".claude" || l === "/.claude"
     );
-    const parentDir = toolIsEmbedded ? path2.basename(path2.dirname(toolDir)) : null;
+    const parentDir = toolIsEmbedded ? path3.basename(path3.dirname(toolDir)) : null;
     const ignoresParent = parentDir && lines.some((l) => l === `${parentDir}/` || l === parentDir || l === `/${parentDir}`);
     if (!ignoresParent && !ignoresClaude) {
       pass(".gitignore does not exclude .claude/" + (parentDir ? ` or ${parentDir}/` : ""));
@@ -364,13 +721,6 @@ async function main(configOverride) {
   console.log("");
   return { passed, failed, warned };
 }
-var isDirectRun = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url).pathname);
-if (isDirectRun) {
-  main().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
-    console.error("Fatal error:", err);
-    process.exit(1);
-  });
-}
 export {
   main
 };