typegraph-mcp 0.9.46 → 0.9.48

package/dist/cli.js

@@ -9,1232 +9,1326 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// biome-config.ts
+function filesObjectMatch(raw) {
+  return raw.match(/(["']files["']\s*:\s*\{)([\s\S]*?)(\n?\s*\})/);
+}
+function filesIncludes(raw) {
+  const filesObject = filesObjectMatch(raw);
+  if (!filesObject) return null;
+  const includes = filesObject[2].match(/["']includes["']\s*:\s*\[([\s\S]*?)\]/);
+  if (!includes) return null;
+  return [...includes[1].matchAll(/["']([^"']+)["']/g)].map((match) => match[1]);
+}
+function biomeScopeExcludes(raw, parentDir) {
+  const escaped = parentDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const explicitIgnore = new RegExp(
+    `["']!{1,2}(?:\\*\\*/)?${escaped}(?:/\\*\\*)?["']`
+  );
+  if (explicitIgnore.test(raw)) return true;
+  const includes = filesIncludes(raw);
+  if (!includes) return false;
+  const positivePatterns = includes.filter((pattern) => !pattern.startsWith("!"));
+  return !positivePatterns.some((pattern) => {
+    const normalized = pattern.replace(/^\.\//, "");
+    return normalized === "*" || normalized === "**" || normalized.startsWith("**/") || normalized.startsWith("*/") || normalized === parentDir || normalized.startsWith(`${parentDir}/`);
+  });
+}
+function appendToIncludes(body, forceIgnore) {
+  const pattern = /(["']includes["']\s*:\s*\[)([\s\S]*?)(\])/;
+  if (!pattern.test(body)) return null;
+  return body.replace(pattern, (_match, open, items, close) => {
+    const trimmed = items.trimEnd();
+    const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
+    return `${open}${trimmed}${needsComma ? "," : ""} ${forceIgnore}${close}`;
+  });
+}
+function patchBiomeConfig(raw, parentDir) {
+  const forceIgnore = `"!!${parentDir}"`;
+  const filesObjectRe = /(["']files["']\s*:\s*\{)([\s\S]*?)(\n?\s*\})/;
+  const filesObject = filesObjectMatch(raw);
+  if (filesObject) {
+    const updatedBody = appendToIncludes(filesObject[2], forceIgnore);
+    if (updatedBody) {
+      return raw.replace(filesObjectRe, `${filesObject[1]}${updatedBody}${filesObject[3]}`);
+    }
+    const body = filesObject[2].trimEnd();
+    const needsComma2 = body.trim().length > 0 && !body.trimEnd().endsWith(",");
+    const updatedFiles = `${filesObject[1]}${body}${needsComma2 ? "," : ""}
+    "includes": ["**", ${forceIgnore}]${filesObject[3]}`;
+    return raw.replace(filesObjectRe, updatedFiles);
+  }
+  const lastBrace = raw.lastIndexOf("}");
+  if (lastBrace === -1) return null;
+  const before = raw.slice(0, lastBrace).trimEnd();
+  const needsComma = !before.endsWith(",") && !before.endsWith("{");
+  return `${before}${needsComma ? "," : ""}
+  "files": { "includes": ["**", ${forceIgnore}] }
+}
+`;
+}
+var BIOME_CONFIG_NAMES;
+var init_biome_config = __esm({
+  "biome-config.ts"() {
+    BIOME_CONFIG_NAMES = [
+      "biome.json",
+      "biome.jsonc",
+      ".biome.json",
+      ".biome.jsonc"
+    ];
+  }
+});
+
 // config.ts
 import * as path from "path";
-function resolveConfig(toolDir) {
+function resolveConfig(toolDir2) {
   const cwd = process.cwd();
-  const projectRoot3 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir)) === "plugins" ? path.resolve(toolDir, "../..") : cwd;
+  const projectRoot3 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir2)) === "plugins" ? path.resolve(toolDir2, "../..") : cwd;
   const tsconfigPath3 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
-  const toolIsEmbedded = toolDir.startsWith(projectRoot3 + path.sep);
-  const toolRelPath = toolIsEmbedded ? path.relative(projectRoot3, toolDir) : toolDir;
-  return { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir, toolIsEmbedded, toolRelPath };
+  const toolIsEmbedded2 = toolDir2.startsWith(projectRoot3 + path.sep);
+  const toolRelPath = toolIsEmbedded2 ? path.relative(projectRoot3, toolDir2) : toolDir2;
+  return { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir: toolDir2, toolIsEmbedded: toolIsEmbedded2, toolRelPath };
 }
 var init_config = __esm({
   "config.ts"() {
   }
 });
 
-// module-graph.ts
-var module_graph_exports = {};
-__export(module_graph_exports, {
-  buildGraph: () => buildGraph,
-  createResolver: () => createResolver,
-  discoverFiles: () => discoverFiles,
-  removeFile: () => removeFile,
-  resolveProjectImport: () => resolveProjectImport,
-  startWatcher: () => startWatcher,
-  updateFile: () => updateFile
-});
-import { parseSync } from "oxc-parser";
-import { ResolverFactory } from "oxc-resolver";
-import * as fs from "fs";
+// tsserver-client.ts
+import { spawn } from "child_process";
 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, projectRoot3) {
-  if (!resolvedPath.startsWith(projectRoot3)) return resolvedPath;
-  const rel2 = path2.relative(projectRoot3, resolvedPath);
-  const distIdx = rel2.indexOf("dist" + path2.sep);
-  if (distIdx === -1) return resolvedPath;
-  const prefix = rel2.slice(0, distIdx);
-  const afterDist = rel2.slice(distIdx + 5);
-  const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
-  for (const ext of SOURCE_EXTS) {
-    const candidate = path2.resolve(projectRoot3, prefix, "src", withoutExt + ext);
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  for (const ext of SOURCE_EXTS) {
-    const candidate = path2.resolve(projectRoot3, prefix, withoutExt + ext);
-    if (fs.existsSync(candidate)) return candidate;
-  }
-  if (withoutExt.endsWith("/index")) {
-    const dirPath = withoutExt.slice(0, -6);
-    for (const ext of SOURCE_EXTS) {
-      const candidate = path2.resolve(projectRoot3, prefix, "src", dirPath + ext);
-      if (fs.existsSync(candidate)) return candidate;
-    }
-  }
-  return resolvedPath;
+import * as fs from "fs";
+import { createRequire } from "module";
+function readPackageVersion(packagePath) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return pkg.version ?? "unknown";
 }
-function resolveProjectImport(resolver, fromDir, specifier, projectRoot3) {
+function resolveTsServer(projectRoot3) {
+  const projectRequire = createRequire(path2.resolve(projectRoot3, "package.json"));
+  let projectVersion;
   try {
-    const result = resolver.sync(fromDir, specifier);
-    if (result.path && !result.path.includes("node_modules")) {
-      const mapped = distToSource(result.path, projectRoot3);
-      const ext = path2.extname(mapped);
-      if (!TS_EXTENSIONS.has(ext)) return null;
-      if (SKIP_FILES.has(path2.basename(mapped))) return null;
-      return mapped;
-    }
+    const packagePath2 = projectRequire.resolve("typescript/package.json");
+    projectVersion = readPackageVersion(packagePath2);
+    const serverPath2 = projectRequire.resolve("typescript/lib/tsserver.js");
+    return { path: serverPath2, version: projectVersion, source: "project" };
   } catch {
   }
-  return null;
-}
-function createResolver(projectRoot3, tsconfigPath3) {
-  return new ResolverFactory({
-    tsconfig: {
-      configFile: path2.resolve(projectRoot3, tsconfigPath3),
-      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"]
-  });
+  const toolRequire = createRequire(import.meta.url);
+  const packagePath = toolRequire.resolve("typescript/package.json");
+  const serverPath = toolRequire.resolve("typescript/lib/tsserver.js");
+  return {
+    path: serverPath,
+    version: readPackageVersion(packagePath),
+    source: "typegraph",
+    projectVersion
+  };
 }
-function buildForwardEdges(files, resolver, projectRoot3) {
-  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 = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
-      if (target) {
-        edges.push({
-          target,
-          specifiers: raw.names,
-          isTypeOnly: raw.isTypeOnly,
-          isDynamic: raw.isDynamic
+var log, REQUEST_TIMEOUT_MS, TsServerClient;
+var init_tsserver_client = __esm({
+  "tsserver-client.ts"() {
+    log = (...args2) => console.error("[typegraph/tsserver]", ...args2);
+    REQUEST_TIMEOUT_MS = 1e4;
+    TsServerClient = class {
+      constructor(projectRoot3, tsconfigPath3 = "./tsconfig.json") {
+        this.projectRoot = projectRoot3;
+        this.tsconfigPath = tsconfigPath3;
+      }
+      child = null;
+      seq = 0;
+      pending = /* @__PURE__ */ new Map();
+      openFiles = /* @__PURE__ */ new Set();
+      buffer = Buffer.alloc(0);
+      ready = false;
+      shuttingDown = false;
+      restartCount = 0;
+      maxRestarts = 3;
+      projectsDirty = false;
+      // ─── Path Resolution ────────────────────────────────────────────────────
+      resolvePath(file) {
+        return path2.isAbsolute(file) ? file : path2.resolve(this.projectRoot, file);
+      }
+      relativePath(file) {
+        return path2.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 = fs.readFileSync(absPath2, "utf-8");
+          const lines = content.split("\n");
+          return lines[line - 1]?.trim() ?? "";
+        } catch {
+          return "";
+        }
+      }
+      // ─── Lifecycle ──────────────────────────────────────────────────────────
+      async start() {
+        if (this.child) return;
+        const resolution = resolveTsServer(this.projectRoot);
+        const tsserverPath = resolution.path;
+        const fallbackNote = resolution.projectVersion ? `; project TypeScript ${resolution.projectVersion} has no legacy tsserver` : "";
+        log(
+          `Spawning tsserver: ${tsserverPath} (TypeScript ${resolution.version}, ${resolution.source}${fallbackNote})`
+        );
+        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();
+        await this.sendRequest("compilerOptionsForInferredProjects", {
+          options: { allowJs: true, checkJs: false }
         });
+        this.ready = true;
+        log(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
       }
-    }
-    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);
+      shutdown() {
+        this.shuttingDown = true;
+        if (this.child) {
+          this.child.kill("SIGTERM");
+          this.child = null;
+        }
+        this.rejectAllPending(new Error("Client shutdown"));
       }
-      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(projectRoot3, tsconfigPath3) {
-  const startTime = performance.now();
-  const resolver = createResolver(projectRoot3, tsconfigPath3);
-  const fileList = discoverFiles(projectRoot3);
-  log(`Discovered ${fileList.length} source files`);
-  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot3);
-  const reverse = buildReverseMap(forward);
-  const files = new Set(fileList);
-  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
-  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, projectRoot3) {
-  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 = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
-    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(projectRoot3, graph, resolver, hooks) {
-  try {
-    const watcher = fs.watch(
-      projectRoot3,
-      { 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"))
+      tryRestart() {
+        if (this.shuttingDown) return;
+        if (this.restartCount >= this.maxRestarts) {
+          log(`Max restarts (${this.maxRestarts}) reached, not restarting`);
           return;
-        const absPath2 = path2.resolve(projectRoot3, filename);
-        if (fs.existsSync(absPath2)) {
-          updateFile(graph, absPath2, resolver, projectRoot3);
-          void hooks?.onFileUpdated?.(absPath2);
-        } else {
-          removeFile(graph, absPath2);
-          void hooks?.onFileDeleted?.(absPath2);
         }
+        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(() => {
+            });
+          }
+        });
       }
-    );
-    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 fs2 from "fs";
-import * as path3 from "path";
-import { createRequire } from "module";
-import { spawn, spawnSync } from "child_process";
-function findFirstTsFile(dir) {
-  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
-  try {
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
-        return path3.join(dir, entry.name);
+      rejectAllPending(err) {
+        for (const [seq, pending] of this.pending) {
+          clearTimeout(pending.timer);
+          pending.reject(err);
+        }
+        this.pending.clear();
       }
-    }
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
-        const found = findFirstTsFile(path3.join(dir, entry.name));
-        if (found) return found;
+      // ─── Protocol: Parsing ──────────────────────────────────────────────────
+      onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.processBuffer();
       }
-    }
-  } catch {
-  }
-  return null;
-}
-function testTsserver(projectRoot3) {
-  return new Promise((resolve9) => {
-    let tsserverPath;
-    try {
-      const require2 = createRequire(path3.resolve(projectRoot3, "package.json"));
-      tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    } catch {
-      resolve9(false);
-      return;
-    }
-    const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
-      cwd: projectRoot3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const timeout = setTimeout(() => {
-      child.kill();
-      resolve9(false);
-    }, 1e4);
-    let buffer = "";
-    child.stdout.on("data", (chunk) => {
-      buffer += chunk.toString();
-      if (buffer.includes('"success":true')) {
-        clearTimeout(timeout);
-        child.kill();
-        resolve9(true);
+      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");
+          }
+        }
       }
-    });
-    child.on("error", () => {
-      clearTimeout(timeout);
-      resolve9(false);
-    });
-    child.on("exit", () => {
-      clearTimeout(timeout);
-    });
-    const request = JSON.stringify({
-      seq: 1,
-      type: "request",
-      command: "configure",
-      arguments: {
-        preferences: { disableSuggestions: true }
+      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"}`)
+              );
+            }
+          }
+        }
       }
-    });
-    child.stdin.write(request + "\n");
-  });
-}
-function readProjectCodexConfig(projectRoot3) {
-  const configPath = path3.resolve(projectRoot3, ".codex/config.toml");
-  if (!fs2.existsSync(configPath)) return null;
-  return fs2.readFileSync(configPath, "utf-8");
-}
-function hasCodexTypegraphRegistration(content) {
-  return /\[mcp_servers\.typegraph\]/.test(content);
-}
-function hasCodexTsxLauncher(content) {
-  return /command\s*=\s*"[^"]*tsx(?:\.cmd)?"/.test(content) || /args\s*=\s*\[[\s\S]*"tsx"/.test(content);
-}
-function hasCompleteCodexTypegraphRegistration(content) {
-  return hasCodexTypegraphRegistration(content) && /command\s*=\s*"[^"]+"/.test(content) && /args\s*=\s*\[[\s\S]*\]/.test(content) && hasCodexTsxLauncher(content) && /TYPEGRAPH_PROJECT_ROOT\s*=/.test(content) && /TYPEGRAPH_TSCONFIG\s*=/.test(content);
-}
-function hasTrustedCodexProject(projectRoot3) {
-  const home = process.env.HOME;
-  if (!home) return null;
-  const globalConfigPath = path3.join(home, ".codex/config.toml");
-  if (!fs2.existsSync(globalConfigPath)) return null;
-  const lines = fs2.readFileSync(globalConfigPath, "utf-8").split(/\r?\n/);
-  let currentProject = null;
-  let currentTrusted = false;
-  const matchesTrustedProject = () => currentProject !== null && currentTrusted && (projectRoot3 === currentProject || projectRoot3.startsWith(currentProject + path3.sep));
-  for (const line of lines) {
-    const sectionMatch = line.match(/^\[projects\."([^"]+)"\]\s*$/);
-    if (sectionMatch) {
-      if (matchesTrustedProject()) return true;
-      currentProject = path3.resolve(sectionMatch[1]);
-      currentTrusted = false;
-      continue;
-    }
-    if (line.startsWith("[")) {
-      if (matchesTrustedProject()) return true;
-      currentProject = null;
-      currentTrusted = false;
-      continue;
-    }
-    if (currentProject && /\btrust_level\s*=\s*"trusted"/.test(line)) {
-      currentTrusted = true;
-    }
-  }
-  return matchesTrustedProject();
-}
-function hasCompleteJsonTypegraphRegistration(config, serverName, projectRoot3) {
-  if (typeof config !== "object" || config === null) return false;
-  const servers = config["mcpServers"];
-  if (typeof servers !== "object" || servers === null) return false;
-  const entry = servers[serverName];
-  if (typeof entry !== "object" || entry === null) return false;
-  const record = entry;
-  const command2 = record["command"];
-  const args2 = record["args"];
-  const env = record["env"];
-  const serializedArgs = JSON.stringify(args2 ?? []);
-  return typeof command2 === "string" && command2.length > 0 && Array.isArray(args2) && serializedArgs.includes("server.ts") && serializedArgs.includes("tsx") && typeof env === "object" && env !== null && env["TYPEGRAPH_PROJECT_ROOT"] === projectRoot3 && typeof env["TYPEGRAPH_TSCONFIG"] === "string";
-}
-function readJsonConfig(configPath) {
-  if (!fs2.existsSync(configPath)) return null;
-  try {
-    return JSON.parse(fs2.readFileSync(configPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getAntigravityMcpConfigPaths() {
-  const home = process.env.HOME || "";
-  return [
-    path3.join(home, ".gemini/antigravity/mcp_config.json"),
-    path3.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json")
-  ];
-}
-function findAntigravityRegistration(projectRoot3) {
-  const home = process.env.HOME || "";
-  for (const configPath of getAntigravityMcpConfigPaths()) {
-    const config = readJsonConfig(configPath);
-    if (hasCompleteJsonTypegraphRegistration(config, "typegraph-mcp", projectRoot3)) {
-      return configPath.replace(home, "~");
-    }
-  }
-  return null;
-}
-function readProjectPackageJson(projectRoot3) {
-  const packageJsonPath = path3.resolve(projectRoot3, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) return null;
-  try {
-    return JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getProjectInstallCommand(projectRoot3, packageJson) {
-  const packageManager = typeof packageJson?.["packageManager"] === "string" ? packageJson["packageManager"] : "";
-  if (packageManager.startsWith("pnpm@") || fs2.existsSync(path3.join(projectRoot3, "pnpm-lock.yaml"))) {
-    return "pnpm install";
-  }
-  if (packageManager.startsWith("yarn@") || fs2.existsSync(path3.join(projectRoot3, "yarn.lock"))) {
-    return "yarn install";
+      // ─── 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((resolve10, 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: resolve10, 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));
+      }
+      /**
+       * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+       * in tsserver). tsserver's own disk watching silently decays in long-lived
+       * instances at monorepo scale, leaving closed-file contents frozen at project
+       * load time and new files unassigned (they land in single-file inferred
+       * projects, producing definition-only reference results). The next query
+       * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+       * from disk. Open files are unaffected by design — their content is
+       * protocol-owned and refreshed via reloadOpenFile().
+       */
+      markProjectsDirty() {
+        this.projectsDirty = true;
+      }
+      refreshIfDirty() {
+        if (!this.projectsDirty) return;
+        this.projectsDirty = false;
+        this.sendNotification("reloadProjects");
+      }
+      async reloadOpenFile(file) {
+        const absPath2 = this.resolvePath(file);
+        if (!this.openFiles.has(absPath2)) return false;
+        await this.sendRequest("reload", {
+          file: absPath2,
+          tmpfile: absPath2
+        });
+        return true;
+      }
+      closeFile(file) {
+        const absPath2 = this.resolvePath(file);
+        if (!this.openFiles.delete(absPath2)) return false;
+        this.sendNotification("close", { file: absPath2 });
+        return true;
+      }
+      // ─── Public API ────────────────────────────────────────────────────────
+      async definition(file, line, offset) {
+        this.refreshIfDirty();
+        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) {
+        this.refreshIfDirty();
+        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) {
+        this.refreshIfDirty();
+        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) {
+        this.refreshIfDirty();
+        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) {
+        this.refreshIfDirty();
+        const absPath2 = this.resolvePath(file);
+        await this.ensureOpen(absPath2);
+        const body = await this.sendRequest("navbar", {
+          file: absPath2
+        });
+        return body ?? [];
+      }
+    };
   }
-  return "npm install";
+});
+
+// module-graph.ts
+var module_graph_exports = {};
+__export(module_graph_exports, {
+  buildGraph: () => buildGraph,
+  createResolver: () => createResolver,
+  discoverFiles: () => discoverFiles,
+  removeFile: () => removeFile,
+  resolveProjectImport: () => resolveProjectImport,
+  startWatcher: () => startWatcher,
+  updateFile: () => updateFile
+});
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
+import * as fs2 from "fs";
+import * as path3 from "path";
+function normalizeExcludedPaths(rootDir, excludedPaths2) {
+  return excludedPaths2.map(
+    (excludedPath) => path3.resolve(rootDir, excludedPath)
+  );
 }
-function hasDeclaredDependency(packageJson, packageName) {
-  const depKeys = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies"
-  ];
-  return depKeys.some((key) => {
-    const deps = packageJson?.[key];
-    return typeof deps === "object" && deps !== null && packageName in deps;
-  });
+function isExcluded(filePath, excludedPaths2) {
+  return excludedPaths2.some(
+    (excludedPath) => filePath === excludedPath || filePath.startsWith(excludedPath + path3.sep)
+  );
 }
-function findLintConfigs(projectRoot3) {
-  const configs = [];
-  for (const fileName of ESLINT_CONFIG_NAMES) {
-    const fullPath = path3.resolve(projectRoot3, fileName);
-    if (fs2.existsSync(fullPath)) {
-      configs.push({ tool: "ESLint", fileName, fullPath, propertyName: "ignores" });
+function discoverFiles(rootDir, excludedPaths2 = []) {
+  const files = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths2);
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
     }
-  }
-  for (const fileName of OXLINT_CONFIG_NAMES) {
-    const fullPath = path3.resolve(projectRoot3, fileName);
-    if (fs2.existsSync(fullPath)) {
-      configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && dir !== rootDir) continue;
+        const childDir = path3.join(dir, entry.name);
+        if (isExcluded(childDir, normalizedExclusions)) continue;
+        walk(childDir);
+      } 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 = path3.extname(name);
+        if (TS_EXTENSIONS.has(ext)) {
+          files.push(path3.join(dir, name));
+        }
+      }
     }
   }
-  return configs;
+  walk(rootDir);
+  return files;
 }
-async function main(configOverride) {
-  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
-  let passed = 0;
-  let failed = 0;
-  let warned = 0;
-  const projectPackageJson = readProjectPackageJson(projectRoot3);
-  const installCommand = getProjectInstallCommand(projectRoot3, projectPackageJson);
-  function pass(msg) {
-    console.log(`  \u2713 ${msg}`);
-    passed++;
+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 });
+    }
   }
-  function fail(msg, fix) {
-    console.log(`  \u2717 ${msg}`);
-    console.log(`    Fix: ${fix}`);
-    failed++;
+  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 });
+      }
+    }
   }
-  function warn(msg, note) {
-    console.log(`  ! ${msg}`);
-    console.log(`    ${note}`);
-    warned++;
+  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 });
+      }
+    }
   }
-  function skip(msg) {
-    console.log(`  - ${msg} (skipped)`);
+  return imports;
+}
+function distToSource(resolvedPath, projectRoot3) {
+  if (!resolvedPath.startsWith(projectRoot3)) return resolvedPath;
+  const rel2 = path3.relative(projectRoot3, resolvedPath);
+  const distIdx = rel2.indexOf("dist" + path3.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 = path3.resolve(projectRoot3, prefix, "src", withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
   }
-  console.log("");
-  console.log("typegraph-mcp Health Check");
-  console.log("=======================");
-  console.log(`Project root: ${projectRoot3}`);
-  console.log("");
-  const nodeVersion = process.version;
-  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
-  if (nodeMajor >= 22) {
-    pass(`Node.js ${nodeVersion} (>= 22 required)`);
-  } else {
-    fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 22");
+  for (const ext of SOURCE_EXTS) {
+    const candidate = path3.resolve(projectRoot3, prefix, withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
   }
-  const tsxInRoot = fs2.existsSync(path3.join(projectRoot3, "node_modules/.bin/tsx"));
-  const tsxInTool = fs2.existsSync(path3.join(toolDir, "node_modules/.bin/tsx"));
-  if (tsxInRoot || tsxInTool) {
-    pass(`tsx available (in ${tsxInRoot ? "project" : "tool"} node_modules)`);
-  } else {
-    pass("tsx available (via npx/global)");
+  if (withoutExt.endsWith("/index")) {
+    const dirPath = withoutExt.slice(0, -6);
+    for (const ext of SOURCE_EXTS) {
+      const candidate = path3.resolve(projectRoot3, prefix, "src", dirPath + ext);
+      if (fs2.existsSync(candidate)) return candidate;
+    }
   }
-  let tsVersion = null;
+  return resolvedPath;
+}
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot3) {
   try {
-    const require2 = createRequire(path3.resolve(projectRoot3, "package.json"));
-    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    const tsPkgPath = path3.resolve(path3.dirname(tsserverPath), "..", "package.json");
-    const tsPkg = JSON.parse(fs2.readFileSync(tsPkgPath, "utf-8"));
-    tsVersion = tsPkg.version;
-    pass(`TypeScript found (v${tsVersion})`);
+    const result = resolver.sync(fromDir, specifier);
+    if (result.path && !result.path.includes("node_modules")) {
+      const mapped = distToSource(result.path, projectRoot3);
+      const ext = path3.extname(mapped);
+      if (!TS_EXTENSIONS.has(ext)) return null;
+      if (SKIP_FILES.has(path3.basename(mapped))) return null;
+      return mapped;
+    }
   } catch {
-    const hasDeclaredTs = hasDeclaredDependency(projectPackageJson, "typescript");
-    fail(
-      hasDeclaredTs ? "TypeScript is declared but not installed in project" : "TypeScript not found in project",
-      hasDeclaredTs ? `Run \`${installCommand}\` to install project dependencies` : `Add \`typescript\` to devDependencies and run \`${installCommand}\``
-    );
-  }
-  const tsconfigAbs = path3.resolve(projectRoot3, tsconfigPath3);
-  if (fs2.existsSync(tsconfigAbs)) {
-    pass(`tsconfig.json exists at ${tsconfigPath3}`);
-  } else {
-    fail(`tsconfig.json not found at ${tsconfigPath3}`, `Create a tsconfig.json at ${tsconfigPath3}`);
   }
-  const pluginMcpPath = path3.join(toolDir, ".mcp.json");
-  const hasPluginMcp = fs2.existsSync(pluginMcpPath) && fs2.existsSync(path3.join(toolDir, ".claude-plugin/plugin.json"));
-  const projectCodexConfig = readProjectCodexConfig(projectRoot3);
-  const hasProjectCodexRegistration = projectCodexConfig !== null && hasCompleteCodexTypegraphRegistration(projectCodexConfig);
-  const codexGet = spawnSync("codex", ["mcp", "get", "typegraph"], {
-    stdio: "pipe",
-    encoding: "utf-8"
+  return null;
+}
+function createResolver(projectRoot3, tsconfigPath3) {
+  const configFile = path3.resolve(projectRoot3, tsconfigPath3);
+  return new ResolverFactory({
+    ...fs2.existsSync(configFile) ? { tsconfig: { configFile, 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"]
   });
-  const hasGlobalCodexRegistration = codexGet.status === 0;
-  const antigravityRegistrationPath = findAntigravityRegistration(projectRoot3);
-  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 if (projectCodexConfig !== null) {
-    const codexConfigPath = path3.resolve(projectRoot3, ".codex/config.toml");
-    const hasSection = hasCodexTypegraphRegistration(projectCodexConfig);
-    const hasCommand = /command\s*=\s*"[^"]+"/.test(projectCodexConfig);
-    const hasArgs = /args\s*=\s*\[[\s\S]*\]/.test(projectCodexConfig);
-    const hasTsxLauncher = hasCodexTsxLauncher(projectCodexConfig);
-    const hasEnvRoot = /TYPEGRAPH_PROJECT_ROOT\s*=/.test(projectCodexConfig);
-    const hasEnvTsconfig = /TYPEGRAPH_TSCONFIG\s*=/.test(projectCodexConfig);
-    if (hasProjectCodexRegistration) {
-      pass("MCP registered in project .codex/config.toml");
-      const trusted = hasTrustedCodexProject(projectRoot3);
-      if (trusted === false) {
-        warn(
-          "Project Codex config may be ignored",
-          'Add the project (or a parent directory) to ~/.codex/config.toml with trust_level = "trusted"'
-        );
-      }
-    } else {
-      const issues = [];
-      if (!hasSection) issues.push("[mcp_servers.typegraph] section is missing");
-      if (!hasCommand) issues.push("command is missing");
-      if (!hasArgs) issues.push("args are missing");
-      if (!hasTsxLauncher) issues.push("command should point to tsx or args should include 'tsx'");
-      if (!hasEnvRoot) issues.push("TYPEGRAPH_PROJECT_ROOT is missing");
-      if (!hasEnvTsconfig) issues.push("TYPEGRAPH_TSCONFIG is missing");
-      fail(
-        `Project .codex/config.toml registration incomplete: ${issues.join(", ")}`,
-        `Update ${codexConfigPath} with a complete [mcp_servers.typegraph] entry`
-      );
+}
+function buildForwardEdges(files, resolver, projectRoot3) {
+  const forward = /* @__PURE__ */ new Map();
+  const parseFailures = [];
+  for (const filePath of files) {
+    let source;
+    try {
+      source = fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
     }
-  } else if (hasGlobalCodexRegistration) {
-    pass("MCP registered in global Codex CLI config");
-  } else if (antigravityRegistrationPath !== null) {
-    pass(`MCP registered in Antigravity config (${antigravityRegistrationPath})`);
-  } else {
-    const codexConfigPath = path3.resolve(projectRoot3, ".codex/config.toml");
-    const mcpJsonPath = path3.resolve(projectRoot3, ".claude/mcp.json");
-    if (fs2.existsSync(mcpJsonPath)) {
-      try {
-        const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
-        const tsNav = mcpJson?.mcpServers?.["typegraph"];
-        if (tsNav) {
-          const hasCommand = tsNav.command === "npx";
-          const hasArgs = Array.isArray(tsNav.args) && tsNav.args.includes("tsx");
-          const hasEnv = tsNav.env?.["TYPEGRAPH_PROJECT_ROOT"] && tsNav.env?.["TYPEGRAPH_TSCONFIG"];
-          if (hasCommand && hasArgs && hasEnv) {
-            pass("MCP registered in .claude/mcp.json");
-          } else {
-            const issues = [];
-            if (!hasCommand) issues.push("command should be 'npx'");
-            if (!hasArgs) issues.push("args should include 'tsx'");
-            if (!hasEnv) issues.push("env should set TYPEGRAPH_PROJECT_ROOT and TYPEGRAPH_TSCONFIG");
-            fail(
-              `MCP registration incomplete: ${issues.join(", ")}`,
-              "See README for correct .claude/mcp.json format"
-            );
-          }
-        } else {
-          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:
-    {
-      "mcpServers": {
-        "typegraph": {
-          "command": "npx",
-          "args": ["tsx", "${serverPath}"],
-          "env": { "TYPEGRAPH_PROJECT_ROOT": ".", "TYPEGRAPH_TSCONFIG": "./tsconfig.json" }
-        }
-      }
-    }`
-          );
-        }
-      } catch (err) {
-        fail(
-          "Failed to parse .claude/mcp.json",
-          `Check JSON syntax: ${err instanceof Error ? err.message : String(err)}`
-        );
+    let rawImports;
+    try {
+      rawImports = parseFileImports(filePath, source);
+    } catch (err) {
+      parseFailures.push(filePath);
+      continue;
+    }
+    const edges = [];
+    const fromDir = path3.dirname(filePath);
+    for (const raw of rawImports) {
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
+      if (target) {
+        edges.push({
+          target,
+          specifiers: raw.names,
+          isTypeOnly: raw.isTypeOnly,
+          isDynamic: raw.isDynamic
+        });
       }
-    } else {
-      fail(
-        "No MCP registration found",
-        `Create ${codexConfigPath} with [mcp_servers.typegraph] or create .claude/mcp.json with typegraph server registration`
-      );
     }
+    forward.set(filePath, edges);
   }
-  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) => !fs2.existsSync(path3.join(toolNodeModules, ...pkg.split("/")))
-    );
-    if (missing.length === 0) {
-      pass(`Dependencies installed (${requiredPkgs.length} packages)`);
-    } else {
-      fail(`Missing packages: ${missing.join(", ")}`, `Run \`cd ${toolRelPath} && npm install\``);
+  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
+      });
     }
-  } else {
-    fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && npm install\``);
   }
-  try {
-    const oxcParserReq = createRequire(path3.join(toolDir, "package.json"));
-    const { parseSync: parseSync3 } = await import(oxcParserReq.resolve("oxc-parser"));
-    const result = parseSync3("test.ts", 'import { x } from "./y";');
-    if (result.module?.staticImports?.length === 1) {
-      pass("oxc-parser working");
-    } else {
-      fail(
-        "oxc-parser parseSync returned unexpected result",
-        `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
-      );
+  return reverse;
+}
+async function buildGraph(projectRoot3, tsconfigPath3, excludedPaths2 = []) {
+  const startTime = performance.now();
+  const resolver = createResolver(projectRoot3, tsconfigPath3);
+  const fileList = discoverFiles(projectRoot3, excludedPaths2);
+  log2(`Discovered ${fileList.length} source files`);
+  const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot3);
+  const reverse = buildReverseMap(forward);
+  const files = new Set(fileList);
+  const edgeCount = [...forward.values()].reduce((sum, edges) => sum + edges.length, 0);
+  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, projectRoot3) {
+  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);
     }
-  } catch (err) {
-    fail(
-      `oxc-parser failed: ${err instanceof Error ? err.message : String(err)}`,
-      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
-    );
   }
+  let source;
   try {
-    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"] }
-    });
-    let resolveOk = false;
-    const testFile = findFirstTsFile(projectRoot3);
-    if (testFile) {
-      const dir = path3.dirname(testFile);
-      const base = "./" + path3.basename(testFile);
-      const result = resolver.sync(dir, base);
-      resolveOk = !!result.path;
-    }
-    if (resolveOk) {
-      pass("oxc-resolver working");
-    } else {
-      warn(
-        "oxc-resolver loaded but couldn't resolve a test import",
-        "Check tsconfig.json is valid and has correct `references`"
-      );
+    source = fs2.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 = path3.dirname(filePath);
+  const newEdges = [];
+  for (const raw of rawImports) {
+    const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
+    if (target) {
+      newEdges.push({
+        target,
+        specifiers: raw.names,
+        isTypeOnly: raw.isTypeOnly,
+        isDynamic: raw.isDynamic
+      });
     }
-  } catch (err) {
-    fail(
-      `oxc-resolver failed: ${err instanceof Error ? err.message : String(err)}`,
-      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
-    );
   }
-  if (tsVersion) {
-    try {
-      const ok = await testTsserver(projectRoot3);
-      if (ok) {
-        pass("tsserver responds to configure");
-      } else {
-        fail(
-          "tsserver did not respond",
-          "Verify `typescript` is installed and tsconfig.json is valid"
-        );
-      }
-    } catch (err) {
-      fail(
-        `tsserver failed to start: ${err instanceof Error ? err.message : String(err)}`,
-        "Verify `typescript` is installed and tsconfig.json is valid"
-      );
+  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);
     }
-  } else {
-    skip("tsserver test (TypeScript not found)");
+    revEdges.push({
+      target: filePath,
+      specifiers: edge.specifiers,
+      isTypeOnly: edge.isTypeOnly,
+      isDynamic: edge.isDynamic
+    });
   }
-  try {
-    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)));
+}
+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 start2 = performance.now();
-    const { graph } = await buildGraph2(projectRoot3, tsconfigPath3);
-    const elapsed = (performance.now() - start2).toFixed(0);
-    const edgeCount = [...graph.forward.values()].reduce(
-      (s, e) => s + e.length,
-      0
-    );
-    if (graph.files.size > 0 && edgeCount > 0) {
-      pass(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${elapsed}ms]`);
-    } else if (graph.files.size > 0) {
-      warn(
-        `Module graph: ${graph.files.size} files but 0 edges`,
-        "Files found but no internal imports resolved. Check tsconfig references."
-      );
-    } else {
-      fail(
-        "Module graph: 0 files discovered",
-        "Check tsconfig.json includes source files and project root is correct"
-      );
+  }
+  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);
     }
-  } catch (err) {
-    fail(
-      `Module graph build failed: ${err instanceof Error ? err.message : String(err)}`,
-      "Check that oxc-parser and oxc-resolver are installed correctly"
-    );
   }
-  if (toolIsEmbedded) {
-    const lintConfigs = findLintConfigs(projectRoot3);
-    if (lintConfigs.length > 0) {
-      const parentDir = path3.basename(path3.dirname(toolDir));
-      const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
-      for (const config of lintConfigs) {
-        const content = fs2.readFileSync(config.fullPath, "utf-8");
-        const hasParentIgnore = parentIgnorePattern.test(content);
-        if (hasParentIgnore) {
-          pass(`${config.tool} ignores ${parentDir}/ (${config.fileName})`);
+  graph.forward.delete(filePath);
+  graph.reverse.delete(filePath);
+  graph.files.delete(filePath);
+}
+function startWatcher(projectRoot3, graph, resolver, hooks, excludedPaths2 = []) {
+  try {
+    const normalizedExclusions = normalizeExcludedPaths(projectRoot3, excludedPaths2);
+    const watcher = fs2.watch(
+      projectRoot3,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (!filename) return;
+        const ext = path3.extname(filename);
+        if (!TS_EXTENSIONS.has(ext)) return;
+        const parts = filename.split(path3.sep);
+        if (parts.some((p2) => SKIP_DIRS.has(p2))) return;
+        if (SKIP_FILES.has(path3.basename(filename))) return;
+        if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
+          return;
+        const absPath2 = path3.resolve(projectRoot3, filename);
+        if (isExcluded(absPath2, normalizedExclusions)) return;
+        if (fs2.existsSync(absPath2)) {
+          updateFile(graph, absPath2, resolver, projectRoot3);
+          void hooks?.onFileUpdated?.(absPath2);
         } else {
-          fail(
-            `${config.tool} missing ignore: "${parentDir}/**" (${config.fileName})`,
-            `Add to ${config.propertyName} in ${config.fileName}:
-    "${parentDir}/**",`
-          );
+          removeFile(graph, absPath2);
+          void hooks?.onFileDeleted?.(absPath2);
         }
       }
-    } else {
-      skip("Lint config check (no ESLint or Oxlint config found)");
-    }
-  } else {
-    skip("Lint config check (typegraph-mcp is external to project)");
-  }
-  const gitignorePath = path3.resolve(projectRoot3, ".gitignore");
-  if (fs2.existsSync(gitignorePath)) {
-    const gitignoreContent = fs2.readFileSync(gitignorePath, "utf-8");
-    const lines = gitignoreContent.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
-    const ignoresClaude = lines.some(
-      (l) => l === ".claude/" || l === ".claude" || l === "/.claude"
-    );
-    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}/` : ""));
-    } else {
-      const excluded = [];
-      if (ignoresParent) excluded.push(`${parentDir}/`);
-      if (ignoresClaude) excluded.push(".claude/");
-      warn(
-        `.gitignore excludes ${excluded.join(" and ")}`,
-        "Remove these entries so MCP config and tool source are tracked in git"
-      );
-    }
-  } else {
-    skip(".gitignore check (no .gitignore)");
-  }
-  console.log("");
-  const total = passed + failed;
-  if (failed === 0) {
-    console.log(
-      `${passed}/${total} checks passed` + (warned > 0 ? ` (${warned} warning${warned > 1 ? "s" : ""})` : "") + " -- typegraph-mcp is ready"
-    );
-  } else {
-    console.log(
-      `${passed}/${total} checks passed, ${failed} failed` + (warned > 0 ? `, ${warned} warning${warned > 1 ? "s" : ""}` : "") + " -- fix issues above"
     );
+    process.on("SIGINT", () => watcher.close());
+    process.on("SIGTERM", () => watcher.close());
+    log2("File watcher started");
+  } catch (err) {
+    log2("Failed to start file watcher:", err);
   }
-  console.log("");
-  return { passed, failed, warned };
 }
-var ESLINT_CONFIG_NAMES, OXLINT_CONFIG_NAMES;
-var init_check = __esm({
-  "check.ts"() {
-    init_config();
-    ESLINT_CONFIG_NAMES = [
-      "eslint.config.mjs",
-      "eslint.config.js",
-      "eslint.config.ts",
-      "eslint.config.cjs"
-    ];
-    OXLINT_CONFIG_NAMES = [
-      ".oxlintrc.json",
-      "oxlint.config.ts",
-      "oxlint.config.js",
-      "oxlint.config.mjs",
-      "oxlint.config.cjs"
-    ];
+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"];
   }
 });
 
-// tsserver-client.ts
-import { spawn as spawn2 } from "child_process";
-import * as path4 from "path";
+// check.ts
+var check_exports = {};
+__export(check_exports, {
+  main: () => main
+});
 import * as fs3 from "fs";
+import * as path4 from "path";
 import { createRequire as createRequire2 } from "module";
-var log2, REQUEST_TIMEOUT_MS, TsServerClient;
-var init_tsserver_client = __esm({
-  "tsserver-client.ts"() {
-    log2 = (...args2) => console.error("[typegraph/tsserver]", ...args2);
-    REQUEST_TIMEOUT_MS = 1e4;
-    TsServerClient = class {
-      constructor(projectRoot3, tsconfigPath3 = "./tsconfig.json") {
-        this.projectRoot = projectRoot3;
-        this.tsconfigPath = tsconfigPath3;
-      }
-      child = null;
-      seq = 0;
-      pending = /* @__PURE__ */ new Map();
-      openFiles = /* @__PURE__ */ new Set();
-      buffer = Buffer.alloc(0);
-      ready = false;
-      shuttingDown = false;
-      restartCount = 0;
-      maxRestarts = 3;
-      projectsDirty = false;
-      // ─── Path Resolution ────────────────────────────────────────────────────
-      resolvePath(file) {
-        return path4.isAbsolute(file) ? file : path4.resolve(this.projectRoot, file);
-      }
-      relativePath(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 = fs3.readFileSync(absPath2, "utf-8");
-          const lines = content.split("\n");
-          return lines[line - 1]?.trim() ?? "";
-        } catch {
-          return "";
-        }
-      }
-      // ─── Lifecycle ──────────────────────────────────────────────────────────
-      async start() {
-        if (this.child) return;
-        const require2 = createRequire2(path4.resolve(this.projectRoot, "package.json"));
-        const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-        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"],
-          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) log2(`[stderr] ${text}`);
-        });
-        this.child.on("close", (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) => {
-          log2(`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 (fs3.existsSync(tsconfigAbs)) {
-          await this.sendRequest("compilerOptionsForInferredProjects", {
-            options: { allowJs: true, checkJs: false }
-          });
-        }
-        this.ready = true;
-        log2(`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"));
+import { spawn as spawn2, spawnSync } from "child_process";
+function findFirstTsFile(dir, excludedPaths2 = []) {
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
+  try {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        return path4.join(dir, entry.name);
       }
-      tryRestart() {
-        if (this.shuttingDown) return;
-        if (this.restartCount >= this.maxRestarts) {
-          log2(`Max restarts (${this.maxRestarts}) reached, not restarting`);
-          return;
-        }
-        this.restartCount++;
-        log2(`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(() => {
-            });
-          }
-        });
+    }
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
+        const childDir = path4.join(dir, entry.name);
+        if (excludedPaths2.some(
+          (excludedPath) => childDir === excludedPath || childDir.startsWith(excludedPath + path4.sep)
+        )) continue;
+        const found = findFirstTsFile(childDir, excludedPaths2);
+        if (found) return found;
       }
-      rejectAllPending(err) {
-        for (const [seq, pending] of this.pending) {
-          clearTimeout(pending.timer);
-          pending.reject(err);
-        }
-        this.pending.clear();
+    }
+  } catch {
+  }
+  return null;
+}
+function testTsserver(projectRoot3, resolution) {
+  return new Promise((resolve10) => {
+    const child = spawn2("node", [resolution.path, "--disableAutomaticTypingAcquisition"], {
+      cwd: projectRoot3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve10(false);
+    }, 1e4);
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.includes('"success":true')) {
+        clearTimeout(timeout);
+        child.kill();
+        resolve10(true);
       }
-      // ─── Protocol: Parsing ──────────────────────────────────────────────────
-      onData(chunk) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        this.processBuffer();
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve10(false);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+    });
+    const request = JSON.stringify({
+      seq: 1,
+      type: "request",
+      command: "configure",
+      arguments: {
+        preferences: { disableSuggestions: true }
       }
-      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 {
-            log2("Failed to parse tsserver message");
-          }
-        }
+    });
+    child.stdin.write(request + "\n");
+  });
+}
+function readProjectCodexConfig(projectRoot3) {
+  const configPath = path4.resolve(projectRoot3, ".codex/config.toml");
+  if (!fs3.existsSync(configPath)) return null;
+  return fs3.readFileSync(configPath, "utf-8");
+}
+function hasCodexTypegraphRegistration(content) {
+  return /\[mcp_servers\.typegraph\]/.test(content);
+}
+function hasCodexTsxLauncher(content) {
+  return /command\s*=\s*"[^"]*tsx(?:\.cmd)?"/.test(content) || /args\s*=\s*\[[\s\S]*"tsx"/.test(content);
+}
+function hasCompleteCodexTypegraphRegistration(content) {
+  return hasCodexTypegraphRegistration(content) && /command\s*=\s*"[^"]+"/.test(content) && /args\s*=\s*\[[\s\S]*\]/.test(content) && hasCodexTsxLauncher(content) && /TYPEGRAPH_PROJECT_ROOT\s*=/.test(content) && /TYPEGRAPH_TSCONFIG\s*=/.test(content);
+}
+function hasTrustedCodexProject(projectRoot3) {
+  const home = process.env.HOME;
+  if (!home) return null;
+  const globalConfigPath = path4.join(home, ".codex/config.toml");
+  if (!fs3.existsSync(globalConfigPath)) return null;
+  const lines = fs3.readFileSync(globalConfigPath, "utf-8").split(/\r?\n/);
+  let currentProject = null;
+  let currentTrusted = false;
+  const matchesTrustedProject = () => currentProject !== null && currentTrusted && (projectRoot3 === currentProject || projectRoot3.startsWith(currentProject + path4.sep));
+  for (const line of lines) {
+    const sectionMatch = line.match(/^\[projects\."([^"]+)"\]\s*$/);
+    if (sectionMatch) {
+      if (matchesTrustedProject()) return true;
+      currentProject = path4.resolve(sectionMatch[1]);
+      currentTrusted = false;
+      continue;
+    }
+    if (line.startsWith("[")) {
+      if (matchesTrustedProject()) return true;
+      currentProject = null;
+      currentTrusted = false;
+      continue;
+    }
+    if (currentProject && /\btrust_level\s*=\s*"trusted"/.test(line)) {
+      currentTrusted = true;
+    }
+  }
+  return matchesTrustedProject();
+}
+function hasCompleteJsonTypegraphRegistration(config, serverName, projectRoot3) {
+  if (typeof config !== "object" || config === null) return false;
+  const servers = config["mcpServers"];
+  if (typeof servers !== "object" || servers === null) return false;
+  const entry = servers[serverName];
+  if (typeof entry !== "object" || entry === null) return false;
+  const record = entry;
+  const command2 = record["command"];
+  const args2 = record["args"];
+  const env = record["env"];
+  const serializedArgs = JSON.stringify(args2 ?? []);
+  return typeof command2 === "string" && command2.length > 0 && Array.isArray(args2) && serializedArgs.includes("server.ts") && serializedArgs.includes("tsx") && typeof env === "object" && env !== null && env["TYPEGRAPH_PROJECT_ROOT"] === projectRoot3 && typeof env["TYPEGRAPH_TSCONFIG"] === "string";
+}
+function readJsonConfig(configPath) {
+  if (!fs3.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getAntigravityMcpConfigPaths() {
+  const home = process.env.HOME || "";
+  return [
+    path4.join(home, ".gemini/antigravity/mcp_config.json"),
+    path4.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json")
+  ];
+}
+function findAntigravityRegistration(projectRoot3) {
+  const home = process.env.HOME || "";
+  for (const configPath of getAntigravityMcpConfigPaths()) {
+    const config = readJsonConfig(configPath);
+    if (hasCompleteJsonTypegraphRegistration(config, "typegraph-mcp", projectRoot3)) {
+      return configPath.replace(home, "~");
+    }
+  }
+  return null;
+}
+function findLintConfigs(projectRoot3) {
+  const configs = [];
+  for (const fileName of ESLINT_CONFIG_NAMES) {
+    const fullPath = path4.resolve(projectRoot3, fileName);
+    if (fs3.existsSync(fullPath)) {
+      configs.push({ tool: "ESLint", fileName, fullPath, propertyName: "ignores" });
+    }
+  }
+  for (const fileName of OXLINT_CONFIG_NAMES) {
+    const fullPath = path4.resolve(projectRoot3, fileName);
+    if (fs3.existsSync(fullPath)) {
+      configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
+    }
+  }
+  for (const fileName of BIOME_CONFIG_NAMES) {
+    const fullPath = path4.resolve(projectRoot3, fileName);
+    if (fs3.existsSync(fullPath)) {
+      configs.push({ tool: "Biome", fileName, fullPath, propertyName: "files.includes" });
+      break;
+    }
+  }
+  return configs;
+}
+async function main(configOverride) {
+  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir: toolDir2, toolIsEmbedded: toolIsEmbedded2, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  const excludedPaths2 = toolIsEmbedded2 ? [toolDir2] : [];
+  let passed = 0;
+  let failed = 0;
+  let warned = 0;
+  function pass(msg) {
+    console.log(`  \u2713 ${msg}`);
+    passed++;
+  }
+  function fail(msg, fix) {
+    console.log(`  \u2717 ${msg}`);
+    console.log(`    Fix: ${fix}`);
+    failed++;
+  }
+  function warn(msg, note) {
+    console.log(`  ! ${msg}`);
+    console.log(`    ${note}`);
+    warned++;
+  }
+  function skip(msg) {
+    console.log(`  - ${msg} (skipped)`);
+  }
+  console.log("");
+  console.log("typegraph-mcp Health Check");
+  console.log("=======================");
+  console.log(`Project root: ${projectRoot3}`);
+  console.log("");
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (nodeMajor >= 22) {
+    pass(`Node.js ${nodeVersion} (>= 22 required)`);
+  } else {
+    fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 22");
+  }
+  const tsxInRoot = fs3.existsSync(path4.join(projectRoot3, "node_modules/.bin/tsx"));
+  const tsxInTool = fs3.existsSync(path4.join(toolDir2, "node_modules/.bin/tsx"));
+  if (tsxInRoot || tsxInTool) {
+    pass(`tsx available (in ${tsxInRoot ? "project" : "tool"} node_modules)`);
+  } else {
+    pass("tsx available (via npx/global)");
+  }
+  let tsResolution = null;
+  try {
+    tsResolution = resolveTsServer(projectRoot3);
+    if (tsResolution.source === "project") {
+      pass(`TypeScript found (v${tsResolution.version})`);
+    } else if (tsResolution.projectVersion) {
+      pass(
+        `Compatible tsserver found (TypeScript v${tsResolution.version} tool runtime; project uses v${tsResolution.projectVersion})`
+      );
+    } else {
+      pass(`TypeScript found in typegraph-mcp (v${tsResolution.version})`);
+    }
+  } catch {
+    fail(
+      "Compatible tsserver runtime not found",
+      `Run \`cd ${toolRelPath} && npm install --include=optional\``
+    );
+  }
+  const tsconfigAbs = path4.resolve(projectRoot3, tsconfigPath3);
+  if (fs3.existsSync(tsconfigAbs)) {
+    pass(`tsconfig.json exists at ${tsconfigPath3}`);
+  } else {
+    pass("No tsconfig.json; semantic tools will use an inferred TypeScript project");
+  }
+  const pluginMcpPath = path4.join(toolDir2, ".mcp.json");
+  const hasPluginMcp = fs3.existsSync(pluginMcpPath) && fs3.existsSync(path4.join(toolDir2, ".claude-plugin/plugin.json"));
+  const projectCodexConfig = readProjectCodexConfig(projectRoot3);
+  const hasProjectCodexRegistration = projectCodexConfig !== null && hasCompleteCodexTypegraphRegistration(projectCodexConfig);
+  const codexGet = spawnSync("codex", ["mcp", "get", "typegraph"], {
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  const hasGlobalCodexRegistration = codexGet.status === 0;
+  const antigravityRegistrationPath = findAntigravityRegistration(projectRoot3);
+  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 if (projectCodexConfig !== null) {
+    const codexConfigPath = path4.resolve(projectRoot3, ".codex/config.toml");
+    const hasSection = hasCodexTypegraphRegistration(projectCodexConfig);
+    const hasCommand = /command\s*=\s*"[^"]+"/.test(projectCodexConfig);
+    const hasArgs = /args\s*=\s*\[[\s\S]*\]/.test(projectCodexConfig);
+    const hasTsxLauncher = hasCodexTsxLauncher(projectCodexConfig);
+    const hasEnvRoot = /TYPEGRAPH_PROJECT_ROOT\s*=/.test(projectCodexConfig);
+    const hasEnvTsconfig = /TYPEGRAPH_TSCONFIG\s*=/.test(projectCodexConfig);
+    if (hasProjectCodexRegistration) {
+      pass("MCP registered in project .codex/config.toml");
+      const trusted = hasTrustedCodexProject(projectRoot3);
+      if (trusted === false) {
+        warn(
+          "Project Codex config may be ignored",
+          'Add the project (or a parent directory) to ~/.codex/config.toml with trust_level = "trusted"'
+        );
       }
-      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"}`)
-              );
-            }
+    } else {
+      const issues = [];
+      if (!hasSection) issues.push("[mcp_servers.typegraph] section is missing");
+      if (!hasCommand) issues.push("command is missing");
+      if (!hasArgs) issues.push("args are missing");
+      if (!hasTsxLauncher) issues.push("command should point to tsx or args should include 'tsx'");
+      if (!hasEnvRoot) issues.push("TYPEGRAPH_PROJECT_ROOT is missing");
+      if (!hasEnvTsconfig) issues.push("TYPEGRAPH_TSCONFIG is missing");
+      fail(
+        `Project .codex/config.toml registration incomplete: ${issues.join(", ")}`,
+        `Update ${codexConfigPath} with a complete [mcp_servers.typegraph] entry`
+      );
+    }
+  } else if (hasGlobalCodexRegistration) {
+    pass("MCP registered in global Codex CLI config");
+  } else if (antigravityRegistrationPath !== null) {
+    pass(`MCP registered in Antigravity config (${antigravityRegistrationPath})`);
+  } else {
+    const codexConfigPath = path4.resolve(projectRoot3, ".codex/config.toml");
+    const mcpJsonPath = path4.resolve(projectRoot3, ".claude/mcp.json");
+    if (fs3.existsSync(mcpJsonPath)) {
+      try {
+        const mcpJson = JSON.parse(fs3.readFileSync(mcpJsonPath, "utf-8"));
+        const tsNav = mcpJson?.mcpServers?.["typegraph"];
+        if (tsNav) {
+          const hasCommand = tsNav.command === "npx";
+          const hasArgs = Array.isArray(tsNav.args) && tsNav.args.includes("tsx");
+          const hasEnv = tsNav.env?.["TYPEGRAPH_PROJECT_ROOT"] && tsNav.env?.["TYPEGRAPH_TSCONFIG"];
+          if (hasCommand && hasArgs && hasEnv) {
+            pass("MCP registered in .claude/mcp.json");
+          } else {
+            const issues = [];
+            if (!hasCommand) issues.push("command should be 'npx'");
+            if (!hasArgs) issues.push("args should include 'tsx'");
+            if (!hasEnv) issues.push("env should set TYPEGRAPH_PROJECT_ROOT and TYPEGRAPH_TSCONFIG");
+            fail(
+              `MCP registration incomplete: ${issues.join(", ")}`,
+              "See README for correct .claude/mcp.json format"
+            );
           }
+        } else {
+          const serverPath = toolIsEmbedded2 ? `./${toolRelPath}/server.ts` : path4.resolve(toolDir2, "server.ts");
+          fail(
+            "MCP entry 'typegraph' not found in .claude/mcp.json",
+            `Add to .claude/mcp.json:
+    {
+      "mcpServers": {
+        "typegraph": {
+          "command": "npx",
+          "args": ["tsx", "${serverPath}"],
+          "env": { "TYPEGRAPH_PROJECT_ROOT": ".", "TYPEGRAPH_TSCONFIG": "./tsconfig.json" }
         }
       }
-      // ─── 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((resolve9, reject) => {
-          const timer = setTimeout(() => {
-            this.pending.delete(seq);
-            reject(new Error(`tsserver ${command2} timed out after ${REQUEST_TIMEOUT_MS}ms`));
-          }, REQUEST_TIMEOUT_MS);
-          this.pending.set(seq, { resolve: resolve9, 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));
-      }
-      /**
-       * Mark tsserver's view of the disk as stale (a file changed that is NOT open
-       * in tsserver). tsserver's own disk watching silently decays in long-lived
-       * instances at monorepo scale, leaving closed-file contents frozen at project
-       * load time and new files unassigned (they land in single-file inferred
-       * projects, producing definition-only reference results). The next query
-       * forces a `reloadProjects`, which re-globs configs and re-reads closed files
-       * from disk. Open files are unaffected by design — their content is
-       * protocol-owned and refreshed via reloadOpenFile().
-       */
-      markProjectsDirty() {
-        this.projectsDirty = true;
-      }
-      refreshIfDirty() {
-        if (!this.projectsDirty) return;
-        this.projectsDirty = false;
-        this.sendNotification("reloadProjects");
-      }
-      async reloadOpenFile(file) {
-        const absPath2 = this.resolvePath(file);
-        if (!this.openFiles.has(absPath2)) return false;
-        await this.sendRequest("reload", {
-          file: absPath2,
-          tmpfile: absPath2
-        });
-        return true;
-      }
-      closeFile(file) {
-        const absPath2 = this.resolvePath(file);
-        if (!this.openFiles.delete(absPath2)) return false;
-        this.sendNotification("close", { file: absPath2 });
-        return true;
-      }
-      // ─── Public API ────────────────────────────────────────────────────────
-      async definition(file, line, offset) {
-        this.refreshIfDirty();
-        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) {
-        this.refreshIfDirty();
-        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) {
-        this.refreshIfDirty();
-        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) {
-        this.refreshIfDirty();
-        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)
-        }));
+    }`
+          );
+        }
+      } catch (err) {
+        fail(
+          "Failed to parse .claude/mcp.json",
+          `Check JSON syntax: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
-      async navbar(file) {
-        this.refreshIfDirty();
-        const absPath2 = this.resolvePath(file);
-        await this.ensureOpen(absPath2);
-        const body = await this.sendRequest("navbar", {
-          file: absPath2
-        });
-        return body ?? [];
+    } else {
+      fail(
+        "No MCP registration found",
+        `Create ${codexConfigPath} with [mcp_servers.typegraph] or create .claude/mcp.json with typegraph server registration`
+      );
+    }
+  }
+  const toolNodeModules = path4.join(toolDir2, "node_modules");
+  if (fs3.existsSync(toolNodeModules)) {
+    const requiredPkgs = [
+      "@modelcontextprotocol/sdk",
+      "oxc-parser",
+      "oxc-resolver",
+      "typescript",
+      "zod"
+    ];
+    const missing = requiredPkgs.filter(
+      (pkg) => !fs3.existsSync(path4.join(toolNodeModules, ...pkg.split("/")))
+    );
+    if (missing.length === 0) {
+      pass(`Dependencies installed (${requiredPkgs.length} packages)`);
+    } else {
+      fail(`Missing packages: ${missing.join(", ")}`, `Run \`cd ${toolRelPath} && npm install\``);
+    }
+  } else {
+    fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && npm install\``);
+  }
+  try {
+    const oxcParserReq = createRequire2(path4.join(toolDir2, "package.json"));
+    const { parseSync: parseSync3 } = await import(oxcParserReq.resolve("oxc-parser"));
+    const result = parseSync3("test.ts", 'import { x } from "./y";');
+    if (result.module?.staticImports?.length === 1) {
+      pass("oxc-parser working");
+    } else {
+      fail(
+        "oxc-parser parseSync returned unexpected result",
+        `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-parser failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
+    );
+  }
+  try {
+    const oxcResolverReq = createRequire2(path4.join(toolDir2, "package.json"));
+    const { ResolverFactory: ResolverFactory2 } = await import(oxcResolverReq.resolve("oxc-resolver"));
+    const resolver = new ResolverFactory2({
+      ...fs3.existsSync(tsconfigAbs) ? { tsconfig: { configFile: tsconfigAbs, references: "auto" } } : {},
+      extensions: [".ts", ".tsx", ".js"],
+      extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
+    });
+    let resolveOk = false;
+    const testFile = findFirstTsFile(projectRoot3, excludedPaths2);
+    if (testFile) {
+      const dir = path4.dirname(testFile);
+      const base = "./" + path4.basename(testFile);
+      const result = resolver.sync(dir, base);
+      resolveOk = !!result.path;
+    }
+    if (resolveOk) {
+      pass("oxc-resolver working");
+    } else {
+      warn(
+        "oxc-resolver loaded but couldn't resolve a test import",
+        "Check tsconfig.json is valid and has correct `references`"
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-resolver failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
+    );
+  }
+  if (tsResolution) {
+    try {
+      const ok = await testTsserver(projectRoot3, tsResolution);
+      if (ok) {
+        pass("tsserver responds to configure");
+      } else {
+        fail(
+          "tsserver did not respond",
+          "Verify `typescript` is installed and tsconfig.json is valid"
+        );
       }
-    };
+    } catch (err) {
+      fail(
+        `tsserver failed to start: ${err instanceof Error ? err.message : String(err)}`,
+        "Verify `typescript` is installed and tsconfig.json is valid"
+      );
+    }
+  } else {
+    skip("tsserver test (TypeScript not found)");
+  }
+  try {
+    let buildGraph2;
+    try {
+      ({ buildGraph: buildGraph2 } = await import(path4.resolve(toolDir2, "module-graph.js")));
+    } catch {
+      ({ buildGraph: buildGraph2 } = await Promise.resolve().then(() => (init_module_graph(), module_graph_exports)));
+    }
+    const start2 = performance.now();
+    const { graph } = await buildGraph2(
+      projectRoot3,
+      tsconfigPath3,
+      excludedPaths2
+    );
+    const elapsed = (performance.now() - start2).toFixed(0);
+    const edgeCount = [...graph.forward.values()].reduce(
+      (s, e) => s + e.length,
+      0
+    );
+    if (graph.files.size > 0 && edgeCount > 0) {
+      pass(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+    } else if (graph.files.size > 0) {
+      warn(
+        `Module graph: ${graph.files.size} files but 0 edges`,
+        "Files found but no internal imports resolved. Check tsconfig references."
+      );
+    } else {
+      fail(
+        "Module graph: 0 files discovered",
+        "Check tsconfig.json includes source files and project root is correct"
+      );
+    }
+  } catch (err) {
+    fail(
+      `Module graph build failed: ${err instanceof Error ? err.message : String(err)}`,
+      "Check that oxc-parser and oxc-resolver are installed correctly"
+    );
+  }
+  if (toolIsEmbedded2) {
+    const lintConfigs = findLintConfigs(projectRoot3);
+    if (lintConfigs.length > 0) {
+      const parentDir = path4.basename(path4.dirname(toolDir2));
+      const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
+      for (const config of lintConfigs) {
+        const content = fs3.readFileSync(config.fullPath, "utf-8");
+        const hasParentIgnore = config.tool === "Biome" ? biomeScopeExcludes(content, parentDir) : parentIgnorePattern.test(content);
+        if (hasParentIgnore) {
+          pass(`${config.tool} ignores ${parentDir}/ (${config.fileName})`);
+        } else {
+          const expectedPattern = config.tool === "Biome" ? `!!${parentDir}` : `${parentDir}/**`;
+          fail(
+            `${config.tool} missing ignore: "${expectedPattern}" (${config.fileName})`,
+            `Add to ${config.propertyName} in ${config.fileName}:
+    "${expectedPattern}",`
+          );
+        }
+      }
+    } else {
+      skip("Lint config check (no ESLint, Oxlint, or Biome config found)");
+    }
+  } else {
+    skip("Lint config check (typegraph-mcp is external to project)");
+  }
+  const gitignorePath = path4.resolve(projectRoot3, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const gitignoreContent = fs3.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 = toolIsEmbedded2 ? path4.basename(path4.dirname(toolDir2)) : 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}/` : ""));
+    } else {
+      const excluded = [];
+      if (ignoresParent) excluded.push(`${parentDir}/`);
+      if (ignoresClaude) excluded.push(".claude/");
+      warn(
+        `.gitignore excludes ${excluded.join(" and ")}`,
+        "Remove these entries so MCP config and tool source are tracked in git"
+      );
+    }
+  } else {
+    skip(".gitignore check (no .gitignore)");
+  }
+  console.log("");
+  const total = passed + failed;
+  if (failed === 0) {
+    console.log(
+      `${passed}/${total} checks passed` + (warned > 0 ? ` (${warned} warning${warned > 1 ? "s" : ""})` : "") + " -- typegraph-mcp is ready"
+    );
+  } else {
+    console.log(
+      `${passed}/${total} checks passed, ${failed} failed` + (warned > 0 ? `, ${warned} warning${warned > 1 ? "s" : ""}` : "") + " -- fix issues above"
+    );
+  }
+  console.log("");
+  return { passed, failed, warned };
+}
+var ESLINT_CONFIG_NAMES, OXLINT_CONFIG_NAMES;
+var init_check = __esm({
+  "check.ts"() {
+    init_config();
+    init_tsserver_client();
+    init_biome_config();
+    ESLINT_CONFIG_NAMES = [
+      "eslint.config.mjs",
+      "eslint.config.js",
+      "eslint.config.ts",
+      "eslint.config.cjs"
+    ];
+    OXLINT_CONFIG_NAMES = [
+      ".oxlintrc.json",
+      "oxlint.config.ts",
+      "oxlint.config.js",
+      "oxlint.config.mjs",
+      "oxlint.config.cjs"
+    ];
   }
 });
 
@@ -1518,7 +1612,8 @@ var init_graph_queries = __esm({
 // smoke-test.ts
 var smoke_test_exports = {};
 __export(smoke_test_exports, {
-  main: () => main2
+  main: () => main2,
+  selectQuickInfoSymbol: () => selectQuickInfoSymbol
 });
 import * as fs5 from "fs";
 import * as path6 from "path";
@@ -1535,8 +1630,50 @@ function findInNavBar(items, predicate) {
   }
   return null;
 }
-function findTestFile(rootDir) {
+function symbolPositions(symbol, sourceLines) {
+  const span = symbol.spans[0];
+  const positions = [];
+  const lineText = sourceLines[span.start.line - 1];
+  if (lineText) {
+    const nameIndex = lineText.indexOf(symbol.text, Math.max(0, span.start.offset - 1));
+    if (nameIndex >= 0) {
+      positions.push({ line: span.start.line, offset: nameIndex + 1 });
+    }
+  }
+  if (!positions.some((position) => position.offset === span.start.offset)) {
+    positions.push(span.start);
+  }
+  return positions;
+}
+async function probeQuickInfo(client2, file, symbol, sourceLines) {
+  for (const position of symbolPositions(symbol, sourceLines)) {
+    const info = await client2.quickinfo(file, position.line, position.offset);
+    if (info) return { info, position };
+  }
+  return null;
+}
+async function selectQuickInfoSymbol(client2, file, symbols, sourceLines) {
+  const kindPriority = /* @__PURE__ */ new Map([
+    ["const", 0],
+    ["let", 1],
+    ["var", 2],
+    ["class", 3],
+    ["enum", 4],
+    ["function", 5],
+    ["method", 6]
+  ]);
+  const concreteSymbols = symbols.map((symbol, index) => ({ symbol, index })).filter(({ symbol }) => kindPriority.has(symbol.kind)).sort(
+    (a, b) => kindPriority.get(a.symbol.kind) - kindPriority.get(b.symbol.kind) || a.index - b.index
+  ).map(({ symbol }) => symbol);
+  for (const symbol of concreteSymbols) {
+    const probe = await probeQuickInfo(client2, file, symbol, sourceLines);
+    if (probe) return { symbol, ...probe };
+  }
+  return null;
+}
+function findTestFile(rootDir, excludedPaths2 = []) {
   const candidates = [];
+  const normalizedExclusions = excludedPaths2.map((excludedPath) => path6.resolve(excludedPath));
   function walk(dir, depth) {
     if (depth > 5 || candidates.length >= 30) return;
     let entries;
@@ -1548,7 +1685,11 @@ function findTestFile(rootDir) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
-        walk(path6.join(dir, entry.name), depth + 1);
+        const childDir = path6.join(dir, entry.name);
+        if (normalizedExclusions.some(
+          (excludedPath) => childDir === excludedPath || childDir.startsWith(excludedPath + path6.sep)
+        )) continue;
+        walk(childDir, depth + 1);
       } else if (entry.isFile()) {
         const name = entry.name;
         if (name.endsWith(".d.ts") || name.endsWith(".test.ts") || name.endsWith(".spec.ts"))
@@ -1556,7 +1697,7 @@ function findTestFile(rootDir) {
         if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
         try {
           const stat = fs5.statSync(path6.join(dir, name));
-          if (stat.size > 200 && stat.size < 5e4) {
+          if (stat.size > 0 && stat.size < 5e4) {
             candidates.push({ file: path6.join(dir, name), size: stat.size });
           }
         } catch {
@@ -1580,7 +1721,8 @@ function findImporter(graph, file) {
   return (preferred ?? revEdges[0]).target;
 }
 async function main2(configOverride) {
-  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3 } = configOverride ?? resolveConfig(import.meta.dirname);
+  const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir: toolDir2, toolIsEmbedded: toolIsEmbedded2 } = configOverride ?? resolveConfig(import.meta.dirname);
+  const excludedPaths2 = toolIsEmbedded2 ? [toolDir2] : [];
   let passed = 0;
   let failed = 0;
   let skipped = 0;
@@ -1603,7 +1745,7 @@ async function main2(configOverride) {
   console.log("=====================");
   console.log(`Project root: ${projectRoot3}`);
   console.log("");
-  const testFile = findTestFile(projectRoot3);
+  const testFile = findTestFile(projectRoot3, excludedPaths2);
   if (!testFile) {
     console.log("  No suitable .ts file found in project. Cannot run smoke tests.");
     return { passed, failed: failed + 1, skipped };
@@ -1616,7 +1758,7 @@ async function main2(configOverride) {
   let t0;
   t0 = performance.now();
   try {
-    const result = await buildGraph(projectRoot3, tsconfigPath3);
+    const result = await buildGraph(projectRoot3, tsconfigPath3, excludedPaths2);
     graph = result.graph;
     const ms = performance.now() - t0;
     const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
@@ -1733,8 +1875,17 @@ async function main2(configOverride) {
   } 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];
+  const source = fs5.readFileSync(testFile, "utf-8");
+  const sourceLines = source.split(/\r?\n/);
+  const quickInfoSelection = await selectQuickInfoSymbol(
+    client2,
+    testFileRel,
+    allSymbols,
+    sourceLines
+  );
+  const sym = quickInfoSelection?.symbol ?? allSymbols[0];
+  const selectedQuickInfo = quickInfoSelection?.info ?? null;
+  const selectedPosition = quickInfoSelection?.position ?? sym?.spans[0]?.start;
   if (!sym) {
     const toolNames = [
       "find_symbol",
@@ -1749,6 +1900,7 @@ async function main2(configOverride) {
     for (const name of toolNames) skip(name, "No symbol discovered");
   } else {
     const span = sym.spans[0];
+    const point = selectedPosition ?? span.start;
     t0 = performance.now();
     const found = findInNavBar(bar, (item) => item.text === sym.text && item.kind === sym.kind);
     if (found && found.spans.length > 0) {
@@ -1761,7 +1913,7 @@ async function main2(configOverride) {
       fail("find_symbol", `Could not re-find ${sym.text}`, performance.now() - t0);
     }
     t0 = performance.now();
-    const defs = await client2.definition(testFileRel, span.start.line, span.start.offset);
+    const defs = await client2.definition(testFileRel, point.line, point.offset);
     if (defs.length > 0) {
       const def = defs[0];
       pass("definition", `${sym.text} -> ${def.file}:${def.start.line}`, performance.now() - t0);
@@ -1769,7 +1921,7 @@ async function main2(configOverride) {
       pass("definition", `${sym.text} is its own definition`, performance.now() - t0);
     }
     t0 = performance.now();
-    const refs = await client2.references(testFileRel, span.start.line, span.start.offset);
+    const refs = await client2.references(testFileRel, point.line, point.offset);
     const refFiles = new Set(refs.map((r) => r.file));
     pass(
       "references",
@@ -1777,7 +1929,10 @@ async function main2(configOverride) {
       performance.now() - t0
     );
     t0 = performance.now();
-    let info = await client2.quickinfo(testFileRel, span.start.line, span.start.offset);
+    let info = selectedQuickInfo;
+    if (!info) {
+      info = await client2.quickinfo(testFileRel, point.line, point.offset);
+    }
     if (!info && defs.length > 0) {
       const def = defs[0];
       info = await client2.quickinfo(testFileRel, def.start.line, def.start.offset);
@@ -1786,7 +1941,7 @@ async function main2(configOverride) {
       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);
+      skip("type_info", `No discovered symbol returned type info`);
     }
     t0 = performance.now();
     const navItems = await client2.navto(sym.text, 5);
@@ -1818,7 +1973,6 @@ async function main2(configOverride) {
     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 = fs5.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();
@@ -2355,14 +2509,16 @@ async function benchmarkAccuracy(client2, graph) {
   return scenarios;
 }
 async function main3(config) {
-  ({ projectRoot, tsconfigPath } = config ?? resolveConfig(import.meta.dirname));
+  const resolvedConfig = config ?? resolveConfig(import.meta.dirname);
+  ({ projectRoot, tsconfigPath } = resolvedConfig);
+  const excludedPaths2 = resolvedConfig.toolIsEmbedded && resolvedConfig.toolDir ? [resolvedConfig.toolDir] : [];
   console.log("");
   console.log("typegraph-mcp Benchmark");
   console.log("=======================");
   console.log(`Project: ${projectRoot}`);
   console.log("");
   const graphStart = performance.now();
-  const { graph } = await buildGraph(projectRoot, tsconfigPath);
+  const { graph } = await buildGraph(projectRoot, tsconfigPath, excludedPaths2);
   const graphMs = performance.now() - graphStart;
   const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
   console.log(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${graphMs.toFixed(0)}ms]`);
@@ -2716,37 +2872,44 @@ async function main4() {
   log3(`tsconfig: ${tsconfigPath2}`);
   const [, graphResult] = await Promise.all([
     client.start(),
-    buildGraph(projectRoot2, tsconfigPath2)
+    buildGraph(projectRoot2, tsconfigPath2, excludedPaths)
   ]);
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot2, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).then(
-      (wasOpen) => {
-        if (!wasOpen) client.markProjectsDirty();
-      },
-      (err) => {
+  startWatcher(
+    projectRoot2,
+    moduleGraph,
+    graphResult.resolver,
+    {
+      onFileUpdated: (filePath) => client.reloadOpenFile(filePath).then(
+        (wasOpen) => {
+          if (!wasOpen) client.markProjectsDirty();
+        },
+        (err) => {
+          client.markProjectsDirty();
+          log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
+        }
+      ),
+      onFileDeleted: (filePath) => {
+        client.closeFile(filePath);
         client.markProjectsDirty();
-        log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
       }
-    ),
-    onFileDeleted: (filePath) => {
-      client.closeFile(filePath);
-      client.markProjectsDirty();
-    }
-  });
+    },
+    excludedPaths
+  );
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");
 }
-var projectRoot2, tsconfigPath2, log3, client, moduleGraph, moduleResolver, mcpServer, locationOrSymbol, exportKinds, normalizedProjectRoot;
+var projectRoot2, tsconfigPath2, toolDir, toolIsEmbedded, excludedPaths, log3, client, moduleGraph, moduleResolver, mcpServer, locationOrSymbol, exportKinds, normalizedProjectRoot;
 var init_server = __esm({
   "server.ts"() {
     init_tsserver_client();
     init_module_graph();
     init_graph_queries();
     init_config();
-    ({ projectRoot: projectRoot2, tsconfigPath: tsconfigPath2 } = resolveConfig(import.meta.dirname));
+    ({ projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded } = resolveConfig(import.meta.dirname));
+    excludedPaths = toolIsEmbedded ? [toolDir] : [];
     log3 = (...args2) => console.error("[typegraph]", ...args2);
     client = new TsServerClient(projectRoot2, tsconfigPath2);
     mcpServer = new McpServer({
@@ -3256,6 +3419,7 @@ var init_server = __esm({
 });
 
 // cli.ts
+init_biome_config();
 init_config();
 import * as fs8 from "fs";
 import * as path9 from "path";
@@ -3344,6 +3508,7 @@ var AGENTS = {
 };
 var CORE_FILES = [
   "server.ts",
+  "biome-config.ts",
   "module-graph.ts",
   "tsserver-client.ts",
   "graph-queries.ts",
@@ -3777,43 +3942,6 @@ function deregisterAntigravityMcp(projectRoot3) {
     }
   }
 }
-function ensureTsconfigExclude(projectRoot3) {
-  const tsconfigPath3 = path9.resolve(projectRoot3, "tsconfig.json");
-  if (!fs8.existsSync(tsconfigPath3)) return;
-  try {
-    const raw = fs8.readFileSync(tsconfigPath3, "utf-8");
-    const excludeArrayMatch = raw.match(/("exclude"\s*:\s*\[)([\s\S]*?)(\])/);
-    if (excludeArrayMatch && /["']plugins(?:\/\*\*|\/\*|)["']/.test(excludeArrayMatch[2])) {
-      return;
-    }
-    if (excludeArrayMatch) {
-      const updated = raw.replace(
-        /("exclude"\s*:\s*\[)([\s\S]*?)(\])/,
-        (_match, open, items, close) => {
-          const trimmed = items.trimEnd();
-          const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
-          return `${open}${items.trimEnd()}${needsComma ? "," : ""}
-    "plugins/**"${close}`;
-        }
-      );
-      fs8.writeFileSync(tsconfigPath3, updated);
-    } else {
-      const lastBrace = raw.lastIndexOf("}");
-      if (lastBrace !== -1) {
-        const before = raw.slice(0, lastBrace).trimEnd();
-        const needsComma = !before.endsWith(",") && !before.endsWith("{");
-        const patched = `${before}${needsComma ? "," : ""}
-  "exclude": ["plugins/**"]
-}
-`;
-        fs8.writeFileSync(tsconfigPath3, patched);
-      }
-    }
-    p.log.success('Added "plugins/**" to tsconfig.json exclude (prevents build errors)');
-  } catch {
-    p.log.warn('Could not update tsconfig.json \u2014 manually add "plugins/**" to the exclude array to prevent build errors');
-  }
-}
 var ESLINT_CONFIG_NAMES2 = [
   "eslint.config.mjs",
   "eslint.config.js",
@@ -3846,6 +3974,13 @@ function findLintConfigs2(projectRoot3) {
       });
     }
   }
+  for (const fileName of BIOME_CONFIG_NAMES) {
+    const fullPath = path9.resolve(projectRoot3, fileName);
+    if (fs8.existsSync(fullPath)) {
+      configs.push({ tool: "Biome", fileName, fullPath, format: "json" });
+      break;
+    }
+  }
   return configs;
 }
 function appendToArrayLiteral(raw, propertyPattern, valueLiteral) {
@@ -3912,27 +4047,37 @@ function patchOxlintModuleConfig(raw) {
   }
   return null;
 }
+function lintPropertyName(config) {
+  if (config.tool === "ESLint") return "ignores";
+  if (config.tool === "Oxlint") return "ignorePatterns";
+  return "files.includes";
+}
 function ensureLintIgnores(projectRoot3) {
   const configs = findLintConfigs2(projectRoot3);
   for (const config of configs) {
     try {
       const raw = fs8.readFileSync(config.fullPath, "utf-8");
-      if (/["']plugins\/\*\*["']/.test(raw)) continue;
-      const updated = config.tool === "ESLint" ? patchEslintConfig(raw) : config.format === "json" ? patchOxlintJsonConfig(raw) : patchOxlintModuleConfig(raw);
+      if (config.tool === "Biome" ? biomeScopeExcludes(raw, "plugins") : /["']plugins\/\*\*["']/.test(raw)) {
+        continue;
+      }
+      const updated = config.tool === "ESLint" ? patchEslintConfig(raw) : config.tool === "Biome" ? patchBiomeConfig(raw, "plugins") : config.format === "json" ? patchOxlintJsonConfig(raw) : patchOxlintModuleConfig(raw);
       if (updated) {
         fs8.writeFileSync(config.fullPath, updated);
-        const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
-        p.log.success(`Added "plugins/**" to ${config.fileName} ${propertyName}`);
+        const propertyName = lintPropertyName(config);
+        const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
+        p.log.success(`Added "${ignorePattern}" to ${config.fileName} ${propertyName}`);
       } else {
-        const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+        const propertyName = lintPropertyName(config);
+        const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
         p.log.warn(
-          `Could not patch ${config.fileName} \u2014 manually add "plugins/**" to ${propertyName}`
+          `Could not patch ${config.fileName} \u2014 manually add "${ignorePattern}" to ${propertyName}`
         );
       }
     } catch {
-      const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+      const propertyName = lintPropertyName(config);
+      const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
       p.log.warn(
-        `Could not update ${config.fileName} \u2014 manually add "plugins/**" to ${propertyName}`
+        `Could not update ${config.fileName} \u2014 manually add "${ignorePattern}" to ${propertyName}`
       );
     }
   }
@@ -3978,11 +4123,12 @@ async function setup(yes2) {
     p.cancel("No package.json found. Run this from the root of your TypeScript project.");
     process.exit(1);
   }
-  if (!fs8.existsSync(tsconfigPath3)) {
-    p.cancel("No tsconfig.json found. typegraph-mcp requires a TypeScript project.");
-    process.exit(1);
+  if (fs8.existsSync(tsconfigPath3)) {
+    p.log.success("Found package.json and tsconfig.json");
+  } else {
+    p.log.success("Found package.json");
+    p.log.info("No tsconfig.json found; semantic tools will use an inferred TypeScript project");
   }
-  p.log.success("Found package.json and tsconfig.json");
   const targetDir = path9.resolve(projectRoot3, PLUGIN_DIR_NAME);
   const isUpdate = fs8.existsSync(targetDir);
   if (isUpdate && !yes2) {
@@ -4108,7 +4254,6 @@ async function setup(yes2) {
   }
   await setupAgentInstructions(projectRoot3, selectedAgents);
   registerMcpServers(projectRoot3, selectedAgents);
-  ensureTsconfigExclude(projectRoot3);
   ensureLintIgnores(projectRoot3);
   await runVerification(targetDir, selectedAgents);
 }