typegraph-mcp 0.9.43 → 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/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");
@@ -3217,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",
@@ -3261,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 = [
@@ -3346,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;
 }
@@ -3519,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);
@@ -3609,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;
@@ -3831,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/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.44",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",