gitnexus 1.6.6-rc.60 → 1.6.6-rc.61

package/README.md

@@ -2,7 +2,7 @@
 
 **Graph-powered code intelligence for AI agents.** Index any codebase into a knowledge graph, then query it via MCP or CLI.
 
-Works with **Cursor**, **Claude Code**, **Codex**, **Windsurf**, **Cline**, **OpenCode**, and any MCP-compatible tool.
+Works with **Cursor**, **Claude Code**, **Antigravity** (Google), **Codex**, **Windsurf**, **Cline**, **OpenCode**, and any MCP-compatible tool.
 
 [![npm version](https://img.shields.io/npm/v/gitnexus.svg)](https://www.npmjs.com/package/gitnexus)
 [![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg)](https://polyformproject.org/licenses/noncommercial/1.0.0/)
@@ -34,6 +34,7 @@ To configure MCP for your editor, run `npx gitnexus setup` once — or set it up
 |--------|-----|--------|---------------------|---------|
 | **Claude Code** | Yes | Yes | Yes (PreToolUse) | **Full** |
 | **Cursor** | Yes | Yes | Yes (postToolUse, [manual install](../gitnexus-cursor-integration/README.md#hook-install)) | **Full** |
+| **Antigravity** (Google) | Yes | Yes | Yes (AfterTool, [Gemini CLI hooks schema](https://geminicli.com/docs/hooks/reference/)) | **Full** |
 | **Codex** | Yes | Yes | — | MCP + Skills |
 | **Windsurf** | Yes | — | — | MCP |
 | **OpenCode** | Yes | Yes | — | MCP + Skills |

package/dist/cli/index.js

@@ -13,7 +13,7 @@ const program = new Command();
 program.name('gitnexus').description('GitNexus local CLI and MCP server').version(pkg.version);
 program
     .command('setup')
-    .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode, Codex')
+    .description('One-time setup: configure MCP for Cursor, Claude Code, Antigravity, OpenCode, Codex')
     .action(createLazyAction(() => import('./setup.js'), 'setupCommand'));
 program
     .command('analyze [path]')

package/dist/cli/setup.js

@@ -12,7 +12,6 @@ import { execFile, execFileSync } from 'child_process';
 import { createRequire } from 'module';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { glob } from 'glob';
 import { parseTree, modify, applyEdits, parse as parseJsonc } from 'jsonc-parser';
 import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -224,12 +223,12 @@ async function installClaudeCodeSkills(result) {
 /**
  * Check whether an event array already contains a gitnexus-hook entry.
  */
-function hasGitnexusHook(hooksObj, eventName) {
+function hasGitnexusHook(hooksObj, eventName, commandFragment = 'gitnexus-hook') {
     const entries = hooksObj?.[eventName];
     if (!Array.isArray(entries))
         return false;
     return entries.some((h) => Array.isArray(h.hooks) &&
-        h.hooks.some((hh) => typeof hh.command === 'string' && hh.command.includes('gitnexus-hook')));
+        h.hooks.some((hh) => typeof hh.command === 'string' && hh.command.includes(commandFragment)));
 }
 /**
  * Merge hook entries into a JSONC settings file, preserving comments and formatting.
@@ -397,6 +396,172 @@ async function installClaudeCodeHooks(result) {
         result.errors.push(`Claude Code hooks: ${err.message}`);
     }
 }
+// ─── Antigravity (Google) ──────────────────────────────────────────
+//
+// Antigravity stores its MCP config under ~/.gemini/antigravity/mcp_config.json
+// and inherits Gemini CLI's hooks contract
+// (https://geminicli.com/docs/hooks/reference/), which lives at
+// ~/.gemini/settings.json under the canonical `hooks.<EventName>` array layout.
+//
+// We register a single AfterTool entry matching Gemini's built-in search/shell
+// tools (search_file_content|glob|run_shell_command). BeforeTool is not used:
+// the Gemini contract provides no documented context-injection channel for it,
+// so augmentation runs in AfterTool where `hookSpecificOutput.additionalContext`
+// is appended to the tool result the agent reads. See the antigravity hook
+// adapter for the stdin/stdout contract details.
+async function setupAntigravity(result) {
+    const antigravityDir = path.join(os.homedir(), '.gemini', 'antigravity');
+    if (!(await dirExists(antigravityDir))) {
+        result.skipped.push('Antigravity (not installed)');
+        return;
+    }
+    const mcpPath = path.join(antigravityDir, 'mcp_config.json');
+    try {
+        const ok = await mergeJsoncFile(mcpPath, ['mcpServers', 'gitnexus'], getMcpEntry());
+        if (ok) {
+            result.configured.push('Antigravity');
+        }
+        else {
+            result.errors.push('Antigravity: mcp_config.json is corrupt — skipping to preserve existing content');
+        }
+    }
+    catch (err) {
+        result.errors.push(`Antigravity: ${err.message}`);
+    }
+}
+/**
+ * Install GitNexus skills to ~/.gemini/antigravity/skills/ (global scope,
+ * per https://codelabs.developers.google.com/getting-started-with-antigravity-skills).
+ * Each skill is laid out as {skillName}/SKILL.md just like the other editors.
+ */
+async function installAntigravitySkills(result) {
+    const antigravityDir = path.join(os.homedir(), '.gemini', 'antigravity');
+    if (!(await dirExists(antigravityDir)))
+        return;
+    const skillsDir = path.join(antigravityDir, 'skills');
+    try {
+        const installed = await installSkillsTo(skillsDir);
+        if (installed.length > 0) {
+            result.configured.push(`Antigravity skills (${installed.length} skills → ~/.gemini/antigravity/skills/)`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`Antigravity skills: ${err.message}`);
+    }
+}
+/**
+ * Install the Antigravity/Gemini-CLI hook adapter to
+ * ~/.gemini/config/hooks/gitnexus/ and register an AfterTool entry in
+ * ~/.gemini/settings.json under `hooks.AfterTool`.
+ *
+ * Why AfterTool (and not BeforeTool): the Gemini hooks reference
+ * (https://geminicli.com/docs/hooks/reference/) does not provide a context-
+ * injection channel for BeforeTool. AfterTool's
+ * `hookSpecificOutput.additionalContext` is the only documented way to
+ * append text the agent will read.
+ */
+async function installAntigravityHooks(result) {
+    const antigravityDir = path.join(os.homedir(), '.gemini', 'antigravity');
+    if (!(await dirExists(antigravityDir)))
+        return;
+    const geminiDir = path.join(os.homedir(), '.gemini');
+    const settingsPath = path.join(geminiDir, 'settings.json');
+    const destHooksDir = path.join(geminiDir, 'config', 'hooks', 'gitnexus');
+    // The antigravity adapter shares its lock/probe helpers with the claude
+    // adapter — same DB, same concurrency rules — so we reuse those CJS files
+    // from gitnexus/hooks/claude/ rather than duplicating them.
+    const pluginAntigravityDir = path.join(__dirname, '..', '..', 'hooks', 'antigravity');
+    const pluginClaudeDir = path.join(__dirname, '..', '..', 'hooks', 'claude');
+    try {
+        await fs.mkdir(destHooksDir, { recursive: true });
+        // Adapter script: rewrite the dist path baked into the file so it resolves
+        // to the installed gitnexus CLI rather than the cwd-relative dev path.
+        const adapterSrc = path.join(pluginAntigravityDir, 'gitnexus-antigravity-hook.cjs');
+        const adapterDest = path.join(destHooksDir, 'gitnexus-antigravity-hook.cjs');
+        try {
+            let content = await fs.readFile(adapterSrc, 'utf-8');
+            const resolvedCli = path.join(__dirname, '..', 'cli', 'index.js');
+            const normalizedCli = path.resolve(resolvedCli).replace(/\\/g, '/');
+            const jsonCli = JSON.stringify(normalizedCli);
+            content = content.replace("let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", `let cliPath = ${jsonCli};`);
+            await fs.writeFile(adapterDest, content, 'utf-8');
+        }
+        catch {
+            // Adapter not found in source — skip
+        }
+        // Bail out if the adapter was not written — registering the hook entry
+        // without the script would crash on every tool invocation (top-level
+        // require() of sibling helpers fails with MODULE_NOT_FOUND).
+        try {
+            await fs.access(adapterDest);
+        }
+        catch {
+            result.errors.push('Antigravity hooks: adapter script was not installed — skipping hook registration');
+            return;
+        }
+        // Shared helpers (copied from hooks/claude/). win-rm-list-json.ps1 is
+        // required by hook-db-lock-probe.cjs on Windows — without it, the MCP
+        // server ownership probe silently fails open and the hook may contend
+        // with the MCP server on the LadybugDB.
+        for (const helper of ['hook-lock.cjs', 'hook-db-lock-probe.cjs', 'win-rm-list-json.ps1']) {
+            try {
+                await fs.copyFile(path.join(pluginClaudeDir, helper), path.join(destHooksDir, helper));
+            }
+            catch {
+                result.errors.push(`Antigravity hooks: failed to copy ${helper} — hook may crash at runtime`);
+            }
+        }
+        const hookPath = path.join(destHooksDir, 'gitnexus-antigravity-hook.cjs').replace(/\\/g, '/');
+        const escapedHookPath = hookPath.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        const hookCmd = `node "${escapedHookPath}"`;
+        const parsed = await (async () => {
+            try {
+                const r = await fs.readFile(settingsPath, 'utf-8');
+                return parseJsonc(r);
+            }
+            catch {
+                return null;
+            }
+        })();
+        const hookEntries = [];
+        if (!hasGitnexusHook(parsed?.hooks, 'AfterTool', 'gitnexus-antigravity-hook')) {
+            // Matcher follows the Gemini CLI built-in tool naming (snake_case).
+            // search_file_content / glob cover content + filename search; run_shell_command
+            // catches rg/grep invocations and the git commit family for stale-index hints.
+            hookEntries.push({
+                eventName: 'AfterTool',
+                value: {
+                    matcher: 'search_file_content|glob|run_shell_command',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: hookCmd,
+                            name: 'gitnexus',
+                            // ms — Gemini CLI uses milliseconds (default 60000); Claude Code
+                            // uses seconds. 10000 ms = 10 s.
+                            timeout: 10000,
+                            description: 'GitNexus graph context + stale-index hints',
+                        },
+                    ],
+                },
+            });
+        }
+        if (hookEntries.length === 0) {
+            result.configured.push('Antigravity hooks (already configured)');
+            return;
+        }
+        const ok = await mergeHooksJsonc(settingsPath, hookEntries);
+        if (ok) {
+            result.configured.push('Antigravity hooks (AfterTool)');
+        }
+        else {
+            result.errors.push('Antigravity hooks: settings.json is corrupt — skipping to preserve existing content');
+        }
+    }
+    catch (err) {
+        result.errors.push(`Antigravity hooks: ${err.message}`);
+    }
+}
 async function setupOpenCode(result) {
     const opencodeDir = path.join(os.homedir(), '.config', 'opencode');
     if (!(await dirExists(opencodeDir))) {
@@ -484,14 +649,30 @@ async function setupCodex(result) {
  */
 async function installSkillsTo(targetDir) {
     const installed = [];
-    const skillsRoot = path.join(__dirname, '..', '..', 'skills');
+    // GITNEXUS_TEST_SKILLS_ROOT lets tests stage a fixture skills tree without
+    // depending on __dirname resolution under Vitest.
+    const skillsRoot = process.env.GITNEXUS_TEST_SKILLS_ROOT ?? path.join(__dirname, '..', '..', 'skills');
+    // Was glob('*.md') + glob('*/SKILL.md'); replaced with fs.readdir because
+    // glob v13's cwd handling did not match the fixture path on Windows runners
+    // (absolute temp paths containing the 8.3 short-name `RUNNER~1` returned
+    // zero matches). fs.readdir has no such path quirks.
     let flatFiles = [];
     let dirSkillFiles = [];
     try {
-        [flatFiles, dirSkillFiles] = await Promise.all([
-            glob('*.md', { cwd: skillsRoot }),
-            glob('*/SKILL.md', { cwd: skillsRoot }),
-        ]);
+        const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+        flatFiles = entries.filter((e) => e.isFile() && e.name.endsWith('.md')).map((e) => e.name);
+        const subdirSkillFiles = await Promise.all(entries
+            .filter((e) => e.isDirectory())
+            .map(async (e) => {
+            try {
+                await fs.access(path.join(skillsRoot, e.name, 'SKILL.md'));
+                return path.join(e.name, 'SKILL.md');
+            }
+            catch {
+                return null;
+            }
+        }));
+        dirSkillFiles = subdirSkillFiles.filter((p) => p !== null);
     }
     catch {
         return [];
@@ -616,11 +797,14 @@ export const setupCommand = async () => {
     // Detect and configure each editor's MCP
     await setupCursor(result);
     await setupClaudeCode(result);
+    await setupAntigravity(result);
     await setupOpenCode(result);
     await setupCodex(result);
     // Install global skills for platforms that support them
     await installClaudeCodeSkills(result);
     await installClaudeCodeHooks(result);
+    await installAntigravitySkills(result);
+    await installAntigravityHooks(result);
     await installCursorSkills(result);
     await installOpenCodeSkills(result);
     await installCodexSkills(result);

package/hooks/antigravity/gitnexus-antigravity-hook.cjs

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+/**
+ * GitNexus Antigravity / Gemini CLI Hook Adapter
+ *
+ * Bridges the Gemini CLI hooks contract (also used by Antigravity 2.0 — see
+ * https://geminicli.com/docs/hooks/reference/) to the same graph-aware
+ * augmentation / staleness signals the Claude Code hook provides.
+ *
+ * Schema differences from the Claude adapter:
+ *   - Events are BeforeTool / AfterTool (not PreToolUse / PostToolUse).
+ *   - Tool names are snake_case (run_shell_command, search_file_content, glob).
+ *   - BeforeTool cannot inject context — decision: "allow" provides no channel
+ *     to surface text to the agent. Augmentation therefore runs in AfterTool,
+ *     where `hookSpecificOutput.additionalContext` is appended to the tool
+ *     result the agent sees.
+ *   - Stale-index hints after git commit/merge/rebase/cherry-pick/pull are
+ *     surfaced via the same `additionalContext` channel (so the agent reads
+ *     them, not only the user) and mirrored to stderr for terminal users.
+ *   - Stdin uses `tool_name`, `tool_input`, and `tool_response`
+ *     (with `llmContent`, `returnDisplay`, optional `error`).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { acquireHookSlot } = require('./hook-lock.cjs');
+const { hasGitNexusDbLockedByGitNexusServer } = require('./hook-db-lock-probe.cjs');
+
+function readInput() {
+  try {
+    const data = fs.readFileSync(0, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+
+function isGlobalRegistryDir(candidate) {
+  if (fs.existsSync(path.join(candidate, 'meta.json'))) return false;
+  return (
+    fs.existsSync(path.join(candidate, 'registry.json')) ||
+    fs.existsSync(path.join(candidate, 'repos'))
+  );
+}
+
+function walkForGitNexusDir(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, '.gitnexus');
+    if (fs.existsSync(candidate)) {
+      if (!isGlobalRegistryDir(candidate)) return candidate;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function findCanonicalRepoRoot(cwd) {
+  try {
+    const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+      encoding: 'utf-8',
+      timeout: 2000,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    if (result.error || result.status !== 0) return null;
+    const commonDir = (result.stdout || '').trim();
+    if (!commonDir || !path.isAbsolute(commonDir)) return null;
+    return path.dirname(commonDir);
+  } catch {
+    return null;
+  }
+}
+
+function findGitNexusDir(startDir) {
+  const cwd = startDir || process.cwd();
+  const fromCwd = walkForGitNexusDir(cwd);
+  if (fromCwd) return fromCwd;
+  const canonicalRoot = findCanonicalRepoRoot(cwd);
+  if (canonicalRoot && canonicalRoot !== cwd) {
+    return walkForGitNexusDir(canonicalRoot);
+  }
+  return null;
+}
+
+function hasGitNexusServerOwner(gitNexusDir) {
+  return hasGitNexusDbLockedByGitNexusServer(path.join(gitNexusDir, 'lbug'), process.pid);
+}
+
+function extractAugmentContext(stderr) {
+  const output = (stderr || '').trim();
+  const marker = output.indexOf('[GitNexus]');
+  const debug = process.env.GITNEXUS_DEBUG === '1' || process.env.GITNEXUS_DEBUG === 'true';
+  if (debug && output.length > 0) {
+    // Emit the FULL discarded prefix (everything before the marker, or all of
+    // it when no marker is present) so suppressed diagnostics — LadybugDB lock
+    // warnings, parser errors, etc. — remain recoverable on the hook's own
+    // stderr. Mirrors the Claude adapter's debug behavior.
+    const discarded = marker === -1 ? output : output.slice(0, marker).trim();
+    if (discarded.length > 0) {
+      process.stderr.write(`[GitNexus hook] augment stderr discarded prefix:\n${discarded}\n`);
+    }
+  }
+  return marker === -1 ? '' : output.slice(marker).trim();
+}
+
+/**
+ * Extract a usable search token from a tool invocation.
+ *   - search_file_content / glob: top-level `pattern` (sometimes `query`).
+ *   - run_shell_command: parse rg/grep argv, returning the first non-flag
+ *     positional ≥ 3 chars.
+ * Returns null when the tool is not a recognized search or the pattern is
+ * too short.
+ */
+function extractPattern(toolName, toolInput) {
+  if (toolName === 'search_file_content') {
+    const q = toolInput.pattern || toolInput.query || '';
+    return typeof q === 'string' && q.length >= 3 ? q : null;
+  }
+
+  if (toolName === 'glob') {
+    const raw = toolInput.pattern || '';
+    const match = raw.match(/[*\/]([a-zA-Z][a-zA-Z0-9_-]{2,})/);
+    return match ? match[1] : null;
+  }
+
+  if (toolName === 'run_shell_command') {
+    const cmd = toolInput.command || '';
+    if (!/\brg\b|\bgrep\b/.test(cmd)) return null;
+
+    const tokens = cmd.split(/\s+/);
+    let foundCmd = false;
+    let skipNext = false;
+    const flagsWithValues = new Set([
+      '-e',
+      '-f',
+      '-m',
+      '-A',
+      '-B',
+      '-C',
+      '-g',
+      '--glob',
+      '-t',
+      '--type',
+      '--include',
+      '--exclude',
+    ]);
+
+    for (const token of tokens) {
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
+      if (!foundCmd) {
+        if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        if (flagsWithValues.has(token)) skipNext = true;
+        continue;
+      }
+      const cleaned = token.replace(/['"]/g, '');
+      return cleaned.length >= 3 ? cleaned : null;
+    }
+    return null;
+  }
+
+  return null;
+}
+
+function resolveCliPath() {
+  const fromEnv = process.env.GITNEXUS_HOOK_CLI_PATH;
+  if (fromEnv !== undefined && String(fromEnv).trim() && fs.existsSync(String(fromEnv))) {
+    return String(fromEnv);
+  }
+  let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');
+  if (!fs.existsSync(cliPath)) {
+    try {
+      cliPath = require.resolve('gitnexus/dist/cli/index.js');
+    } catch {
+      cliPath = '';
+    }
+  }
+  return cliPath;
+}
+
+function runGitNexusCli(cliPath, args, cwd, timeout) {
+  const isWin = process.platform === 'win32';
+  if (cliPath) {
+    return spawnSync(process.execPath, [cliPath, ...args], {
+      encoding: 'utf-8',
+      timeout,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+  }
+  return spawnSync(isWin ? 'npx.cmd' : 'npx', ['-y', 'gitnexus', ...args], {
+    encoding: 'utf-8',
+    timeout: timeout + 5000,
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+}
+
+function writeAdditionalContext(text) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'AfterTool',
+        additionalContext: text,
+      },
+    }),
+  );
+}
+
+function toolSucceeded(toolResponse) {
+  if (!toolResponse || typeof toolResponse !== 'object') return true;
+  if (toolResponse.error) return false;
+  if (toolResponse.exit_code != null && Number(toolResponse.exit_code) !== 0) return false;
+  return true;
+}
+
+/**
+ * Compute the additionalContext for a tool result, if any.
+ *   1. Graph augment for search-like tools (search_file_content, glob,
+ *      run_shell_command-with-rg/grep) that completed successfully.
+ *   2. Stale-index hint after a successful git commit/merge/rebase/cherry-
+ *      pick/pull.
+ * Returns null when nothing is to be appended.
+ */
+function buildAfterToolContext(input) {
+  const cwd = input.cwd || process.cwd();
+  if (!path.isAbsolute(cwd)) return null;
+  const gitNexusDir = findGitNexusDir(cwd);
+  if (!gitNexusDir) return null;
+
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+  const toolResponse = input.tool_response || {};
+  const parts = [];
+
+  if (toolSucceeded(toolResponse)) {
+    const pattern = extractPattern(toolName, toolInput);
+    if (pattern) {
+      const augmentText = runAugment(gitNexusDir, cwd, pattern);
+      if (augmentText) parts.push(augmentText);
+    }
+  }
+
+  if (toolName === 'run_shell_command' && toolSucceeded(toolResponse)) {
+    const command = toolInput.command || '';
+    if (/\bgit\s+(commit|merge|rebase|cherry-pick|pull)(\s|$)/.test(command)) {
+      const hint = buildStaleIndexHint(gitNexusDir, cwd);
+      if (hint) {
+        process.stderr.write(`${hint}\n`);
+        parts.push(hint);
+      }
+    }
+  }
+
+  return parts.length > 0 ? parts.join('\n\n') : null;
+}
+
+function runAugment(gitNexusDir, cwd, pattern) {
+  if (hasGitNexusServerOwner(gitNexusDir)) {
+    process.stderr.write('[GitNexus] augment skipped: MCP server owns DB\n');
+    return '';
+  }
+  const release = acquireHookSlot(gitNexusDir);
+  if (!release) return '';
+  const cliPath = resolveCliPath();
+  try {
+    const child = runGitNexusCli(cliPath, ['augment', '--', pattern], cwd, 7000);
+    if (!child.error && child.status === 0) {
+      return extractAugmentContext(child.stderr || '');
+    }
+  } catch {
+    /* graceful failure */
+  } finally {
+    release();
+  }
+  return '';
+}
+
+function buildStaleIndexHint(gitNexusDir, cwd) {
+  let currentHead = '';
+  try {
+    const headResult = spawnSync('git', ['rev-parse', 'HEAD'], {
+      encoding: 'utf-8',
+      timeout: 3000,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    currentHead = (headResult.stdout || '').trim();
+  } catch {
+    return '';
+  }
+  if (!currentHead) return '';
+
+  let lastCommit = '';
+  let hadEmbeddings = false;
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8'));
+    lastCommit = meta.lastCommit || '';
+    hadEmbeddings = meta.stats && meta.stats.embeddings > 0;
+  } catch {
+    /* no meta — treat as stale */
+  }
+
+  if (currentHead === lastCommit) return '';
+
+  const analyzeCmd = `npx gitnexus analyze${hadEmbeddings ? ' --embeddings' : ''}`;
+  return (
+    `[GitNexus] index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` +
+    `Run \`${analyzeCmd}\` to refresh the knowledge graph.`
+  );
+}
+
+function handleAfterTool(input) {
+  const context = buildAfterToolContext(input);
+  if (context) writeAdditionalContext(context);
+}
+
+const handlers = {
+  AfterTool: handleAfterTool,
+};
+
+function main() {
+  try {
+    const input = readInput();
+    const handler = handlers[input.hook_event_name || ''];
+    if (handler) handler(input);
+  } catch (err) {
+    if (process.env.GITNEXUS_DEBUG) {
+      console.error('GitNexus antigravity hook error:', (err.message || '').slice(0, 200));
+    }
+  }
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.60",
+  "version": "1.6.6-rc.61",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -29,6 +29,7 @@ const PLATFORM_LOGIC = [
   'test/unit/setup.test.ts',
   'test/unit/setup-jsonc.test.ts',
   'test/unit/setup-codex.test.ts',
+  'test/unit/setup-antigravity.test.ts',
   'test/unit/platform-capabilities.test.ts',
   'test/unit/worker-pool-windows-quarantine.test.ts',
   'test/unit/lbug-pool-win-fts-probe.test.ts',
@@ -79,6 +80,8 @@ const SPAWN_CLI = [
   'test/integration/group/group-cli.test.ts',
   'test/integration/cli/tool-no-index-stderr.test.ts',
   'test/integration/setup-skills.test.ts',
+  'test/integration/setup-antigravity.test.ts',
+  'test/integration/antigravity-hook-e2e.test.ts',
   'test/unit/local-cli-subprocess.test.ts',
 ];