typegraph-mcp 0.9.3 → 0.9.5

package/dist/cli.js

@@ -24,26 +24,369 @@ var init_config = __esm({
   }
 });
 
+// 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, projectRoot2) {
+  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
+  const rel2 = path2.relative(projectRoot2, resolvedPath);
+  const distIdx = rel2.indexOf("dist" + path2.sep);
+  if (distIdx === -1) return resolvedPath;
+  const prefix = rel2.slice(0, distIdx);
+  const afterDist = rel2.slice(distIdx + 5);
+  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, "src", withoutExt + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path2.resolve(projectRoot2, prefix, withoutExt + ext);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path2.resolve(projectRoot2, prefix, "src", dirPath + ext);
+      if (fs.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 = 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, 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);
+  log(`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);
+  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, projectRoot2) {
+  const oldEdges = graph.forward.get(filePath) ?? [];
+  for (const edge of oldEdges) {
+    const revEdges = graph.reverse.get(edge.target);
+    if (revEdges) {
+      const idx = revEdges.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges.splice(idx, 1);
+      if (revEdges.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  let source;
+  try {
+    source = 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, projectRoot2);
+    if (target) {
+      newEdges.push({
+        target,
+        specifiers: raw.names,
+        isTypeOnly: raw.isTypeOnly,
+        isDynamic: raw.isDynamic
+      });
+    }
+  }
+  graph.forward.set(filePath, newEdges);
+  graph.files.add(filePath);
+  for (const edge of newEdges) {
+    let revEdges = graph.reverse.get(edge.target);
+    if (!revEdges) {
+      revEdges = [];
+      graph.reverse.set(edge.target, revEdges);
+    }
+    revEdges.push({
+      target: filePath,
+      specifiers: edge.specifiers,
+      isTypeOnly: edge.isTypeOnly,
+      isDynamic: edge.isDynamic
+    });
+  }
+}
+function removeFile(graph, filePath) {
+  const edges = graph.forward.get(filePath) ?? [];
+  for (const edge of edges) {
+    const revEdges2 = graph.reverse.get(edge.target);
+    if (revEdges2) {
+      const idx = revEdges2.findIndex((r) => r.target === filePath);
+      if (idx !== -1) revEdges2.splice(idx, 1);
+      if (revEdges2.length === 0) graph.reverse.delete(edge.target);
+    }
+  }
+  const revEdges = graph.reverse.get(filePath) ?? [];
+  for (const revEdge of revEdges) {
+    const fwdEdges = graph.forward.get(revEdge.target);
+    if (fwdEdges) {
+      const idx = fwdEdges.findIndex((e) => e.target === filePath);
+      if (idx !== -1) fwdEdges.splice(idx, 1);
+    }
+  }
+  graph.forward.delete(filePath);
+  graph.reverse.delete(filePath);
+  graph.files.delete(filePath);
+}
+function startWatcher(projectRoot2, graph, resolver) {
+  try {
+    const watcher = fs.watch(
+      projectRoot2,
+      { 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((p2) => SKIP_DIRS.has(p2))) return;
+        if (SKIP_FILES.has(path2.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath2 = path2.resolve(projectRoot2, filename);
+        if (fs.existsSync(absPath2)) {
+          updateFile(graph, absPath2, resolver, projectRoot2);
+        } else {
+          removeFile(graph, absPath2);
+        }
+      }
+    );
+    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 = (...args2) => console.error("[typegraph/graph]", ...args2);
+    TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".wrangler",
+      ".mf",
+      ".git",
+      ".next",
+      ".turbo",
+      "coverage"
+    ]);
+    SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
+    SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+  }
+});
+
 // check.ts
 var check_exports = {};
 __export(check_exports, {
   main: () => main
 });
-import * as fs from "fs";
-import * as path2 from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
 import { createRequire } from "module";
 import { spawn } from "child_process";
 function findFirstTsFile(dir) {
   const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
   try {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    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;
       }
     }
@@ -55,7 +398,7 @@ function testTsserver(projectRoot2) {
   return new Promise((resolve8) => {
     let tsserverPath;
     try {
-      const require2 = createRequire(path2.resolve(projectRoot2, "package.json"));
+      const require2 = createRequire(path3.resolve(projectRoot2, "package.json"));
       tsserverPath = require2.resolve("typescript/lib/tsserver.js");
     } catch {
       resolve8(false);
@@ -130,8 +473,8 @@ async function main(configOverride) {
   } else {
     fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 18");
   }
-  const tsxInRoot = fs.existsSync(path2.join(projectRoot2, "node_modules/.bin/tsx"));
-  const tsxInTool = fs.existsSync(path2.join(toolDir, "node_modules/.bin/tsx"));
+  const tsxInRoot = fs2.existsSync(path3.join(projectRoot2, "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 {
@@ -139,10 +482,10 @@ async function main(configOverride) {
   }
   let tsVersion = null;
   try {
-    const require2 = createRequire(path2.resolve(projectRoot2, "package.json"));
+    const require2 = createRequire(path3.resolve(projectRoot2, "package.json"));
     const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    const tsPkgPath = path2.resolve(path2.dirname(tsserverPath), "..", "package.json");
-    const tsPkg = JSON.parse(fs.readFileSync(tsPkgPath, "utf-8"));
+    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 {
@@ -151,23 +494,23 @@ async function main(configOverride) {
       "Add `typescript` to devDependencies and run `npm install`"
     );
   }
-  const tsconfigAbs = path2.resolve(projectRoot2, tsconfigPath2);
-  if (fs.existsSync(tsconfigAbs)) {
+  const tsconfigAbs = path3.resolve(projectRoot2, tsconfigPath2);
+  if (fs2.existsSync(tsconfigAbs)) {
     pass(`tsconfig.json exists at ${tsconfigPath2}`);
   } else {
     fail(`tsconfig.json not found at ${tsconfigPath2}`, `Create a tsconfig.json at ${tsconfigPath2}`);
   }
-  const pluginMcpPath = path2.join(toolDir, ".mcp.json");
-  const hasPluginMcp = fs.existsSync(pluginMcpPath) && fs.existsSync(path2.join(toolDir, ".claude-plugin/plugin.json"));
+  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(projectRoot2, ".claude/mcp.json");
-    if (fs.existsSync(mcpJsonPath)) {
+    const mcpJsonPath = path3.resolve(projectRoot2, ".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";
@@ -186,7 +529,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:
@@ -211,11 +554,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)`);
@@ -226,7 +569,7 @@ 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 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) {
@@ -244,7 +587,7 @@ async function main(configOverride) {
     );
   }
   try {
-    const oxcResolverReq = createRequire(path2.join(toolDir, "package.json"));
+    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" },
@@ -254,8 +597,8 @@ async function main(configOverride) {
     let resolveOk = false;
     const testFile = findFirstTsFile(projectRoot2);
     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;
     }
@@ -294,7 +637,12 @@ async function main(configOverride) {
     skip("tsserver test (TypeScript not found)");
   }
   try {
-    const { buildGraph: buildGraph2 } = 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 start2 = performance.now();
     const { graph } = await buildGraph2(projectRoot2, tsconfigPath2);
     const elapsed = (performance.now() - start2).toFixed(0);
@@ -322,10 +670,10 @@ async function main(configOverride) {
     );
   }
   if (toolIsEmbedded) {
-    const eslintConfigPath = path2.resolve(projectRoot2, "eslint.config.mjs");
-    if (fs.existsSync(eslintConfigPath)) {
-      const eslintContent = fs.readFileSync(eslintConfigPath, "utf-8");
-      const parentDir = path2.basename(path2.dirname(toolDir));
+    const eslintConfigPath = path3.resolve(projectRoot2, "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) {
@@ -343,14 +691,14 @@ async function main(configOverride) {
   } else {
     skip("ESLint config check (typegraph-mcp is external to project)");
   }
-  const gitignorePath = path2.resolve(projectRoot2, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path3.resolve(projectRoot2, ".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}/` : ""));
@@ -380,29 +728,21 @@ async function main(configOverride) {
   console.log("");
   return { passed, failed, warned };
 }
-var isDirectRun;
 var init_check = __esm({
   "check.ts"() {
     init_config();
-    isDirectRun = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url).pathname);
-    if (isDirectRun) {
-      main().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
-        console.error("Fatal error:", err);
-        process.exit(1);
-      });
-    }
   }
 });
 
 // tsserver-client.ts
 import { spawn as spawn2 } from "child_process";
-import * as path3 from "path";
-import * as fs2 from "fs";
+import * as path4 from "path";
+import * as fs3 from "fs";
 import { createRequire as createRequire2 } from "module";
-var log, REQUEST_TIMEOUT_MS, TsServerClient;
+var log2, REQUEST_TIMEOUT_MS, TsServerClient;
 var init_tsserver_client = __esm({
   "tsserver-client.ts"() {
-    log = (...args2) => console.error("[typegraph/tsserver]", ...args2);
+    log2 = (...args2) => console.error("[typegraph/tsserver]", ...args2);
     REQUEST_TIMEOUT_MS = 1e4;
     TsServerClient = class {
       constructor(projectRoot2, tsconfigPath2 = "./tsconfig.json") {
@@ -420,16 +760,16 @@ var init_tsserver_client = __esm({
       maxRestarts = 3;
       // ─── Path Resolution ────────────────────────────────────────────────────
       resolvePath(file) {
-        return path3.isAbsolute(file) ? file : path3.resolve(this.projectRoot, file);
+        return path4.isAbsolute(file) ? file : path4.resolve(this.projectRoot, file);
       }
       relativePath(file) {
-        return path3.relative(this.projectRoot, file);
+        return path4.relative(this.projectRoot, file);
       }
       /** Read a line from a file (1-based line number). Returns trimmed content. */
       readLine(file, line) {
         try {
           const absPath2 = this.resolvePath(file);
-          const content = fs2.readFileSync(absPath2, "utf-8");
+          const content = fs3.readFileSync(absPath2, "utf-8");
           const lines = content.split("\n");
           return lines[line - 1]?.trim() ?? "";
         } catch {
@@ -439,11 +779,11 @@ var init_tsserver_client = __esm({
       // ─── Lifecycle ──────────────────────────────────────────────────────────
       async start() {
         if (this.child) return;
-        const require2 = createRequire2(path3.resolve(this.projectRoot, "package.json"));
+        const require2 = createRequire2(path4.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}`);
+        log2(`Spawning tsserver: ${tsserverPath}`);
+        log2(`Project root: ${this.projectRoot}`);
+        log2(`tsconfig: ${this.tsconfigPath}`);
         this.child = spawn2("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
           cwd: this.projectRoot,
           stdio: ["pipe", "pipe", "pipe"],
@@ -452,16 +792,16 @@ var init_tsserver_client = __esm({
         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}`);
+          if (text) log2(`[stderr] ${text}`);
         });
         this.child.on("close", (code) => {
-          log(`tsserver exited with code ${code}`);
+          log2(`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}`);
+          log2(`tsserver error: ${err.message}`);
           this.rejectAllPending(err);
         });
         await this.sendRequest("configure", {
@@ -471,13 +811,13 @@ var init_tsserver_client = __esm({
         });
         const warmStart = performance.now();
         const tsconfigAbs = this.resolvePath(this.tsconfigPath);
-        if (fs2.existsSync(tsconfigAbs)) {
+        if (fs3.existsSync(tsconfigAbs)) {
           await this.sendRequest("compilerOptionsForInferredProjects", {
             options: { allowJs: true, checkJs: false }
           });
         }
         this.ready = true;
-        log(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
+        log2(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
       }
       shutdown() {
         this.shuttingDown = true;
@@ -490,11 +830,11 @@ var init_tsserver_client = __esm({
       tryRestart() {
         if (this.shuttingDown) return;
         if (this.restartCount >= this.maxRestarts) {
-          log(`Max restarts (${this.maxRestarts}) reached, not restarting`);
+          log2(`Max restarts (${this.maxRestarts}) reached, not restarting`);
           return;
         }
         this.restartCount++;
-        log(`Restarting tsserver (attempt ${this.restartCount})...`);
+        log2(`Restarting tsserver (attempt ${this.restartCount})...`);
         this.buffer = Buffer.alloc(0);
         const filesToReopen = [...this.openFiles];
         this.openFiles.clear();
@@ -538,7 +878,7 @@ var init_tsserver_client = __esm({
             const message = JSON.parse(bodyBytes.toString("utf-8"));
             this.onMessage(message);
           } catch {
-            log("Failed to parse tsserver message");
+            log2("Failed to parse tsserver message");
           }
         }
       }
@@ -551,449 +891,115 @@ var init_tsserver_client = __esm({
             if (message.success) {
               pending.resolve(message.body);
             } else {
-              pending.reject(
-                new Error(`tsserver ${pending.command} failed: ${message.message ?? "unknown error"}`)
-              );
-            }
-          }
-        }
-      }
-      // ─── Protocol: Sending ──────────────────────────────────────────────────
-      sendRequest(command2, args2) {
-        if (!this.child?.stdin?.writable) {
-          return Promise.reject(new Error("tsserver not running"));
-        }
-        const seq = ++this.seq;
-        const request = {
-          seq,
-          type: "request",
-          command: command2,
-          arguments: args2
-        };
-        return new Promise((resolve8, reject) => {
-          const timer = setTimeout(() => {
-            this.pending.delete(seq);
-            reject(new Error(`tsserver ${command2} timed out after ${REQUEST_TIMEOUT_MS}ms`));
-          }, REQUEST_TIMEOUT_MS);
-          this.pending.set(seq, { resolve: resolve8, reject, timer, command: command2 });
-          this.child.stdin.write(JSON.stringify(request) + "\n");
-        });
-      }
-      // Fire-and-forget — for commands like `open` that may not send a response
-      sendNotification(command2, args2) {
-        if (!this.child?.stdin?.writable) return;
-        const seq = ++this.seq;
-        const request = { seq, type: "request", command: command2, arguments: args2 };
-        this.child.stdin.write(JSON.stringify(request) + "\n");
-      }
-      // ─── File Management ───────────────────────────────────────────────────
-      async ensureOpen(file) {
-        const absPath2 = this.resolvePath(file);
-        if (this.openFiles.has(absPath2)) return;
-        this.openFiles.add(absPath2);
-        this.sendNotification("open", { file: absPath2 });
-        await new Promise((r) => setTimeout(r, 50));
-      }
-      // ─── Public API ────────────────────────────────────────────────────────
-      async definition(file, line, offset) {
-        const absPath2 = this.resolvePath(file);
-        await this.ensureOpen(absPath2);
-        const body = await this.sendRequest("definition", {
-          file: absPath2,
-          line,
-          offset
-        });
-        if (!body || !Array.isArray(body)) return [];
-        return body.map((d) => ({
-          ...d,
-          file: this.relativePath(d.file)
-        }));
-      }
-      async references(file, line, offset) {
-        const absPath2 = this.resolvePath(file);
-        await this.ensureOpen(absPath2);
-        const body = await this.sendRequest("references", {
-          file: absPath2,
-          line,
-          offset
-        });
-        if (!body?.refs) return [];
-        return body.refs.map((r) => ({
-          ...r,
-          file: this.relativePath(r.file)
-        }));
-      }
-      async quickinfo(file, line, offset) {
-        const absPath2 = this.resolvePath(file);
-        await this.ensureOpen(absPath2);
-        try {
-          const body = await this.sendRequest("quickinfo", {
-            file: absPath2,
-            line,
-            offset
-          });
-          return body ?? null;
-        } catch {
-          return null;
-        }
-      }
-      async navto(searchValue, maxResults = 10, file) {
-        if (file) await this.ensureOpen(file);
-        const args2 = {
-          searchValue,
-          maxResultCount: maxResults
-        };
-        if (file) args2["file"] = this.resolvePath(file);
-        const body = await this.sendRequest("navto", args2);
-        if (!body || !Array.isArray(body)) return [];
-        return body.map((item) => ({
-          ...item,
-          file: this.relativePath(item.file)
-        }));
-      }
-      async navbar(file) {
-        const absPath2 = this.resolvePath(file);
-        await this.ensureOpen(absPath2);
-        const body = await this.sendRequest("navbar", {
-          file: absPath2
-        });
-        return body ?? [];
-      }
-    };
-  }
-});
-
-// module-graph.ts
-import { parseSync } from "oxc-parser";
-import { ResolverFactory } from "oxc-resolver";
-import * as fs3 from "fs";
-import * as path4 from "path";
-function discoverFiles(rootDir) {
-  const files = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
-        if (entry.name.startsWith(".") && dir !== rootDir) continue;
-        walk(path4.join(dir, entry.name));
-      } else if (entry.isFile()) {
-        const name = entry.name;
-        if (SKIP_FILES.has(name)) continue;
-        if (name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts")) continue;
-        const ext = path4.extname(name);
-        if (TS_EXTENSIONS.has(ext)) {
-          files.push(path4.join(dir, name));
-        }
-      }
-    }
-  }
-  walk(rootDir);
-  return files;
-}
-function parseFileImports(filePath, source) {
-  const result = parseSync(filePath, source);
-  const imports = [];
-  for (const imp of result.module.staticImports) {
-    const specifier = imp.moduleRequest.value;
-    const names = [];
-    let allTypeOnly = true;
-    for (const entry of imp.entries) {
-      const kind = entry.importName.kind;
-      const name = kind === "Default" ? "default" : kind === "All" || kind === "AllButDefault" || kind === "NamespaceObject" ? "*" : entry.importName.name ?? entry.localName.value;
-      names.push(name);
-      if (!entry.isType) allTypeOnly = false;
-    }
-    if (names.length === 0) {
-      imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: false });
-    } else {
-      imports.push({ specifier, names, isTypeOnly: allTypeOnly, isDynamic: false });
-    }
-  }
-  for (const exp of result.module.staticExports) {
-    for (const entry of exp.entries) {
-      const moduleRequest = entry.moduleRequest;
-      if (!moduleRequest) continue;
-      const specifier = moduleRequest.value;
-      const entryKind = entry.importName.kind;
-      const name = entryKind === "AllButDefault" || entryKind === "All" || entryKind === "NamespaceObject" ? "*" : entry.importName.name ?? "*";
-      const existing = imports.find((i) => i.specifier === specifier && !i.isDynamic);
-      if (existing) {
-        if (!existing.names.includes(name)) existing.names.push(name);
-      } else {
-        imports.push({ specifier, names: [name], isTypeOnly: false, isDynamic: false });
-      }
-    }
-  }
-  for (const di of result.module.dynamicImports) {
-    if (di.moduleRequest) {
-      const sliced = source.slice(di.moduleRequest.start, di.moduleRequest.end);
-      if (sliced.startsWith("'") || sliced.startsWith('"')) {
-        const specifier = sliced.slice(1, -1);
-        imports.push({ specifier, names: ["*"], isTypeOnly: false, isDynamic: true });
-      }
-    }
-  }
-  return imports;
-}
-function distToSource(resolvedPath, projectRoot2) {
-  if (!resolvedPath.startsWith(projectRoot2)) return resolvedPath;
-  const rel2 = path4.relative(projectRoot2, resolvedPath);
-  const distIdx = rel2.indexOf("dist" + path4.sep);
-  if (distIdx === -1) return resolvedPath;
-  const prefix = rel2.slice(0, distIdx);
-  const afterDist = rel2.slice(distIdx + 5);
-  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
-  for (const ext of SOURCE_EXTS) {
-    const candidate = path4.resolve(projectRoot2, prefix, "src", withoutExt + ext);
-    if (fs3.existsSync(candidate)) return candidate;
-  }
-  for (const ext of SOURCE_EXTS) {
-    const candidate = path4.resolve(projectRoot2, prefix, withoutExt + ext);
-    if (fs3.existsSync(candidate)) return candidate;
-  }
-  if (withoutExt.endsWith("/index")) {
-    const dirPath = withoutExt.slice(0, -6);
-    for (const ext of SOURCE_EXTS) {
-      const candidate = path4.resolve(projectRoot2, prefix, "src", dirPath + ext);
-      if (fs3.existsSync(candidate)) return candidate;
-    }
-  }
-  return resolvedPath;
-}
-function resolveImport(resolver, fromDir, specifier, projectRoot2) {
-  try {
-    const result = resolver.sync(fromDir, specifier);
-    if (result.path && !result.path.includes("node_modules")) {
-      const mapped = distToSource(result.path, projectRoot2);
-      const ext = path4.extname(mapped);
-      if (!TS_EXTENSIONS.has(ext)) return null;
-      if (SKIP_FILES.has(path4.basename(mapped))) return null;
-      return mapped;
-    }
-  } catch {
-  }
-  return null;
-}
-function createResolver(projectRoot2, tsconfigPath2) {
-  return new ResolverFactory({
-    tsconfig: {
-      configFile: path4.resolve(projectRoot2, tsconfigPath2),
-      references: "auto"
-    },
-    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
-    extensionAlias: {
-      ".js": [".ts", ".tsx", ".js"],
-      ".jsx": [".tsx", ".jsx"],
-      ".mjs": [".mts", ".mjs"],
-      ".cjs": [".cts", ".cjs"]
-    },
-    conditionNames: ["import", "require"],
-    mainFields: ["module", "main"]
-  });
-}
-function buildForwardEdges(files, resolver, projectRoot2) {
-  const forward = /* @__PURE__ */ new Map();
-  const parseFailures = [];
-  for (const filePath of files) {
-    let source;
-    try {
-      source = fs3.readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    let rawImports;
-    try {
-      rawImports = parseFileImports(filePath, source);
-    } catch (err) {
-      parseFailures.push(filePath);
-      continue;
-    }
-    const edges = [];
-    const fromDir = path4.dirname(filePath);
-    for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
-      if (target) {
-        edges.push({
-          target,
-          specifiers: raw.names,
-          isTypeOnly: raw.isTypeOnly,
-          isDynamic: raw.isDynamic
+              pending.reject(
+                new Error(`tsserver ${pending.command} failed: ${message.message ?? "unknown error"}`)
+              );
+            }
+          }
+        }
+      }
+      // ─── Protocol: Sending ──────────────────────────────────────────────────
+      sendRequest(command2, args2) {
+        if (!this.child?.stdin?.writable) {
+          return Promise.reject(new Error("tsserver not running"));
+        }
+        const seq = ++this.seq;
+        const request = {
+          seq,
+          type: "request",
+          command: command2,
+          arguments: args2
+        };
+        return new Promise((resolve8, reject) => {
+          const timer = setTimeout(() => {
+            this.pending.delete(seq);
+            reject(new Error(`tsserver ${command2} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+          }, REQUEST_TIMEOUT_MS);
+          this.pending.set(seq, { resolve: resolve8, reject, timer, command: command2 });
+          this.child.stdin.write(JSON.stringify(request) + "\n");
         });
       }
-    }
-    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);
+      // Fire-and-forget — for commands like `open` that may not send a response
+      sendNotification(command2, args2) {
+        if (!this.child?.stdin?.writable) return;
+        const seq = ++this.seq;
+        const request = { seq, type: "request", command: command2, arguments: args2 };
+        this.child.stdin.write(JSON.stringify(request) + "\n");
       }
-      revEdges.push({
-        target: source,
-        // reverse: the "target" is the file that imports
-        specifiers: edge.specifiers,
-        isTypeOnly: edge.isTypeOnly,
-        isDynamic: edge.isDynamic
-      });
-    }
-  }
-  return reverse;
-}
-async function buildGraph(projectRoot2, tsconfigPath2) {
-  const startTime = performance.now();
-  const resolver = createResolver(projectRoot2, tsconfigPath2);
-  const fileList = discoverFiles(projectRoot2);
-  log2(`Discovered ${fileList.length} source files`);
-  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot2);
-  const reverse = buildReverseMap(forward);
-  const files = new Set(fileList);
-  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
-  const elapsed = (performance.now() - startTime).toFixed(0);
-  log2(`Graph built: ${files.size} files, ${edgeCount} edges [${elapsed}ms]`);
-  if (parseFailures.length > 0) {
-    log2(`Parse failures: ${parseFailures.length} files`);
-  }
-  return {
-    graph: { forward, reverse, files },
-    resolver
-  };
-}
-function updateFile(graph, filePath, resolver, projectRoot2) {
-  const oldEdges = graph.forward.get(filePath) ?? [];
-  for (const edge of oldEdges) {
-    const revEdges = graph.reverse.get(edge.target);
-    if (revEdges) {
-      const idx = revEdges.findIndex((r) => r.target === filePath);
-      if (idx !== -1) revEdges.splice(idx, 1);
-      if (revEdges.length === 0) graph.reverse.delete(edge.target);
-    }
-  }
-  let source;
-  try {
-    source = fs3.readFileSync(filePath, "utf-8");
-  } catch {
-    removeFile(graph, filePath);
-    return;
-  }
-  let rawImports;
-  try {
-    rawImports = parseFileImports(filePath, source);
-  } catch {
-    log2(`Parse error on update: ${filePath}`);
-    graph.forward.set(filePath, []);
-    return;
-  }
-  const fromDir = path4.dirname(filePath);
-  const newEdges = [];
-  for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
-    if (target) {
-      newEdges.push({
-        target,
-        specifiers: raw.names,
-        isTypeOnly: raw.isTypeOnly,
-        isDynamic: raw.isDynamic
-      });
-    }
-  }
-  graph.forward.set(filePath, newEdges);
-  graph.files.add(filePath);
-  for (const edge of newEdges) {
-    let revEdges = graph.reverse.get(edge.target);
-    if (!revEdges) {
-      revEdges = [];
-      graph.reverse.set(edge.target, revEdges);
-    }
-    revEdges.push({
-      target: filePath,
-      specifiers: edge.specifiers,
-      isTypeOnly: edge.isTypeOnly,
-      isDynamic: edge.isDynamic
-    });
-  }
-}
-function removeFile(graph, filePath) {
-  const edges = graph.forward.get(filePath) ?? [];
-  for (const edge of edges) {
-    const revEdges2 = graph.reverse.get(edge.target);
-    if (revEdges2) {
-      const idx = revEdges2.findIndex((r) => r.target === filePath);
-      if (idx !== -1) revEdges2.splice(idx, 1);
-      if (revEdges2.length === 0) graph.reverse.delete(edge.target);
-    }
-  }
-  const revEdges = graph.reverse.get(filePath) ?? [];
-  for (const revEdge of revEdges) {
-    const fwdEdges = graph.forward.get(revEdge.target);
-    if (fwdEdges) {
-      const idx = fwdEdges.findIndex((e) => e.target === filePath);
-      if (idx !== -1) fwdEdges.splice(idx, 1);
-    }
-  }
-  graph.forward.delete(filePath);
-  graph.reverse.delete(filePath);
-  graph.files.delete(filePath);
-}
-function startWatcher(projectRoot2, graph, resolver) {
-  try {
-    const watcher = fs3.watch(
-      projectRoot2,
-      { recursive: true },
-      (_eventType, filename) => {
-        if (!filename) return;
-        const ext = path4.extname(filename);
-        if (!TS_EXTENSIONS.has(ext)) return;
-        const parts = filename.split(path4.sep);
-        if (parts.some((p2) => SKIP_DIRS.has(p2))) return;
-        if (SKIP_FILES.has(path4.basename(filename))) return;
-        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
-          return;
-        const absPath2 = path4.resolve(projectRoot2, filename);
-        if (fs3.existsSync(absPath2)) {
-          updateFile(graph, absPath2, resolver, projectRoot2);
-        } else {
-          removeFile(graph, absPath2);
+      // ─── File Management ───────────────────────────────────────────────────
+      async ensureOpen(file) {
+        const absPath2 = this.resolvePath(file);
+        if (this.openFiles.has(absPath2)) return;
+        this.openFiles.add(absPath2);
+        this.sendNotification("open", { file: absPath2 });
+        await new Promise((r) => setTimeout(r, 50));
+      }
+      // ─── Public API ────────────────────────────────────────────────────────
+      async definition(file, line, offset) {
+        const absPath2 = this.resolvePath(file);
+        await this.ensureOpen(absPath2);
+        const body = await this.sendRequest("definition", {
+          file: absPath2,
+          line,
+          offset
+        });
+        if (!body || !Array.isArray(body)) return [];
+        return body.map((d) => ({
+          ...d,
+          file: this.relativePath(d.file)
+        }));
+      }
+      async references(file, line, offset) {
+        const absPath2 = this.resolvePath(file);
+        await this.ensureOpen(absPath2);
+        const body = await this.sendRequest("references", {
+          file: absPath2,
+          line,
+          offset
+        });
+        if (!body?.refs) return [];
+        return body.refs.map((r) => ({
+          ...r,
+          file: this.relativePath(r.file)
+        }));
+      }
+      async quickinfo(file, line, offset) {
+        const absPath2 = this.resolvePath(file);
+        await this.ensureOpen(absPath2);
+        try {
+          const body = await this.sendRequest("quickinfo", {
+            file: absPath2,
+            line,
+            offset
+          });
+          return body ?? null;
+        } catch {
+          return null;
         }
       }
-    );
-    process.on("SIGINT", () => watcher.close());
-    process.on("SIGTERM", () => watcher.close());
-    log2("File watcher started");
-  } catch (err) {
-    log2("Failed to start file watcher:", err);
-  }
-}
-var log2, TS_EXTENSIONS, SKIP_DIRS, SKIP_FILES, SOURCE_EXTS;
-var init_module_graph = __esm({
-  "module-graph.ts"() {
-    log2 = (...args2) => console.error("[typegraph/graph]", ...args2);
-    TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
-    SKIP_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      "dist",
-      "build",
-      "out",
-      ".wrangler",
-      ".mf",
-      ".git",
-      ".next",
-      ".turbo",
-      "coverage"
-    ]);
-    SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
-    SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts"];
+      async navto(searchValue, maxResults = 10, file) {
+        if (file) await this.ensureOpen(file);
+        const args2 = {
+          searchValue,
+          maxResultCount: maxResults
+        };
+        if (file) args2["file"] = this.resolvePath(file);
+        const body = await this.sendRequest("navto", args2);
+        if (!body || !Array.isArray(body)) return [];
+        return body.map((item) => ({
+          ...item,
+          file: this.relativePath(item.file)
+        }));
+      }
+      async navbar(file) {
+        const absPath2 = this.resolvePath(file);
+        await this.ensureOpen(absPath2);
+        const body = await this.sendRequest("navbar", {
+          file: absPath2
+        });
+        return body ?? [];
+      }
+    };
   }
 });
 
@@ -1633,7 +1639,7 @@ async function main2(configOverride) {
   console.log("");
   return { passed, failed, skipped };
 }
-var SKIP_DIRS2, isDirectRun2;
+var SKIP_DIRS2;
 var init_smoke_test = __esm({
   "smoke-test.ts"() {
     init_tsserver_client();
@@ -1649,13 +1655,6 @@ var init_smoke_test = __esm({
       "coverage",
       "out"
     ]);
-    isDirectRun2 = process.argv[1] && fs5.realpathSync(process.argv[1]) === fs5.realpathSync(new URL(import.meta.url).pathname);
-    if (isDirectRun2) {
-      main2().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
-        console.error("Fatal:", err);
-        process.exit(1);
-      });
-    }
   }
 });
 
@@ -2782,14 +2781,21 @@ async function remove(yes2) {
   }
   await removePlugin(projectRoot2, pluginDir);
 }
+function resolvePluginDir() {
+  const installed = path8.resolve(process.cwd(), PLUGIN_DIR_NAME);
+  if (fs7.existsSync(installed)) return installed;
+  return path8.basename(import.meta.dirname) === "dist" ? path8.resolve(import.meta.dirname, "..") : import.meta.dirname;
+}
 async function check() {
+  const config = resolveConfig(resolvePluginDir());
   const { main: checkMain } = await Promise.resolve().then(() => (init_check(), check_exports));
-  const result = await checkMain();
+  const result = await checkMain(config);
   process.exit(result.failed > 0 ? 1 : 0);
 }
 async function test() {
+  const config = resolveConfig(resolvePluginDir());
   const { main: testMain } = await Promise.resolve().then(() => (init_smoke_test(), smoke_test_exports));
-  const result = await testMain();
+  const result = await testMain(config);
   process.exit(result.failed > 0 ? 1 : 0);
 }
 async function start() {