@saluzi/codegraph 0.1.0 → 0.2.1

package/dist/installer/instructions-template.d.ts

@@ -1,30 +1,41 @@
 /**
- * Agent-instructions template — the markdown body each agent target
- * writes into its conventional instructions file (CLAUDE.md /
- * AGENTS.md / codegraph.mdc / etc.).
+ * The marker-fenced agent-instructions block the installer writes into each
+ * agent's instructions file (CLAUDE.md / AGENTS.md / GEMINI.md).
  *
- * The body content is identical across agents because the codegraph
- * usage advice is agent-agnostic — only the destination filename and
- * any optional frontmatter (Cursor `.mdc`) varies per target.
+ * History: pre-#529 the installer wrote a full usage playbook here, which
+ * duplicated the MCP `initialize` instructions for the main agent — so it
+ * was removed and `mcp/server-instructions.ts` became the single source of
+ * truth. A much smaller block returned for #704, because the MCP
+ * instructions cannot reach two audiences that the instructions FILE does
+ * reach:
  *
- * The legacy `claude-md-template.ts` re-exports these names for
- * backwards compatibility with downstream importers.
- */
-/** Markers used by the marker-based section replacement. */
-export declare const CODEGRAPH_SECTION_START = '<!-- CODEGRAPH_START -->'
-export declare const CODEGRAPH_SECTION_END = '<!-- CODEGRAPH_END -->'
-/**
- * The full marker-delimited block written into each agent's
- * instructions file. Includes the start/end markers so the section
- * can be detected and replaced on re-install.
+ *  - **Task-tool subagents** — they receive the project instructions file
+ *    in their context but NOT the MCP initialize instructions. They hold
+ *    the codegraph MCP tools only as deferred names and rarely think to
+ *    load them: measured on a forced-delegation flow question (excalidraw,
+ *    sonnet, high effort), subagents loaded + used codegraph in ~1 of 9
+ *    runs without this block, and consistently with it — including runs
+ *    with zero Read/grep fallback.
+ *  - **Non-MCP harnesses** — agents with no MCP client at all can still
+ *    run the `codegraph explore` CLI, which prints the same output as the
+ *    MCP tool.
+ *
+ * Keep this block SHORT. The main agent reads it every turn on top of the
+ * server instructions — the #529 duplication-cost argument still bounds
+ * its size. Command names and the two surfaces, nothing more.
  */
-export declare const INSTRUCTIONS_TEMPLATE =
-  '<!-- CODEGRAPH_START -->\n## CodeGraph\n\nThis project has a CodeGraph MCP server (`codegraph_*` tools) configured. CodeGraph is a tree-sitter-parsed knowledge graph of every symbol, edge, and file. Reads are sub-millisecond and return structural information grep cannot.\n\n### When to prefer codegraph over native search\n\nUse codegraph for **structural** questions \u2014 what calls what, what would break, where is X defined, what is X\'s signature. Use native grep/read only for **literal text** queries (string contents, comments, log messages) or after you already have a specific file open.\n\n| Question | Tool |\n|---|---|\n| "Where is X defined?" / "Find symbol named X" | `codegraph_search` |\n| "What calls function Y?" | `codegraph_callers` |\n| "What does Y call?" | `codegraph_callees` |\n| "What would break if I changed Z?" | `codegraph_impact` |\n| "Show me Y\'s signature / source / docstring" | `codegraph_node` |\n| "Give me focused context for a task/area" | `codegraph_context` |\n| "See several related symbols\' source at once" | `codegraph_explore` |\n| "What files exist under path/" | `codegraph_files` |\n| "Is the index healthy?" | `codegraph_status` |\n\n### Rules of thumb\n\n- **Answer directly \u2014 don\'t delegate exploration.** For "how does X work" / architecture / trace questions, answer with 2-3 codegraph calls: `codegraph_context` first, then ONE `codegraph_explore` for the source of the symbols it surfaces. Codegraph IS the pre-built index, so spawning a separate file-reading sub-task/agent \u2014 or running a grep + read loop \u2014 repeats work codegraph already did and costs more for the same answer.\n- **Trust codegraph results.** They come from a full AST parse. Do NOT re-verify them with grep \u2014 that\'s slower, less accurate, and wastes context.\n- **Don\'t grep first** when looking up a symbol by name. `codegraph_search` is faster and returns kind + location + signature in one call.\n- **Don\'t chain `codegraph_search` + `codegraph_node`** when you just want context \u2014 `codegraph_context` is one call.\n- **Don\'t loop `codegraph_node` over many symbols** \u2014 one `codegraph_explore` call returns several symbols\' source grouped in a single capped call, while each separate node/Read call re-reads the whole context and costs far more.\n- **Index lag**: the file watcher debounces ~500ms behind writes; don\'t re-query immediately after editing a file in the same turn.\n\n### If `.codegraph/` doesn\'t exist\n\nThe MCP server returns "not initialized." Ask the user: *"I notice this project doesn\'t have CodeGraph initialized. Want me to run `codegraph init -i` to build the index?"*\n<!-- CODEGRAPH_END -->'
+/** Markers used by the marker-based section write/removal. */
+export declare const CODEGRAPH_SECTION_START = "<!-- CODEGRAPH_START -->";
+export declare const CODEGRAPH_SECTION_END = "<!-- CODEGRAPH_END -->";
 /**
- * Backwards-compat alias. Existing downstream code may import
- * `CLAUDE_MD_TEMPLATE` from this module via the re-export shim in
- * `claude-md-template.ts`.
+ * The full block, markers included, exactly as written to disk.
+ *
+ * The wording is deliberately CONDITIONAL ("in repositories indexed by…"):
+ * a global install writes this into a user-scope file (~/.claude/CLAUDE.md,
+ * ~/.codex/AGENTS.md) that applies to every project the user opens —
+ * including unindexed ones, where an unconditional "this repository is
+ * indexed" claim would send subagents into failing codegraph calls (the
+ * noise the unindexed-session policy exists to prevent).
  */
-export declare const CLAUDE_MD_TEMPLATE =
-  '<!-- CODEGRAPH_START -->\n## CodeGraph\n\nThis project has a CodeGraph MCP server (`codegraph_*` tools) configured. CodeGraph is a tree-sitter-parsed knowledge graph of every symbol, edge, and file. Reads are sub-millisecond and return structural information grep cannot.\n\n### When to prefer codegraph over native search\n\nUse codegraph for **structural** questions \u2014 what calls what, what would break, where is X defined, what is X\'s signature. Use native grep/read only for **literal text** queries (string contents, comments, log messages) or after you already have a specific file open.\n\n| Question | Tool |\n|---|---|\n| "Where is X defined?" / "Find symbol named X" | `codegraph_search` |\n| "What calls function Y?" | `codegraph_callers` |\n| "What does Y call?" | `codegraph_callees` |\n| "What would break if I changed Z?" | `codegraph_impact` |\n| "Show me Y\'s signature / source / docstring" | `codegraph_node` |\n| "Give me focused context for a task/area" | `codegraph_context` |\n| "See several related symbols\' source at once" | `codegraph_explore` |\n| "What files exist under path/" | `codegraph_files` |\n| "Is the index healthy?" | `codegraph_status` |\n\n### Rules of thumb\n\n- **Answer directly \u2014 don\'t delegate exploration.** For "how does X work" / architecture / trace questions, answer with 2-3 codegraph calls: `codegraph_context` first, then ONE `codegraph_explore` for the source of the symbols it surfaces. Codegraph IS the pre-built index, so spawning a separate file-reading sub-task/agent \u2014 or running a grep + read loop \u2014 repeats work codegraph already did and costs more for the same answer.\n- **Trust codegraph results.** They come from a full AST parse. Do NOT re-verify them with grep \u2014 that\'s slower, less accurate, and wastes context.\n- **Don\'t grep first** when looking up a symbol by name. `codegraph_search` is faster and returns kind + location + signature in one call.\n- **Don\'t chain `codegraph_search` + `codegraph_node`** when you just want context \u2014 `codegraph_context` is one call.\n- **Don\'t loop `codegraph_node` over many symbols** \u2014 one `codegraph_explore` call returns several symbols\' source grouped in a single capped call, while each separate node/Read call re-reads the whole context and costs far more.\n- **Index lag**: the file watcher debounces ~500ms behind writes; don\'t re-query immediately after editing a file in the same turn.\n\n### If `.codegraph/` doesn\'t exist\n\nThe MCP server returns "not initialized." Ask the user: *"I notice this project doesn\'t have CodeGraph initialized. Want me to run `codegraph init -i` to build the index?"*\n<!-- CODEGRAPH_END -->'
-//# sourceMappingURL=instructions-template.d.ts.map
+export declare const CODEGRAPH_INSTRUCTIONS_BLOCK = "<!-- CODEGRAPH_START -->\n## CodeGraph\n\nIn repositories indexed by CodeGraph (a `.codegraph/` directory exists at the repo root), reach for it BEFORE grep/find or reading files when you need to understand or locate code:\n\n- **MCP tool** (when available): `codegraph_explore` answers most code questions in one call \u2014 the relevant symbols' verbatim source plus the call paths between them, including dynamic-dispatch hops grep can't follow. Name a file or symbol in the query to read its current line-numbered source. If it's listed but deferred, load it by name via tool search.\n- **Shell** (always works): `codegraph explore \"<symbol names or question>\"` prints the same output.\n\nIf there is no `.codegraph/` directory, skip CodeGraph entirely \u2014 indexing is the user's decision.\n<!-- CODEGRAPH_END -->";
+//# sourceMappingURL=instructions-template.d.ts.map

package/dist/installer/instructions-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions-template.d.ts","sourceRoot":"","sources":["../../src/installer/instructions-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAClE,eAAO,MAAM,qBAAqB,2BAA2B,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,2zBAShB,CAAC"}

package/dist/installer/instructions-template.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * The marker-fenced agent-instructions block the installer writes into each
+ * agent's instructions file (CLAUDE.md / AGENTS.md / GEMINI.md).
+ *
+ * History: pre-#529 the installer wrote a full usage playbook here, which
+ * duplicated the MCP `initialize` instructions for the main agent — so it
+ * was removed and `mcp/server-instructions.ts` became the single source of
+ * truth. A much smaller block returned for #704, because the MCP
+ * instructions cannot reach two audiences that the instructions FILE does
+ * reach:
+ *
+ *  - **Task-tool subagents** — they receive the project instructions file
+ *    in their context but NOT the MCP initialize instructions. They hold
+ *    the codegraph MCP tools only as deferred names and rarely think to
+ *    load them: measured on a forced-delegation flow question (excalidraw,
+ *    sonnet, high effort), subagents loaded + used codegraph in ~1 of 9
+ *    runs without this block, and consistently with it — including runs
+ *    with zero Read/grep fallback.
+ *  - **Non-MCP harnesses** — agents with no MCP client at all can still
+ *    run the `codegraph explore` CLI, which prints the same output as the
+ *    MCP tool.
+ *
+ * Keep this block SHORT. The main agent reads it every turn on top of the
+ * server instructions — the #529 duplication-cost argument still bounds
+ * its size. Command names and the two surfaces, nothing more.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEGRAPH_INSTRUCTIONS_BLOCK = exports.CODEGRAPH_SECTION_END = exports.CODEGRAPH_SECTION_START = void 0;
+/** Markers used by the marker-based section write/removal. */
+exports.CODEGRAPH_SECTION_START = '<!-- CODEGRAPH_START -->';
+exports.CODEGRAPH_SECTION_END = '<!-- CODEGRAPH_END -->';
+/**
+ * The full block, markers included, exactly as written to disk.
+ *
+ * The wording is deliberately CONDITIONAL ("in repositories indexed by…"):
+ * a global install writes this into a user-scope file (~/.claude/CLAUDE.md,
+ * ~/.codex/AGENTS.md) that applies to every project the user opens —
+ * including unindexed ones, where an unconditional "this repository is
+ * indexed" claim would send subagents into failing codegraph calls (the
+ * noise the unindexed-session policy exists to prevent).
+ */
+exports.CODEGRAPH_INSTRUCTIONS_BLOCK = `${exports.CODEGRAPH_SECTION_START}
+## CodeGraph
+
+In repositories indexed by CodeGraph (a \`.codegraph/\` directory exists at the repo root), reach for it BEFORE grep/find or reading files when you need to understand or locate code:
+
+- **MCP tool** (when available): \`codegraph_explore\` answers most code questions in one call — the relevant symbols' verbatim source plus the call paths between them, including dynamic-dispatch hops grep can't follow. Name a file or symbol in the query to read its current line-numbered source. If it's listed but deferred, load it by name via tool search.
+- **Shell** (always works): \`codegraph explore "<symbol names or question>"\` prints the same output.
+
+If there is no \`.codegraph/\` directory, skip CodeGraph entirely — indexing is the user's decision.
+${exports.CODEGRAPH_SECTION_END}`;
+//# sourceMappingURL=instructions-template.js.map

package/dist/installer/instructions-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions-template.js","sourceRoot":"","sources":["../../src/installer/instructions-template.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;;;AAEH,8DAA8D;AACjD,QAAA,uBAAuB,GAAG,0BAA0B,CAAC;AACrD,QAAA,qBAAqB,GAAG,wBAAwB,CAAC;AAE9D;;;;;;;;;GASG;AACU,QAAA,4BAA4B,GAAG,GAAG,+BAAuB;;;;;;;;;EASpE,6BAAqB,EAAE,CAAC"}

package/dist/installer/targets/antigravity.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Google Antigravity IDE target. Antigravity is Google's VS Code-derived
+ * multi-agent IDE; the Gemini CLI is in the process of consolidating with
+ * it under a single agent platform. Antigravity reads MCP server
+ * definitions from a separate config file from the CLI.
+ *
+ * ## Config path: unified vs legacy
+ *
+ * Antigravity recently migrated to a **unified** MCP config path shared
+ * across all Antigravity tools:
+ *
+ *   - **Unified** (post-migration, current): `~/.gemini/config/mcp_config.json`
+ *     — signalled by the `~/.gemini/config/.migrated` marker file.
+ *   - **Legacy** (pre-migration): `~/.gemini/antigravity/mcp_config.json`
+ *     — what the github-mcp-server install guide still documents.
+ *
+ * We detect the marker at install time and write to the right path. On
+ * uninstall we sweep BOTH — so a user who installed on the legacy path,
+ * was then auto-migrated by Antigravity, and re-ran `codegraph install`
+ * doesn't end up with stale codegraph entries in two files.
+ *
+ * ## Entry shape: no `type: stdio` field
+ *
+ * Antigravity rejects MCP entries that carry the `type: "stdio"` field
+ * the rest of our targets use — the working entries it manages itself
+ * (e.g. `code-review-graph`) omit it, and dropping it was load-bearing
+ * to get codegraph to appear in the Customizations UI. We build the
+ * entry locally instead of routing through `getMcpServerConfig()`.
+ *
+ * ## macOS GUI app PATH resolution
+ *
+ * Antigravity is a GUI Electron app. macOS gives Dock/Finder-launched
+ * apps a stripped PATH (`/usr/bin:/bin:/usr/sbin:/sbin`) — nvm-managed
+ * tools live outside that, so a bare `codegraph` command fails to spawn
+ * even when `which codegraph` resolves in the user's shell. We resolve
+ * `codegraph` to its absolute path on macOS at install time. (Linux GUI
+ * apps inherit user PATH; Windows uses `PATH` env directly — both are
+ * fine with the bare command.)
+ *
+ * ## Shared instructions (no GEMINI.md from here)
+ *
+ * The IDE shares `~/.gemini/GEMINI.md` with Gemini CLI for instructions
+ * — written by the `./gemini.ts` target. We deliberately don't touch it
+ * here so uninstalling Antigravity without uninstalling Gemini CLI
+ * leaves CLI instructions intact. Users who install only Antigravity
+ * still get a working MCP integration; the prefer-codegraph-over-grep
+ * guidance just won't be present unless they also install the gemini
+ * target.
+ *
+ * ## Location
+ *
+ * `supportsLocation('local')` returns false — Antigravity has no
+ * project-scoped config concept as of 2026-05.
+ */
+import { AgentTarget } from './types';
+export declare const antigravityTarget: AgentTarget;
+//# sourceMappingURL=antigravity.d.ts.map

package/dist/installer/targets/antigravity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antigravity.d.ts","sourceRoot":"","sources":["../../../src/installer/targets/antigravity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAMH,OAAO,EACL,WAAW,EAKZ,MAAM,SAAS,CAAC;AA+NjB,eAAO,MAAM,iBAAiB,EAAE,WAAqC,CAAC"}

package/dist/installer/targets/antigravity.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * Google Antigravity IDE target. Antigravity is Google's VS Code-derived
+ * multi-agent IDE; the Gemini CLI is in the process of consolidating with
+ * it under a single agent platform. Antigravity reads MCP server
+ * definitions from a separate config file from the CLI.
+ *
+ * ## Config path: unified vs legacy
+ *
+ * Antigravity recently migrated to a **unified** MCP config path shared
+ * across all Antigravity tools:
+ *
+ *   - **Unified** (post-migration, current): `~/.gemini/config/mcp_config.json`
+ *     — signalled by the `~/.gemini/config/.migrated` marker file.
+ *   - **Legacy** (pre-migration): `~/.gemini/antigravity/mcp_config.json`
+ *     — what the github-mcp-server install guide still documents.
+ *
+ * We detect the marker at install time and write to the right path. On
+ * uninstall we sweep BOTH — so a user who installed on the legacy path,
+ * was then auto-migrated by Antigravity, and re-ran `codegraph install`
+ * doesn't end up with stale codegraph entries in two files.
+ *
+ * ## Entry shape: no `type: stdio` field
+ *
+ * Antigravity rejects MCP entries that carry the `type: "stdio"` field
+ * the rest of our targets use — the working entries it manages itself
+ * (e.g. `code-review-graph`) omit it, and dropping it was load-bearing
+ * to get codegraph to appear in the Customizations UI. We build the
+ * entry locally instead of routing through `getMcpServerConfig()`.
+ *
+ * ## macOS GUI app PATH resolution
+ *
+ * Antigravity is a GUI Electron app. macOS gives Dock/Finder-launched
+ * apps a stripped PATH (`/usr/bin:/bin:/usr/sbin:/sbin`) — nvm-managed
+ * tools live outside that, so a bare `codegraph` command fails to spawn
+ * even when `which codegraph` resolves in the user's shell. We resolve
+ * `codegraph` to its absolute path on macOS at install time. (Linux GUI
+ * apps inherit user PATH; Windows uses `PATH` env directly — both are
+ * fine with the bare command.)
+ *
+ * ## Shared instructions (no GEMINI.md from here)
+ *
+ * The IDE shares `~/.gemini/GEMINI.md` with Gemini CLI for instructions
+ * — written by the `./gemini.ts` target. We deliberately don't touch it
+ * here so uninstalling Antigravity without uninstalling Gemini CLI
+ * leaves CLI instructions intact. Users who install only Antigravity
+ * still get a working MCP integration; the prefer-codegraph-over-grep
+ * guidance just won't be present unless they also install the gemini
+ * target.
+ *
+ * ## Location
+ *
+ * `supportsLocation('local')` returns false — Antigravity has no
+ * project-scoped config concept as of 2026-05.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.antigravityTarget = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const shared_1 = require("./shared");
+function unifiedConfigDir() {
+    return path.join(os.homedir(), '.gemini', 'config');
+}
+function unifiedMcpConfigPath() {
+    return path.join(unifiedConfigDir(), 'mcp_config.json');
+}
+function legacyConfigDir() {
+    return path.join(os.homedir(), '.gemini', 'antigravity');
+}
+function legacyMcpConfigPath() {
+    return path.join(legacyConfigDir(), 'mcp_config.json');
+}
+function migratedMarkerPath() {
+    return path.join(unifiedConfigDir(), '.migrated');
+}
+/**
+ * Pick the right MCP config path to write to.
+ *
+ * Prefers the unified `~/.gemini/config/mcp_config.json` when Antigravity
+ * has signalled it's migrated (`.migrated` marker present, OR the
+ * unified file already exists — Antigravity creates it on first
+ * launch post-migration). Falls back to the legacy
+ * `~/.gemini/antigravity/mcp_config.json` for users on a pre-migration
+ * Antigravity build.
+ */
+function preferredMcpConfigPath() {
+    if (fs.existsSync(migratedMarkerPath()))
+        return unifiedMcpConfigPath();
+    if (fs.existsSync(unifiedMcpConfigPath()))
+        return unifiedMcpConfigPath();
+    return legacyMcpConfigPath();
+}
+/**
+ * Resolve the on-disk path of the `codegraph` binary so a Mac GUI app
+ * launched from Dock/Finder (with a stripped PATH) can find it. Falls
+ * back to the bare `codegraph` name when:
+ *
+ *  - we're not on macOS (Linux GUI apps inherit user PATH; Windows
+ *    uses env PATH directly), OR
+ *  - the lookup fails for any reason (preserving install in restricted
+ *    environments where `which`/`command -v` aren't available).
+ *
+ * Resolution prefers `command -v` (built-in, no PATH manipulation),
+ * with `which` as a fallback. Both are read via the user's interactive
+ * shell PATH at install time — that's the right PATH for finding
+ * nvm-managed tools like ours.
+ */
+function resolveCodegraphCommand() {
+    if (process.platform !== 'darwin')
+        return 'codegraph';
+    try {
+        const resolved = (0, child_process_1.execSync)('command -v codegraph || which codegraph', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            shell: '/bin/bash',
+            windowsHide: true,
+        }).trim();
+        if (resolved && fs.existsSync(resolved))
+            return resolved;
+    }
+    catch {
+        /* fall through to bare name */
+    }
+    return 'codegraph';
+}
+/**
+ * Build the codegraph MCP-server entry for Antigravity. Distinct from
+ * `getMcpServerConfig()` because Antigravity (a) rejects the `type`
+ * field and (b) needs an absolute command path on macOS — see file
+ * header.
+ */
+function buildAntigravityEntry() {
+    return {
+        command: resolveCodegraphCommand(),
+        args: ['serve', '--mcp'],
+    };
+}
+class AntigravityTarget {
+    id = 'antigravity';
+    displayName = 'Antigravity IDE';
+    docsUrl = 'https://antigravity.google';
+    supportsLocation(loc) {
+        return loc === 'global';
+    }
+    detect(loc) {
+        if (loc !== 'global') {
+            return { installed: false, alreadyConfigured: false };
+        }
+        const file = preferredMcpConfigPath();
+        const config = (0, shared_1.readJsonFile)(file);
+        const alreadyConfigured = !!config.mcpServers?.codegraph;
+        // "Installed" heuristic: either the unified config dir, the legacy
+        // config dir, or one of the config files exists. Antigravity creates
+        // ~/.gemini/ on first launch even before MCP configs.
+        const installed = fs.existsSync(unifiedConfigDir()) ||
+            fs.existsSync(legacyConfigDir()) ||
+            fs.existsSync(file);
+        return { installed, alreadyConfigured, configPath: file };
+    }
+    install(loc, _opts) {
+        if (loc !== 'global') {
+            return {
+                files: [],
+                notes: ['Antigravity IDE has no project-local config — re-run with --location=global.'],
+            };
+        }
+        const files = [];
+        files.push(writeMcpEntry());
+        // If the user originally installed on the legacy path and Antigravity
+        // has since migrated, strip the stale legacy entry so they don't
+        // wind up with two competing codegraph configs.
+        const legacyCleanup = cleanupLegacyEntry();
+        if (legacyCleanup)
+            files.push(legacyCleanup);
+        return {
+            files,
+            notes: ['Restart Antigravity for MCP changes to take effect.'],
+        };
+    }
+    uninstall(loc) {
+        if (loc !== 'global')
+            return { files: [] };
+        const files = [];
+        // Remove from the preferred path.
+        const preferred = preferredMcpConfigPath();
+        files.push(removeCodegraphFromFile(preferred));
+        // Also sweep the OTHER path (legacy when preferred is unified, and
+        // vice versa) — handles the migration-half-state case where codegraph
+        // got written to one file but Antigravity now reads from the other.
+        const other = preferred === unifiedMcpConfigPath()
+            ? legacyMcpConfigPath()
+            : unifiedMcpConfigPath();
+        if (preferred !== other) {
+            const otherResult = removeCodegraphFromFile(other);
+            // Only surface the secondary file if we actually touched it —
+            // a `not-found` on a file the user never had is noise.
+            if (otherResult.action === 'removed')
+                files.push(otherResult);
+        }
+        return { files };
+    }
+    printConfig(loc) {
+        if (loc !== 'global') {
+            return '# Antigravity IDE has no project-local config — use --location=global.\n';
+        }
+        const file = preferredMcpConfigPath();
+        const snippet = JSON.stringify({ mcpServers: { codegraph: buildAntigravityEntry() } }, null, 2);
+        return `# Add to ${file}\n\n${snippet}\n`;
+    }
+    describePaths(loc) {
+        if (loc !== 'global')
+            return [];
+        return [preferredMcpConfigPath()];
+    }
+}
+function writeMcpEntry() {
+    const file = preferredMcpConfigPath();
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const existing = (0, shared_1.readJsonFile)(file);
+    const before = existing.mcpServers?.codegraph;
+    const after = buildAntigravityEntry();
+    if ((0, shared_1.jsonDeepEqual)(before, after)) {
+        return { path: file, action: 'unchanged' };
+    }
+    const action = before ? 'updated' : (fs.existsSync(file) ? 'updated' : 'created');
+    if (!existing.mcpServers)
+        existing.mcpServers = {};
+    existing.mcpServers.codegraph = after;
+    (0, shared_1.writeJsonFile)(file, existing);
+    return { path: file, action };
+}
+/**
+ * Strip the codegraph entry from the legacy `~/.gemini/antigravity/mcp_config.json`
+ * if it's present AND we're writing to the unified path. Used by install
+ * to migrate users who had codegraph configured on the legacy path
+ * before Antigravity migrated their config. Returns the file action for
+ * reporting, or `null` when there's nothing to clean up.
+ */
+function cleanupLegacyEntry() {
+    if (preferredMcpConfigPath() !== unifiedMcpConfigPath())
+        return null;
+    const legacy = legacyMcpConfigPath();
+    if (!fs.existsSync(legacy))
+        return null;
+    const config = (0, shared_1.readJsonFile)(legacy);
+    if (!config.mcpServers?.codegraph)
+        return null;
+    delete config.mcpServers.codegraph;
+    if (Object.keys(config.mcpServers).length === 0) {
+        delete config.mcpServers;
+    }
+    (0, shared_1.writeJsonFile)(legacy, config);
+    return { path: legacy, action: 'removed' };
+}
+function removeCodegraphFromFile(file) {
+    if (!fs.existsSync(file))
+        return { path: file, action: 'not-found' };
+    const config = (0, shared_1.readJsonFile)(file);
+    if (!config.mcpServers?.codegraph)
+        return { path: file, action: 'not-found' };
+    delete config.mcpServers.codegraph;
+    if (Object.keys(config.mcpServers).length === 0) {
+        delete config.mcpServers;
+    }
+    // Leave a now-empty `{}` in place — Antigravity manages this file and
+    // a stray empty file is less surprising than a deletion.
+    (0, shared_1.writeJsonFile)(file, config);
+    return { path: file, action: 'removed' };
+}
+exports.antigravityTarget = new AntigravityTarget();
+//# sourceMappingURL=antigravity.js.map

package/dist/installer/targets/antigravity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"antigravity.js","sourceRoot":"","sources":["../../../src/installer/targets/antigravity.ts"],"names":[],"mappings":"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"}

package/dist/installer/targets/claude.d.ts

@@ -16,7 +16,7 @@
  * now write `./.mcp.json` and migrate any stale `./.claude.json` entry
  * out of the way on install and uninstall.
  */
-import { AgentTarget, Location, WriteResult } from './types'
+import { AgentTarget, Location, WriteResult } from './types';
 /**
  * Per-file write helpers, exported so the legacy `config-writer.ts`
  * shim can call only the named operation (writeMcpConfig writes ONLY
@@ -24,32 +24,39 @@ import { AgentTarget, Location, WriteResult } from './types'
  * writes all three files. Without this split the shims silently
  * cause side effects callers don't expect.
  */
-export declare function writeMcpEntry(
-  loc: Location,
-): WriteResult['files'][number]
+export declare function writeMcpEntry(loc: Location): WriteResult['files'][number];
 /**
- * Remove stale codegraph auto-sync hooks from Claude `settings.json`.
- *
- * Surgical at the individual-command level: only entries matching
- * `isLegacyCodegraphHookCommand` are dropped, so a sibling hook sharing
- * a matcher group (or the Stop event) with ours survives. We prune a
- * matcher group only once its `hooks` array is empty, an event only
- * once it has no groups left, and `hooks` itself only once every event
- * is gone — and none of that runs unless we actually removed a
- * codegraph command, so a settings.json with no legacy hooks is left
- * byte-for-byte untouched and reported `unchanged`.
- *
- * Exported so it can be unit-tested directly and reused by both
+ * Remove stale codegraph auto-sync hooks (`mark-dirty` / `sync-if-dirty`) that a
+ * pre-0.8 install wrote. Exported for direct unit-testing; reused by both
  * `install` (an upgrade self-heals) and `uninstall`.
  */
-export declare function cleanupLegacyHooks(
-  loc: Location,
-): WriteResult['files'][number]
-export declare function writePermissionsEntry(
-  loc: Location,
-): WriteResult['files'][number]
-export declare function writeInstructionsEntry(
-  loc: Location,
-): WriteResult['files'][number]
-export declare const claudeTarget: AgentTarget
-//# sourceMappingURL=claude.d.ts.map
+export declare function cleanupLegacyHooks(loc: Location): WriteResult['files'][number];
+/**
+ * Remove the front-load `UserPromptSubmit` hook this installer writes (see
+ * writePromptHookEntry). Used by `uninstall`, and by `install` when the user
+ * opts out, so the choice round-trips.
+ */
+export declare function removePromptHookEntry(loc: Location): WriteResult['files'][number];
+export declare function writePermissionsEntry(loc: Location): WriteResult['files'][number];
+/**
+ * Write the front-load `UserPromptSubmit` hook into Claude `settings.json` —
+ * a `command` hook that runs `codegraph prompt-hook`, which injects
+ * codegraph_explore context for structural prompts so the agent reliably uses
+ * the graph. Idempotent: if our command is already wired under UserPromptSubmit
+ * the file is left byte-for-byte untouched and reported `unchanged`. Sibling
+ * hooks (the user's own, or other events) are preserved. Opt-in — the installer
+ * only calls this when the user accepts the prompt (default-yes).
+ */
+export declare function writePromptHookEntry(loc: Location): WriteResult['files'][number];
+/**
+ * Strip the marker-delimited CodeGraph block from CLAUDE.md if a prior
+ * install wrote one. Codegraph no longer maintains an instructions file
+ * (issue #529) — the MCP server's `initialize` instructions are the
+ * single source of truth — so both install (self-heal on upgrade) and
+ * uninstall call this. `removeMarkedSection` returns `not-found`/`kept`
+ * when there's nothing to strip; the install caller drops those from
+ * the report so a fresh install stays quiet.
+ */
+export declare function removeInstructionsEntry(loc: Location): WriteResult['files'][number];
+export declare const claudeTarget: AgentTarget;
+//# sourceMappingURL=claude.d.ts.map

package/dist/installer/targets/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../../src/installer/targets/claude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,EACL,WAAW,EAGX,QAAQ,EACR,WAAW,EACZ,MAAM,SAAS,CAAC;AAkMjB;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAsBzE;AAoHD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAEjF;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAoBjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAoBhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAInF;AAED,eAAO,MAAM,YAAY,EAAE,WAAoC,CAAC"}