typegraph-mcp 0.9.42 → 0.9.44

package/check.ts

@@ -170,6 +170,64 @@ function hasTrustedCodexProject(projectRoot: string): boolean | null {
   return matchesTrustedProject();
 }
 
+function hasCompleteJsonTypegraphRegistration(
+  config: unknown,
+  serverName: string,
+  projectRoot: string
+): boolean {
+  if (typeof config !== "object" || config === null) return false;
+  const servers = (config as Record<string, unknown>)["mcpServers"];
+  if (typeof servers !== "object" || servers === null) return false;
+  const entry = (servers as Record<string, unknown>)[serverName];
+  if (typeof entry !== "object" || entry === null) return false;
+
+  const record = entry as Record<string, unknown>;
+  const command = record["command"];
+  const args = record["args"];
+  const env = record["env"];
+  const serializedArgs = JSON.stringify(args ?? []);
+
+  return (
+    typeof command === "string" &&
+    command.length > 0 &&
+    Array.isArray(args) &&
+    serializedArgs.includes("server.ts") &&
+    serializedArgs.includes("tsx") &&
+    typeof env === "object" &&
+    env !== null &&
+    (env as Record<string, unknown>)["TYPEGRAPH_PROJECT_ROOT"] === projectRoot &&
+    typeof (env as Record<string, unknown>)["TYPEGRAPH_TSCONFIG"] === "string"
+  );
+}
+
+function readJsonConfig(configPath: string): unknown | null {
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function getAntigravityMcpConfigPaths(): string[] {
+  const home = process.env.HOME || "";
+  return [
+    path.join(home, ".gemini/antigravity/mcp_config.json"),
+    path.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json"),
+  ];
+}
+
+function findAntigravityRegistration(projectRoot: string): string | null {
+  const home = process.env.HOME || "";
+  for (const configPath of getAntigravityMcpConfigPaths()) {
+    const config = readJsonConfig(configPath);
+    if (hasCompleteJsonTypegraphRegistration(config, "typegraph-mcp", projectRoot)) {
+      return configPath.replace(home, "~");
+    }
+  }
+  return null;
+}
+
 function readProjectPackageJson(projectRoot: string): Record<string, unknown> | null {
   const packageJsonPath = path.resolve(projectRoot, "package.json");
   if (!fs.existsSync(packageJsonPath)) return null;
@@ -346,6 +404,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
     encoding: "utf-8",
   });
   const hasGlobalCodexRegistration = codexGet.status === 0;
+  const antigravityRegistrationPath = findAntigravityRegistration(projectRoot);
   if (process.env.CLAUDE_PLUGIN_ROOT) {
     pass("MCP registered via plugin (CLAUDE_PLUGIN_ROOT set)");
   } else if (hasPluginMcp) {
@@ -382,6 +441,8 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
     }
   } 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 = path.resolve(projectRoot, ".codex/config.toml");
     const mcpJsonPath = path.resolve(projectRoot, ".claude/mcp.json");

package/cli.ts

@@ -22,7 +22,7 @@ import { resolveConfig } from "./config.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
-type AgentId = "claude-code" | "cursor" | "codex" | "gemini" | "copilot";
+type AgentId = "claude-code" | "cursor" | "codex" | "gemini" | "copilot" | "antigravity";
 
 interface AgentDef {
   name: string;
@@ -80,7 +80,7 @@ const CLAUDE_NODE_PLACEHOLDER = "__TYPEGRAPH_NODE__";
 
 const PLUGIN_DIR_NAME = "plugins/typegraph-mcp";
 
-const AGENT_IDS: AgentId[] = ["claude-code", "cursor", "codex", "gemini", "copilot"];
+const AGENT_IDS: AgentId[] = ["claude-code", "cursor", "codex", "gemini", "copilot", "antigravity"];
 
 const AGENTS: Record<AgentId, AgentDef> = {
   "claude-code": {
@@ -129,6 +129,13 @@ const AGENTS: Record<AgentId, AgentDef> = {
     detect: (root) =>
       fs.existsSync(path.join(root, ".github/copilot-instructions.md")),
   },
+  antigravity: {
+    name: "Antigravity",
+    pluginFiles: [],
+    agentFile: "AGENTS.md",
+    needsAgentsSkills: true,
+    detect: (root) => fs.existsSync(path.join(root, ".gemini/antigravity")),
+  },
 };
 
 /** Core files always installed (server, modules, config, package manifest) */
@@ -250,6 +257,35 @@ function getCodexConfigPath(projectRoot: string): string {
   return path.resolve(projectRoot, ".codex/config.toml");
 }
 
+function getAntigravityMcpConfigPaths(): string[] {
+  const home = process.env.HOME || "";
+  return [
+    path.join(home, ".gemini/antigravity/mcp_config.json"),
+    path.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json"),
+  ];
+}
+
+function ensureAntigravityCliPlugin(): void {
+  const home = process.env.HOME || "";
+  const pluginDir = path.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp");
+  const pluginJsonPath = path.join(pluginDir, "plugin.json");
+  if (!fs.existsSync(pluginJsonPath)) {
+    fs.mkdirSync(pluginDir, { recursive: true });
+    fs.writeFileSync(
+      pluginJsonPath,
+      JSON.stringify(
+        {
+          name: "typegraph-mcp",
+          version: "1.0.0",
+          description: "TypeGraph MCP server for TypeScript navigation",
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+}
+
 function isTomlSectionGroup(sectionName: string | null, prefix: string): boolean {
   return sectionName === prefix || sectionName?.startsWith(`${prefix}.`) === true;
 }
@@ -476,6 +512,9 @@ function registerMcpServers(projectRoot: string, selectedAgents: AgentId[]): voi
   if (selectedAgents.includes("copilot")) {
     registerJsonMcp(projectRoot, ".vscode/mcp.json", "servers");
   }
+  if (selectedAgents.includes("antigravity")) {
+    registerAntigravityMcp(projectRoot);
+  }
 }
 
 /** Deregister the typegraph MCP server from all agent config files */
@@ -483,6 +522,7 @@ function deregisterMcpServers(projectRoot: string): void {
   deregisterJsonMcp(projectRoot, ".cursor/mcp.json", "mcpServers");
   deregisterCodexMcp(projectRoot);
   deregisterJsonMcp(projectRoot, ".vscode/mcp.json", "servers");
+  deregisterAntigravityMcp(projectRoot);
 }
 
 /** Register MCP server in a JSON config file (Cursor or Copilot format) */
@@ -593,6 +633,73 @@ function deregisterCodexMcp(projectRoot: string): void {
   }
 }
 
+/** Register MCP server in Antigravity's config files */
+function registerAntigravityMcp(projectRoot: string): void {
+  const home = process.env.HOME || "";
+  const pluginDir = path.resolve(projectRoot, PLUGIN_DIR_NAME);
+  const tsConfigPath = path.resolve(projectRoot, "tsconfig.json");
+  ensureAntigravityCliPlugin();
+
+  const entry = {
+    command: process.execPath,
+    args: [
+      path.join(pluginDir, "node_modules/tsx/dist/cli.mjs"),
+      path.join(pluginDir, "server.ts"),
+    ],
+    env: {
+      TYPEGRAPH_PROJECT_ROOT: projectRoot,
+      TYPEGRAPH_TSCONFIG: tsConfigPath,
+    },
+  };
+
+  for (const configPath of getAntigravityMcpConfigPaths()) {
+    let config: any = { mcpServers: {} };
+    if (fs.existsSync(configPath)) {
+      try {
+        config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      } catch {
+        p.log.warn(`Could not parse ~${configPath.replace(home, "")} — skipping MCP registration`);
+        continue;
+      }
+    }
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers["typegraph-mcp"] = entry;
+
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    p.log.success(`~${configPath.replace(home, "")}: registered typegraph-mcp server`);
+  }
+}
+
+/** Deregister MCP server from Antigravity's config files */
+function deregisterAntigravityMcp(projectRoot: string): void {
+  const home = process.env.HOME || "";
+
+  for (const configPath of getAntigravityMcpConfigPaths()) {
+    if (!fs.existsSync(configPath)) continue;
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (config.mcpServers && config.mcpServers["typegraph-mcp"]) {
+        delete config.mcpServers["typegraph-mcp"];
+        if (Object.keys(config.mcpServers).length === 0) {
+          delete config.mcpServers;
+        }
+        if (Object.keys(config).length === 0) {
+          fs.unlinkSync(configPath);
+        } else {
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        }
+        p.log.info(`~${configPath.replace(home, "")}: removed typegraph-mcp server`);
+      }
+    } catch {
+      // Ignore
+    }
+  }
+}
+
 // ─── TSConfig Exclude ─────────────────────────────────────────────────────────
 
 function ensureTsconfigExclude(projectRoot: string): void {
@@ -876,7 +983,7 @@ async function setup(yes: boolean): Promise<void> {
   // 3. Agent selection
   const selectedAgents = await selectAgents(projectRoot, yes);
 
-  const needsPluginSkills = selectedAgents.includes("claude-code") || selectedAgents.includes("cursor");
+  const needsPluginSkills = selectedAgents.includes("claude-code") || selectedAgents.includes("cursor") || selectedAgents.includes("antigravity");
   const needsAgentsSkills = selectedAgents.some((id) => AGENTS[id].needsAgentsSkills);
 
   p.log.step(`Installing to ${PLUGIN_DIR_NAME}/...`);

package/dist/benchmark.js

@@ -201,6 +201,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/dist/check.js

@@ -301,7 +301,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot, graph, resolver) {
+function startWatcher(projectRoot, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot,
@@ -318,8 +318,10 @@ function startWatcher(projectRoot, graph, resolver) {
         const absPath = path2.resolve(projectRoot, filename);
         if (fs.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );
@@ -476,6 +478,44 @@ function hasTrustedCodexProject(projectRoot) {
   }
   return matchesTrustedProject();
 }
+function hasCompleteJsonTypegraphRegistration(config, serverName, projectRoot) {
+  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 command = record["command"];
+  const args = record["args"];
+  const env = record["env"];
+  const serializedArgs = JSON.stringify(args ?? []);
+  return typeof command === "string" && command.length > 0 && Array.isArray(args) && serializedArgs.includes("server.ts") && serializedArgs.includes("tsx") && typeof env === "object" && env !== null && env["TYPEGRAPH_PROJECT_ROOT"] === projectRoot && 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(projectRoot) {
+  const home = process.env.HOME || "";
+  for (const configPath of getAntigravityMcpConfigPaths()) {
+    const config = readJsonConfig(configPath);
+    if (hasCompleteJsonTypegraphRegistration(config, "typegraph-mcp", projectRoot)) {
+      return configPath.replace(home, "~");
+    }
+  }
+  return null;
+}
 function readProjectPackageJson(projectRoot) {
   const packageJsonPath = path3.resolve(projectRoot, "package.json");
   if (!fs2.existsSync(packageJsonPath)) return null;
@@ -609,6 +649,7 @@ async function main(configOverride) {
     encoding: "utf-8"
   });
   const hasGlobalCodexRegistration = codexGet.status === 0;
+  const antigravityRegistrationPath = findAntigravityRegistration(projectRoot);
   if (process.env.CLAUDE_PLUGIN_ROOT) {
     pass("MCP registered via plugin (CLAUDE_PLUGIN_ROOT set)");
   } else if (hasPluginMcp) {
@@ -645,6 +686,8 @@ async function main(configOverride) {
     }
   } 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(projectRoot, ".codex/config.toml");
     const mcpJsonPath = path3.resolve(projectRoot, ".claude/mcp.json");

package/dist/cli.js

@@ -317,7 +317,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot3, graph, resolver) {
+function startWatcher(projectRoot3, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot3,
@@ -334,8 +334,10 @@ function startWatcher(projectRoot3, graph, resolver) {
         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);
         }
       }
     );
@@ -483,6 +485,44 @@ function hasTrustedCodexProject(projectRoot3) {
   }
   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;
@@ -603,6 +643,7 @@ async function main(configOverride) {
     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) {
@@ -639,6 +680,8 @@ async function main(configOverride) {
     }
   } 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");
@@ -1087,6 +1130,21 @@ var init_tsserver_client = __esm({
         this.sendNotification("open", { file: absPath2 });
         await new Promise((r) => setTimeout(r, 50));
       }
+      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) {
         const absPath2 = this.resolvePath(file);
@@ -2638,7 +2696,14 @@ async function main4() {
   ]);
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot2, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot2, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
+      log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
+    }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    }
+  });
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");
@@ -3193,7 +3258,7 @@ Practical rule:
 var SNIPPET_MARKER = "## TypeScript Navigation (typegraph-mcp)";
 var CLAUDE_NODE_PLACEHOLDER = "__TYPEGRAPH_NODE__";
 var PLUGIN_DIR_NAME = "plugins/typegraph-mcp";
-var AGENT_IDS = ["claude-code", "cursor", "codex", "gemini", "copilot"];
+var AGENT_IDS = ["claude-code", "cursor", "codex", "gemini", "copilot", "antigravity"];
 var AGENTS = {
   "claude-code": {
     name: "Claude Code",
@@ -3237,6 +3302,13 @@ var AGENTS = {
     agentFile: ".github/copilot-instructions.md",
     needsAgentsSkills: true,
     detect: (root) => fs8.existsSync(path9.join(root, ".github/copilot-instructions.md"))
+  },
+  antigravity: {
+    name: "Antigravity",
+    pluginFiles: [],
+    agentFile: "AGENTS.md",
+    needsAgentsSkills: true,
+    detect: (root) => fs8.existsSync(path9.join(root, ".gemini/antigravity"))
   }
 };
 var CORE_FILES = [
@@ -3322,6 +3394,33 @@ function getCodexMcpServerEntry(projectRoot3) {
 function getCodexConfigPath(projectRoot3) {
   return path9.resolve(projectRoot3, ".codex/config.toml");
 }
+function getAntigravityMcpConfigPaths2() {
+  const home = process.env.HOME || "";
+  return [
+    path9.join(home, ".gemini/antigravity/mcp_config.json"),
+    path9.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json")
+  ];
+}
+function ensureAntigravityCliPlugin() {
+  const home = process.env.HOME || "";
+  const pluginDir = path9.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp");
+  const pluginJsonPath = path9.join(pluginDir, "plugin.json");
+  if (!fs8.existsSync(pluginJsonPath)) {
+    fs8.mkdirSync(pluginDir, { recursive: true });
+    fs8.writeFileSync(
+      pluginJsonPath,
+      JSON.stringify(
+        {
+          name: "typegraph-mcp",
+          version: "1.0.0",
+          description: "TypeGraph MCP server for TypeScript navigation"
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+}
 function isTomlSectionGroup(sectionName, prefix) {
   return sectionName === prefix || sectionName?.startsWith(`${prefix}.`) === true;
 }
@@ -3495,11 +3594,15 @@ function registerMcpServers(projectRoot3, selectedAgents) {
   if (selectedAgents.includes("copilot")) {
     registerJsonMcp(projectRoot3, ".vscode/mcp.json", "servers");
   }
+  if (selectedAgents.includes("antigravity")) {
+    registerAntigravityMcp(projectRoot3);
+  }
 }
 function deregisterMcpServers(projectRoot3) {
   deregisterJsonMcp(projectRoot3, ".cursor/mcp.json", "mcpServers");
   deregisterCodexMcp(projectRoot3);
   deregisterJsonMcp(projectRoot3, ".vscode/mcp.json", "servers");
+  deregisterAntigravityMcp(projectRoot3);
 }
 function registerJsonMcp(projectRoot3, configPath, rootKey) {
   const fullPath = path9.resolve(projectRoot3, configPath);
@@ -3585,6 +3688,64 @@ function deregisterCodexMcp(projectRoot3) {
     }
   }
 }
+function registerAntigravityMcp(projectRoot3) {
+  const home = process.env.HOME || "";
+  const pluginDir = path9.resolve(projectRoot3, PLUGIN_DIR_NAME);
+  const tsConfigPath = path9.resolve(projectRoot3, "tsconfig.json");
+  ensureAntigravityCliPlugin();
+  const entry = {
+    command: process.execPath,
+    args: [
+      path9.join(pluginDir, "node_modules/tsx/dist/cli.mjs"),
+      path9.join(pluginDir, "server.ts")
+    ],
+    env: {
+      TYPEGRAPH_PROJECT_ROOT: projectRoot3,
+      TYPEGRAPH_TSCONFIG: tsConfigPath
+    }
+  };
+  for (const configPath of getAntigravityMcpConfigPaths2()) {
+    let config = { mcpServers: {} };
+    if (fs8.existsSync(configPath)) {
+      try {
+        config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      } catch {
+        p.log.warn(`Could not parse ~${configPath.replace(home, "")} \u2014 skipping MCP registration`);
+        continue;
+      }
+    }
+    if (!config.mcpServers) config.mcpServers = {};
+    config.mcpServers["typegraph-mcp"] = entry;
+    const dir = path9.dirname(configPath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
+    }
+    fs8.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    p.log.success(`~${configPath.replace(home, "")}: registered typegraph-mcp server`);
+  }
+}
+function deregisterAntigravityMcp(projectRoot3) {
+  const home = process.env.HOME || "";
+  for (const configPath of getAntigravityMcpConfigPaths2()) {
+    if (!fs8.existsSync(configPath)) continue;
+    try {
+      const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      if (config.mcpServers && config.mcpServers["typegraph-mcp"]) {
+        delete config.mcpServers["typegraph-mcp"];
+        if (Object.keys(config.mcpServers).length === 0) {
+          delete config.mcpServers;
+        }
+        if (Object.keys(config).length === 0) {
+          fs8.unlinkSync(configPath);
+        } else {
+          fs8.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        }
+        p.log.info(`~${configPath.replace(home, "")}: removed typegraph-mcp server`);
+      }
+    } catch {
+    }
+  }
+}
 function ensureTsconfigExclude(projectRoot3) {
   const tsconfigPath3 = path9.resolve(projectRoot3, "tsconfig.json");
   if (!fs8.existsSync(tsconfigPath3)) return;
@@ -3807,7 +3968,7 @@ async function setup(yes2) {
     }
   }
   const selectedAgents = await selectAgents(projectRoot3, yes2);
-  const needsPluginSkills = selectedAgents.includes("claude-code") || selectedAgents.includes("cursor");
+  const needsPluginSkills = selectedAgents.includes("claude-code") || selectedAgents.includes("cursor") || selectedAgents.includes("antigravity");
   const needsAgentsSkills = selectedAgents.some((id) => AGENTS[id].needsAgentsSkills);
   p.log.step(`Installing to ${PLUGIN_DIR_NAME}/...`);
   const s = p.spinner();

package/dist/module-graph.js

@@ -297,7 +297,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot, graph, resolver) {
+function startWatcher(projectRoot, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot,
@@ -314,8 +314,10 @@ function startWatcher(projectRoot, graph, resolver) {
         const absPath = path.resolve(projectRoot, filename);
         if (fs.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );

package/dist/server.js

@@ -202,6 +202,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath2 });
     await new Promise((r) => setTimeout(r, 50));
   }
+  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) {
     const absPath2 = this.resolvePath(file);
@@ -568,7 +583,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot2, graph, resolver) {
+function startWatcher(projectRoot2, graph, resolver, hooks) {
   try {
     const watcher = fs2.watch(
       projectRoot2,
@@ -585,8 +600,10 @@ function startWatcher(projectRoot2, graph, resolver) {
         const absPath2 = path2.resolve(projectRoot2, filename);
         if (fs2.existsSync(absPath2)) {
           updateFile(graph, absPath2, resolver, projectRoot2);
+          void hooks?.onFileUpdated?.(absPath2);
         } else {
           removeFile(graph, absPath2);
+          void hooks?.onFileDeleted?.(absPath2);
         }
       }
     );
@@ -1677,7 +1694,14 @@ async function main() {
   ]);
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
+      log3(`Failed to reload open file ${relPath(filePath)}:`, err);
+    }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    }
+  });
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");

package/dist/smoke-test.js

@@ -200,6 +200,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/dist/tsserver-client.js

@@ -195,6 +195,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/engine-sync-test.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env npx tsx
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+type DependencyTreeResult = {
+  root: string;
+  nodes: number;
+  files: string[];
+};
+
+type TypeInfoResult = {
+  type: string | null;
+  documentation: string | null;
+  kind?: string;
+  source?: string;
+};
+
+type ModuleExportsResult = {
+  file: string;
+  exports: Array<{
+    symbol: string;
+    type: string | null;
+  }>;
+  count: number;
+};
+
+function normalize(file: string): string {
+  return file.replaceAll("\\", "/");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitFor(
+  description: string,
+  fn: () => Promise<void>,
+  timeoutMs = 5_000,
+  intervalMs = 50
+): Promise<void> {
+  const start = Date.now();
+  let lastError: unknown;
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await fn();
+      return;
+    } catch (err) {
+      lastError = err;
+      await sleep(intervalMs);
+    }
+  }
+
+  throw new Error(
+    `${description} did not stabilize within ${timeoutMs}ms: ${String(lastError)}`
+  );
+}
+
+function writeFile(root: string, relativePath: string, content: string): void {
+  const absPath = path.join(root, relativePath);
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, content);
+}
+
+async function main(): Promise<void> {
+  const repoRoot = import.meta.dirname;
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "typegraph-engine-sync-"));
+  const projectRoot = path.join(tempRoot, "project");
+
+  fs.mkdirSync(projectRoot, { recursive: true });
+  writeFile(
+    projectRoot,
+    "package.json",
+    JSON.stringify(
+      {
+        name: "typegraph-engine-sync-fixture",
+        private: true,
+        type: "module",
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  writeFile(
+    projectRoot,
+    "tsconfig.json",
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          strict: true,
+        },
+        include: ["src/**/*.ts"],
+      },
+      null,
+      2
+    ) + "\n"
+  );
+
+  writeFile(projectRoot, "src/a.ts", 'export const current = "a" as const;\n');
+  writeFile(projectRoot, "src/b.ts", 'export const current = "b" as const;\n');
+  writeFile(
+    projectRoot,
+    "src/main.ts",
+    'import { current } from "./a";\nexport const value = current;\n'
+  );
+  writeFile(projectRoot, "src/test.ts", "export const oldName = 1 as const;\n");
+  writeFile(projectRoot, "src/util.ts", "export const helper = 1 as const;\n");
+
+  fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules/typescript"),
+    path.join(projectRoot, "node_modules/typescript"),
+    "dir"
+  );
+
+  const client = new Client({ name: "engine-sync-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: path.join(repoRoot, "node_modules/.bin/tsx"),
+    args: [path.join(repoRoot, "server.ts")],
+    cwd: projectRoot,
+    env: {
+      TYPEGRAPH_PROJECT_ROOT: projectRoot,
+      TYPEGRAPH_TSCONFIG: path.join(projectRoot, "tsconfig.json"),
+    },
+  });
+
+  async function callTool<T>(name: string, args: Record<string, unknown>): Promise<T> {
+    const result = await client.request(
+      {
+        method: "tools/call",
+        params: {
+          name,
+          arguments: args,
+        },
+      },
+      CallToolResultSchema
+    );
+
+    const content = result.content[0];
+    assert.ok(content?.type === "text", `Expected text response from ${name}`);
+    return JSON.parse(content.text) as T;
+  }
+
+  try {
+    await client.connect(transport);
+
+    const initialType = await callTool<TypeInfoResult>("ts_type_info", {
+      file: "src/main.ts",
+      line: 2,
+      column: 14,
+    });
+    assert.match(initialType.type ?? "", /"a"/);
+
+    writeFile(projectRoot, "src/main.ts", 'import { current } from "./b";\nexport const value = current;\n');
+
+    await waitFor("import swap to synchronize graph and tsserver", async () => {
+      const deps = await callTool<DependencyTreeResult>("ts_dependency_tree", {
+        file: "src/main.ts",
+      });
+      const normalizedDeps = deps.files.map(normalize);
+      assert.ok(normalizedDeps.includes("src/b.ts"), `Expected src/b.ts in ${normalizedDeps}`);
+      assert.ok(!normalizedDeps.includes("src/a.ts"), `Expected src/a.ts to be removed from ${normalizedDeps}`);
+
+      const typeInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/main.ts",
+        line: 2,
+        column: 14,
+      });
+      assert.match(typeInfo.type ?? "", /"b"/);
+    });
+
+    // Open test.ts through ts_module_exports, then rename the export on disk.
+    const initialExports = await callTool<ModuleExportsResult>("ts_module_exports", {
+      file: "src/test.ts",
+    });
+    assert.ok(initialExports.exports.some((item) => item.symbol === "oldName"));
+
+    writeFile(projectRoot, "src/test.ts", "export const newName = 1 as const;\n");
+
+    await waitFor("symbol rename to refresh mixed export metadata", async () => {
+      const exportsResult = await callTool<ModuleExportsResult>("ts_module_exports", {
+        file: "src/test.ts",
+      });
+      const next = exportsResult.exports.find((item) => item.symbol === "newName");
+      assert.ok(next, `Expected newName in ${JSON.stringify(exportsResult.exports)}`);
+      assert.match(next.type ?? "", /\bnewName\b/);
+      assert.ok(!exportsResult.exports.some((item) => item.symbol === "oldName"));
+    });
+
+    // Open util.ts directly so tsserver tracks it, then delete it from disk.
+    const utilInfo = await callTool<TypeInfoResult>("ts_type_info", {
+      file: "src/util.ts",
+      line: 1,
+      column: 14,
+    });
+    assert.match(utilInfo.type ?? "", /\bhelper: 1\b/);
+    fs.rmSync(path.join(projectRoot, "src/util.ts"));
+
+    await waitFor("deleted file to disappear from semantic answers", async () => {
+      const deletedInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/util.ts",
+        line: 1,
+        column: 14,
+      });
+      assert.equal(
+        deletedInfo.type,
+        null,
+        `Expected deleted file to have no type info, got ${JSON.stringify(deletedInfo)}`
+      );
+    });
+
+    console.log("");
+    console.log("typegraph-mcp Engine Sync Test");
+    console.log("==============================");
+    console.log("  ✓ import swaps keep dependency_tree and type_info aligned");
+    console.log("  ✓ export renames refresh ts_module_exports semantic metadata");
+    console.log("  ✓ deleted open files do not survive as tsserver ghost snapshots");
+  } finally {
+    await transport.close().catch(() => {});
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/install-oxlint-test.ts

@@ -22,13 +22,14 @@ function copyDir(src: string, dest: string): void {
 function runTsx(
   toolRoot: string,
   args: string[],
-  cwd: string
+  cwd: string,
+  env: NodeJS.ProcessEnv = process.env
 ): string {
   return execFileSync(path.join(toolRoot, "node_modules/.bin/tsx"), args, {
     cwd,
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024,
-    env: process.env,
+    env,
   });
 }
 
@@ -44,6 +45,7 @@ async function main(): Promise<void> {
   const fixtureRoot = path.join(repoRoot, ".fixtures/install-oxlint");
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "typegraph-install-oxlint-"));
   const projectRoot = path.join(tempRoot, "project");
+  const homeRoot = path.join(tempRoot, "home");
 
   copyDir(fixtureRoot, projectRoot);
   fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
@@ -54,7 +56,14 @@ async function main(): Promise<void> {
   );
 
   try {
-    const setupOutput = runTsx(repoRoot, [path.join(repoRoot, "cli.ts"), "setup", "--yes"], projectRoot);
+    fs.mkdirSync(homeRoot, { recursive: true });
+    const testEnv = { ...process.env, HOME: homeRoot };
+    const setupOutput = runTsx(
+      repoRoot,
+      [path.join(repoRoot, "cli.ts"), "setup", "--yes"],
+      projectRoot,
+      testEnv
+    );
     const pluginRoot = path.join(projectRoot, "plugins/typegraph-mcp");
 
     const tsconfig = fs.readFileSync(path.join(projectRoot, "tsconfig.json"), "utf-8");
@@ -70,7 +79,12 @@ async function main(): Promise<void> {
     assertIncludes(setupOutput, 'Added "plugins/**" to .oxlintrc.json ignorePatterns');
     assertIncludes(setupOutput, "Oxlint ignores plugins/ (.oxlintrc.json)");
 
-    const checkOutput = runTsx(pluginRoot, [path.join(pluginRoot, "cli.ts"), "check"], projectRoot);
+    const checkOutput = runTsx(
+      pluginRoot,
+      [path.join(pluginRoot, "cli.ts"), "check"],
+      projectRoot,
+      testEnv
+    );
     assertIncludes(checkOutput, "Oxlint ignores plugins/ (.oxlintrc.json)");
     assert.ok(
       !checkOutput.includes("Lint config check (no ESLint or Oxlint config found)"),

package/module-graph.ts

@@ -460,7 +460,11 @@ export function removeFile(graph: ModuleGraph, filePath: string): void {
 export function startWatcher(
   projectRoot: string,
   graph: ModuleGraph,
-  resolver: ResolverFactory
+  resolver: ResolverFactory,
+  hooks?: {
+    onFileUpdated?: (filePath: string) => void | Promise<void>;
+    onFileDeleted?: (filePath: string) => void | Promise<void>;
+  }
 ): void {
   try {
     const watcher = fs.watch(
@@ -489,9 +493,11 @@ export function startWatcher(
         if (fs.existsSync(absPath)) {
           // File created or modified
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           // File deleted
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph-mcp",
-  "version": "0.9.42",
+  "version": "0.9.44",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",
@@ -34,7 +34,7 @@
   "scripts": {
     "build": "tsup",
     "start": "tsx server.ts",
-    "test": "tsx smoke-test.ts && tsx export-surface-test.ts && tsx install-oxlint-test.ts",
+    "test": "tsx smoke-test.ts && tsx export-surface-test.ts && tsx engine-sync-test.ts && tsx install-oxlint-test.ts",
     "check": "tsx check.ts"
   },
   "dependencies": {

package/server.ts

@@ -1132,7 +1132,15 @@ async function main() {
 
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) =>
+      client.reloadOpenFile(filePath).catch((err) => {
+        log(`Failed to reload open file ${relPath(filePath)}:`, err);
+      }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    },
+  });
 
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);

package/tsserver-client.ts

@@ -323,6 +323,23 @@ export class TsServerClient {
     await new Promise((r) => setTimeout(r, 50));
   }
 
+  async reloadOpenFile(file: string): Promise<boolean> {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath,
+    });
+    return true;
+  }
+
+  closeFile(file: string): boolean {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
+
   // ─── Public API ────────────────────────────────────────────────────────
 
   async definition(file: string, line: number, offset: number): Promise<DefinitionResult[]> {