typegraph-mcp 0.9.43 → 0.9.45

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

@@ -25,6 +25,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -201,6 +202,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     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 absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -218,6 +237,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -232,6 +252,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -246,6 +267,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -260,6 +282,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -274,6 +297,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/dist/check.js

@@ -478,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;
@@ -611,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) {
@@ -647,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

@@ -485,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;
@@ -605,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) {
@@ -641,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");
@@ -913,6 +954,7 @@ var init_tsserver_client = __esm({
       shuttingDown = false;
       restartCount = 0;
       maxRestarts = 3;
+      projectsDirty = false;
       // ─── Path Resolution ────────────────────────────────────────────────────
       resolvePath(file) {
         return path4.isAbsolute(file) ? file : path4.resolve(this.projectRoot, file);
@@ -1089,6 +1131,24 @@ var init_tsserver_client = __esm({
         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;
@@ -1106,6 +1166,7 @@ var init_tsserver_client = __esm({
       }
       // ─── Public API ────────────────────────────────────────────────────────
       async definition(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("definition", {
@@ -1120,6 +1181,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async references(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("references", {
@@ -1134,6 +1196,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async quickinfo(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         try {
@@ -1148,6 +1211,7 @@ var init_tsserver_client = __esm({
         }
       }
       async navto(searchValue, maxResults = 10, file) {
+        this.refreshIfDirty();
         if (file) await this.ensureOpen(file);
         const args2 = {
           searchValue,
@@ -1162,6 +1226,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async navbar(file) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("navbar", {
@@ -2656,11 +2721,18 @@ async function main4() {
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot2, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
-      log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
-    }),
+    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();
     }
   });
   const transport = new StdioServerTransport();
@@ -3217,7 +3289,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",
@@ -3261,6 +3333,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 = [
@@ -3346,6 +3425,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;
 }
@@ -3519,11 +3625,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);
@@ -3609,6 +3719,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;
@@ -3831,7 +3999,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/server.js

@@ -26,6 +26,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -202,6 +203,24 @@ var TsServerClient = class {
     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;
@@ -219,6 +238,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("definition", {
@@ -233,6 +253,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("references", {
@@ -247,6 +268,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     try {
@@ -261,6 +283,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -275,6 +298,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("navbar", {
@@ -1695,11 +1719,18 @@ async function main() {
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
-      log3(`Failed to reload open file ${relPath(filePath)}:`, err);
-    }),
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).then(
+      (wasOpen) => {
+        if (!wasOpen) client.markProjectsDirty();
+      },
+      (err) => {
+        client.markProjectsDirty();
+        log3(`Failed to reload open file ${relPath(filePath)}:`, err);
+      }
+    ),
     onFileDeleted: (filePath) => {
       client.closeFile(filePath);
+      client.markProjectsDirty();
     }
   });
   const transport = new StdioServerTransport();

package/dist/smoke-test.js

@@ -24,6 +24,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -200,6 +201,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     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 absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -217,6 +236,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -231,6 +251,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -245,6 +266,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -259,6 +281,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -273,6 +296,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/dist/tsserver-client.js

@@ -19,6 +19,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -195,6 +196,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     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 absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -212,6 +231,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -226,6 +246,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -240,6 +261,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -254,6 +276,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -268,6 +291,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/engine-sync-test.ts

@@ -114,6 +114,12 @@ async function main(): Promise<void> {
   );
   writeFile(projectRoot, "src/test.ts", "export const oldName = 1 as const;\n");
   writeFile(projectRoot, "src/util.ts", "export const helper = 1 as const;\n");
+  writeFile(projectRoot, "src/closed.ts", "export const closedValue = 1 as const;\n");
+  writeFile(
+    projectRoot,
+    "src/closed-consumer.ts",
+    'import { closedValue } from "./closed";\nexport const observed = closedValue;\n'
+  );
 
   fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
   fs.symlinkSync(
@@ -196,6 +202,25 @@ async function main(): Promise<void> {
       assert.ok(!exportsResult.exports.some((item) => item.symbol === "oldName"));
     });
 
+    // Change a file that tsserver has not opened. The watcher should mark
+    // projects dirty so the next semantic query reloads closed-file contents.
+    writeFile(projectRoot, "src/closed.ts", "export const closedValue = 2 as const;\n");
+
+    await waitFor("closed file update to refresh semantic project state", async () => {
+      const deps = await callTool<DependencyTreeResult>("ts_dependency_tree", {
+        file: "src/closed-consumer.ts",
+      });
+      const normalizedDeps = deps.files.map(normalize);
+      assert.ok(normalizedDeps.includes("src/closed.ts"), `Expected src/closed.ts in ${normalizedDeps}`);
+
+      const typeInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/closed-consumer.ts",
+        line: 2,
+        column: 14,
+      });
+      assert.match(typeInfo.type ?? "", /\b2\b/);
+    });
+
     // 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",
@@ -223,6 +248,7 @@ async function main(): Promise<void> {
     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("  ✓ closed-file edits refresh tsserver project state");
     console.log("  ✓ deleted open files do not survive as tsserver ghost snapshots");
   } finally {
     await transport.close().catch(() => {});

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph-mcp",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",

package/server.ts

@@ -1134,11 +1134,20 @@ async function main() {
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
     onFileUpdated: (filePath) =>
-      client.reloadOpenFile(filePath).catch((err) => {
-        log(`Failed to reload open file ${relPath(filePath)}:`, err);
-      }),
+      client.reloadOpenFile(filePath).then(
+        (wasOpen) => {
+          // Closed files: tsserver's own disk watching decays in long-lived
+          // instances; force a projects reload before the next query.
+          if (!wasOpen) client.markProjectsDirty();
+        },
+        (err) => {
+          client.markProjectsDirty();
+          log(`Failed to reload open file ${relPath(filePath)}:`, err);
+        }
+      ),
     onFileDeleted: (filePath) => {
       client.closeFile(filePath);
+      client.markProjectsDirty();
     },
   });
 

package/tsserver-client.ts

@@ -90,6 +90,7 @@ export class TsServerClient {
   private shuttingDown = false;
   private restartCount = 0;
   private readonly maxRestarts = 3;
+  private projectsDirty = false;
 
   constructor(
     private readonly projectRoot: string,
@@ -323,6 +324,29 @@ export class TsServerClient {
     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(): void {
+    this.projectsDirty = true;
+  }
+
+  private refreshIfDirty(): void {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    // reloadProjects sends no response (notRequired), so fire it as a
+    // notification; the following request queues behind the reload on
+    // tsserver's single-threaded loop.
+    this.sendNotification("reloadProjects");
+  }
+
   async reloadOpenFile(file: string): Promise<boolean> {
     const absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -343,6 +367,7 @@ export class TsServerClient {
   // ─── Public API ────────────────────────────────────────────────────────
 
   async definition(file: string, line: number, offset: number): Promise<DefinitionResult[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -361,6 +386,7 @@ export class TsServerClient {
   }
 
   async references(file: string, line: number, offset: number): Promise<ReferenceEntry[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -379,6 +405,7 @@ export class TsServerClient {
   }
 
   async quickinfo(file: string, line: number, offset: number): Promise<QuickInfoResult | null> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -398,6 +425,7 @@ export class TsServerClient {
   }
 
   async navto(searchValue: string, maxResults = 10, file?: string): Promise<NavToItem[]> {
+    this.refreshIfDirty();
     // If a file is specified, open it first so tsserver knows about it
     if (file) await this.ensureOpen(file);
 
@@ -418,6 +446,7 @@ export class TsServerClient {
   }
 
   async navbar(file: string): Promise<NavBarItem[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);