#1 Persistent memory for AI coding agents based on real-world benchmarks
TypeScript agentmemoryagentsaiclaudeclaudecodecodexcopilotcursorgenaiharnesshermesmemoryompopenclawopencodepi
feat(cli): native hooks adapter for Antigravity CLI (agy) (#1146)
Bertho Jorisd60652a70587
diff --git a/README.md b/README.mdindex 332e2010..eb6bd1fa 100644--- a/README.md+++ b/README.md@@ -672,6 +672,7 @@ The agentmemory entry is the **same MCP server block** across every host that us| **Hermes Agent** | `~/.hermes/config.yaml` | Use the deeper [memory provider plugin](integrations/hermes/) with `memory.provider: agentmemory`. || **Qwen Code** | `~/.qwen/settings.json` | `agentmemory connect qwen` writes the standard `mcpServers` block. Hook payload is field-compatible with Claude Code, so the existing 12-hook scripts work without modification — wire them via the `hooks` section in the same `settings.json`. || **Antigravity** (replaces Gemini CLI) | `mcp_config.json` (in Antigravity's User dir) | `agentmemory connect antigravity` writes the standard `mcpServers` block. macOS: `~/Library/Application Support/Antigravity/User/`. Linux: `~/.config/Antigravity/User/`. Use after the 2026-06-18 Gemini CLI sunset. |+| **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity-cli` — the `agy` CLI keeps its own config under `~/.gemini/`, separate from the Antigravity IDE above. Pass `--with-hooks` for native auto-capture via `~/.gemini/config/hooks.json`. || **Kiro** | `~/.kiro/settings/mcp.json` | `agentmemory connect kiro` writes the user-level config. Workspace overrides go in `.kiro/settings/mcp.json` next to your code. || **Warp** | `~/.warp/.mcp.json` | `agentmemory connect warp` writes the standard `mcpServers` block. Warp also auto-discovers skills from `.claude/skills/` — once the Claude Code plugin is installed the 8 agentmemory skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `commit-context`, `commit-history`, `session-history`) appear natively in Warp's slash-command palette. || **Cline (CLI)** | `~/.cline/mcp.json` | `agentmemory connect cline` writes the standard `mcpServers` block. VS Code extension users: paste the same block via Cline Settings → MCP Servers → Edit JSON. |diff --git a/plugin/hooks/hooks.antigravity.json b/plugin/hooks/hooks.antigravity.jsonnew file mode 100644index 00000000..e3152b7a--- /dev/null+++ b/plugin/hooks/hooks.antigravity.json@@ -0,0 +1,43 @@+{+ "agentmemory": {+ "enabled": true,+ "PreInvocation": [+ {+ "type": "command",+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PreInvocation",+ "timeout": 10+ }+ ],+ "PreToolUse": [+ {+ "matcher": "view_file|view_code_item|read_file|edit_file|replace_file_content|write_to_file|create_file|grep_search|codebase_search|find_by_name|list_dir",+ "hooks": [+ {+ "type": "command",+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PreToolUse",+ "timeout": 10+ }+ ]+ }+ ],+ "PostToolUse": [+ {+ "matcher": "",+ "hooks": [+ {+ "type": "command",+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs PostToolUse",+ "timeout": 10+ }+ ]+ }+ ],+ "Stop": [+ {+ "type": "command",+ "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/antigravity-bridge.mjs Stop",+ "timeout": 10+ }+ ]+ }+}diff --git a/plugin/scripts/antigravity-bridge.mjs b/plugin/scripts/antigravity-bridge.mjsnew file mode 100644index 00000000..12d72ba9--- /dev/null+++ b/plugin/scripts/antigravity-bridge.mjs@@ -0,0 +1,114 @@+#!/usr/bin/env node+import { spawnSync } from "node:child_process";+import { dirname, join, resolve } from "node:path";+import { fileURLToPath } from "node:url";+//#region src/hooks/antigravity-bridge.ts+const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));+const TOOL_NAME_MAP = {+ view_file: "read",+ view_line_range: "read",+ view_code_item: "read",+ read_file: "read",+ read_url_content: "read",+ edit_file: "edit",+ replace_file_content: "edit",+ propose_code: "edit",+ write_to_file: "write",+ create_file: "write",+ grep_search: "grep",+ codebase_search: "grep",+ find_by_name: "glob",+ list_dir: "glob"+};+const ARG_KEY_MAP = {+ AbsolutePath: "file_path",+ TargetFile: "file_path",+ DirectoryPath: "path",+ SearchDirectory: "path",+ Pattern: "pattern",+ Query: "pattern",+ CommandLine: "command"+};+function asObject(value) {+ return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;+}+function firstString(...values) {+ for (const v of values) if (typeof v === "string" && v.length > 0) return v;+}+function normalizeToolArgs(args) {+ if (!args) return {};+ const out = { ...args };+ for (const [from, to] of Object.entries(ARG_KEY_MAP)) if (out[to] === void 0 && args[from] !== void 0) out[to] = args[from];+ return out;+}+function normalizePayload(event, raw) {+ const toolCall = asObject(raw["toolCall"]);+ const workspacePaths = Array.isArray(raw["workspacePaths"]) ? raw["workspacePaths"] : [];+ const sessionId = firstString(raw["conversationId"], raw["session_id"], raw["sessionId"]) ?? "unknown";+ const cwd = firstString(raw["cwd"], workspacePaths[0]) ?? process.cwd();+ const out = {+ ...raw,+ session_id: sessionId,+ cwd,+ hook_event_name: event+ };+ const transcriptPath = firstString(raw["transcript_path"], raw["transcriptPath"]);+ if (transcriptPath) out["transcript_path"] = transcriptPath;+ if (toolCall) {+ const args = normalizeToolArgs(asObject(toolCall["args"]) ?? asObject(toolCall["toolArgs"]));+ const rawName = firstString(toolCall["name"], toolCall["toolName"], args["ToolName"], args["toolName"]);+ if (rawName) {+ out["tool_name"] = TOOL_NAME_MAP[rawName] ?? rawName;+ out["native_tool_name"] = rawName;+ }+ out["tool_input"] = args;+ const result = toolCall["result"] ?? raw["toolResult"] ?? raw["result"];+ if (result !== void 0) out["tool_result"] = result;+ }+ return out;+}+function targetsFor(event, raw) {+ switch (event) {+ case "PreInvocation": {+ const n = raw["invocationNum"];+ return typeof n !== "number" || n <= 1 ? ["session-start.mjs", "prompt-submit.mjs"] : ["prompt-submit.mjs"];+ }+ case "PreToolUse": return ["pre-tool-use.mjs"];+ case "PostToolUse": return ["post-tool-use.mjs"];+ case "Stop": return ["stop.mjs", "session-end.mjs"];+ default: return [];+ }+}+function responseFor(event) {+ return event === "PreToolUse" ? "{\"decision\":\"allow\"}" : "{}";+}+async function main() {+ const event = process.argv[2];+ if (!event) return;+ let input = "";+ for await (const chunk of process.stdin) input += chunk;+ let raw;+ try {+ raw = JSON.parse(input);+ } catch {+ return;+ }+ if (!raw || typeof raw !== "object") return;+ const payload = JSON.stringify(normalizePayload(event, raw));+ for (const script of targetsFor(event, raw)) spawnSync(process.execPath, [join(SCRIPTS_DIR, script)], {+ input: payload,+ stdio: [+ "pipe",+ "ignore",+ "ignore"+ ]+ });+}+if (process.argv[1] !== void 0 && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main().catch(() => {}).finally(() => {+ process.stdout.write(responseFor(process.argv[2] ?? ""));+ process.exit(0);+});+//#endregion+export { normalizePayload, responseFor, targetsFor };++//# sourceMappingURL=antigravity-bridge.mjs.map\ No newline at end of filediff --git a/plugin/skills/agentmemory-agents/REFERENCE.md b/plugin/skills/agentmemory-agents/REFERENCE.mdindex a0ec69ca..8943cfa4 100644--- a/plugin/skills/agentmemory-agents/REFERENCE.md+++ b/plugin/skills/agentmemory-agents/REFERENCE.md@@ -3,11 +3,12 @@Generated from `src/cli/connect/index.ts`. Do not edit the block below by hand; run `npm run skills:gen` after adding or removing an adapter.<!-- AUTOGEN:agents START - generated by scripts/skills/generate.ts, do not edit by hand -->-`agentmemory connect <agent>` wires the memory server into a host agent. 18 adapters:+`agentmemory connect <agent>` wires the memory server into a host agent. 19 adapters:| Agent | Name | Protocol || --- | --- | --- || Antigravity | `antigravity` | Using MCP via mcp_config.json. Antigravity replaces Gemini CLI (sunset 2026-06-18). |+| Antigravity CLI (agy) | `antigravity-cli` | Using MCP via ~/.gemini/config/mcp_config.json (the agy CLI, not the Antigravity IDE, that one is `connect antigravity`). The `/mcp` slash command inside agy lists configured servers. Pass --with-hooks to also install the native ~/.gemini/config/hooks.json auto-capture hooks. || Claude Code | `claude-code` | Using MCP. Hooks are also available, see https://github.com/rohitg00/agentmemory#claude-code-one-block-paste-it. || Cline | `cline` | Using MCP via ~/.cline/mcp.json (CLI). VS Code users: add the same block via Cline Settings → MCP Servers → Edit JSON. || Codex CLI | `codex` | Using MCP. Hooks ship via the Codex plugin; on Codex Desktop, also pass --with-hooks to install the global hooks.json workaround for openai/codex#16430. |diff --git a/plugin/skills/agentmemory-rest-api/REFERENCE.md b/plugin/skills/agentmemory-rest-api/REFERENCE.mdindex d12ff461..b92e35a9 100644--- a/plugin/skills/agentmemory-rest-api/REFERENCE.md+++ b/plugin/skills/agentmemory-rest-api/REFERENCE.md@@ -5,7 +5,7 @@ Generated from `src/triggers/api.ts`. Do not edit the block below by hand; run `<!-- AUTOGEN:rest START - generated by scripts/skills/generate.ts, do not edit by hand -->The REST API is the primary surface. All paths are under `http://localhost:3111` (override with `--port`). When `AGENTMEMORY_SECRET` is set, send `Authorization: Bearer $AGENTMEMORY_SECRET`; localhost is otherwise open.-118 registered endpoints:+119 registered endpoints:| Method | Path || --- | --- |diff --git a/src/cli/connect/antigravity-cli.ts b/src/cli/connect/antigravity-cli.tsnew file mode 100644index 00000000..af64870f--- /dev/null+++ b/src/cli/connect/antigravity-cli.ts@@ -0,0 +1,97 @@+import { existsSync, mkdirSync } from "node:fs";+import { homedir } from "node:os";+import { join } from "node:path";+import * as p from "@clack/prompts";+import { createJsonMcpAdapter } from "./json-mcp-adapter.js";+import type { ConnectOptions, ConnectResult } from "./types.js";+import {+ buildMergedAntigravityHooks,+ containsSpaces,+ type AntigravityHookManifest,+} from "./antigravity-hooks.js";+import { findPluginRoot } from "./codex-hooks.js";+import {+ backupFile,+ logBackup,+ logInstalled,+ readJsonSafe,+ writeJsonAtomic,+} from "./util.js";++// The `agy` CLI shares no configuration with the Antigravity IDE that+// `antigravity.ts` wires — it reads MCP from ~/.gemini/config/mcp_config.json+// and hooks from ~/.gemini/config/hooks.json (per-workspace overrides in+// <repo>/.agents/hooks.json). Detection keys off ~/.gemini/antigravity-cli/,+// which only the CLI creates; ~/.gemini/ alone would also match Gemini CLI.+// Sources: antigravity.google/docs/hooks, antigravity.google/docs/cli/using+const GEMINI_DIR = join(homedir(), ".gemini");+const ANTIGRAVITY_CLI_DIR = join(GEMINI_DIR, "antigravity-cli");+const CUSTOMIZATION_DIR = join(GEMINI_DIR, "config");+const ANTIGRAVITY_CLI_HOOKS = join(CUSTOMIZATION_DIR, "hooks.json");++export const adapter = createJsonMcpAdapter({+ name: "antigravity-cli",+ displayName: "Antigravity CLI (agy)",+ detectDir: ANTIGRAVITY_CLI_DIR,+ configPath: join(CUSTOMIZATION_DIR, "mcp_config.json"),+ docs: "https://github.com/rohitg00/agentmemory#other-agents",+ protocolNote:+ "→ Using MCP via ~/.gemini/config/mcp_config.json (the agy CLI, not the Antigravity IDE — that one is `connect antigravity`). The `/mcp` slash command inside agy lists configured servers. Pass --with-hooks to also install the native ~/.gemini/config/hooks.json auto-capture hooks.",+ installHooks: installAntigravityCliHooks,+});++/**+ * Merge the bundled `plugin/hooks/hooks.antigravity.json` into+ * `~/.gemini/config/hooks.json`, replacing only the bundle agentmemory owns.+ */+function installAntigravityCliHooks(opts: ConnectOptions): ConnectResult {+ let pluginRoot: string;+ try {+ pluginRoot = findPluginRoot();+ } catch (err) {+ return {+ kind: "skipped",+ reason: err instanceof Error ? err.message : String(err),+ };+ }++ // agy honours no quoting, so a space in the path yields hooks that load+ // but never run. Refuse rather than install something that can only fail.+ if (containsSpaces(pluginRoot)) {+ return {+ kind: "skipped",+ reason: `Antigravity CLI cannot run hook commands whose path contains spaces, and agentmemory is installed at ${pluginRoot}. Reinstall it under a space-free path to use --with-hooks; MCP works either way.`,+ };+ }++ const existing = readJsonSafe<AntigravityHookManifest>(ANTIGRAVITY_CLI_HOOKS);+ const merged = buildMergedAntigravityHooks(existing, pluginRoot);++ if (opts.dryRun) {+ p.log.info(+ `[dry-run] Would ${existing ? "merge" : "create"} ${ANTIGRAVITY_CLI_HOOKS} with ${Object.keys(merged).length} hook bundle(s)`,+ );+ return { kind: "installed", mutatedPath: ANTIGRAVITY_CLI_HOOKS };+ }++ let backupPath: string | undefined;+ if (existsSync(ANTIGRAVITY_CLI_HOOKS)) {+ backupPath = backupFile(ANTIGRAVITY_CLI_HOOKS, "antigravity-cli-hooks", "json");+ logBackup(backupPath);+ } else {+ mkdirSync(CUSTOMIZATION_DIR, { recursive: true });+ }++ writeJsonAtomic(ANTIGRAVITY_CLI_HOOKS, merged);++ logInstalled("Antigravity CLI hooks", ANTIGRAVITY_CLI_HOOKS);+ p.log.info(+ "User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect antigravity-cli --with-hooks` after upgrading agentmemory to refresh them.",+ );++ return {+ kind: "installed",+ mutatedPath: ANTIGRAVITY_CLI_HOOKS,+ ...(backupPath !== undefined && { backupPath }),+ };+}diff --git a/src/cli/connect/antigravity-hooks.ts b/src/cli/connect/antigravity-hooks.tsnew file mode 100644index 00000000..b3b11297--- /dev/null+++ b/src/cli/connect/antigravity-hooks.ts@@ -0,0 +1,163 @@+import { readFileSync } from "node:fs";+import { join } from "node:path";++/**+ * Merge engine for Antigravity CLI's `hooks.json`.+ *+ * Antigravity does not use the `{ hooks: { <Event>: [...] } }` envelope+ * that `codex-hooks.ts` handles for Claude Code, Codex and Droid. Its file+ * is a map of *named* hook bundles at the root:+ *+ * {+ * "<hook-name>": {+ * "enabled": true,+ * "PreToolUse": [ { "matcher": "…", "hooks": [ { type, command, timeout } ] } ],+ * "Stop": [ { type, command, timeout } ]+ * }+ * }+ *+ * The two shapes are not a typo: tool events take the `{ matcher, hooks }`+ * wrapper, lifecycle events a flat handler list. Wrapping a lifecycle event+ * makes agy read the wrapper as a handler and reject the *whole file*+ * (`command hook must specify 'command'`), disabling every other bundle in+ * it too.+ *+ * Named bundles make the merge simpler than the Codex one: agentmemory owns+ * exactly the top-level keys whose commands point under+ * `<pluginRoot>/scripts/`, so a re-install drops those wholesale and re-adds+ * a fresh bundle, preserving user keys and their order.+ *+ * `${CLAUDE_PLUGIN_ROOT}` is resolved at install time — agy expands no env+ * vars and requires absolute paths. The resolved path must also be bare and+ * space-free: agy runs no shell and strips no quotes, so `node "<root>/…"`+ * looks for a module whose name starts with a quote, and a space truncates+ * the argument with no escaping form that works.+ *+ * Behaviour above verified against agy 1.0.15.+ * Source: antigravity.google/docs/hooks+ */++type HookHandler = { type: string; command: string; timeout?: number };+type HookEntry = { matcher?: string; hooks: HookHandler[] };+export type NamedHook = { enabled?: boolean } & Record<+ string,+ boolean | HookEntry[] | HookHandler[] | undefined+>;+export type AntigravityHookManifest = Record<string, NamedHook>;++/** Tool events: `[ { matcher, hooks: [...] } ]`. */+const TOOL_EVENT_KEYS = new Set(["PreToolUse", "PostToolUse"]);++/** Lifecycle events: a flat `[ { type, command } ]` handler list. */+const LIFECYCLE_EVENT_KEYS = new Set([+ "PreInvocation",+ "PostInvocation",+ "Stop",+]);++/** Events Antigravity dispatches. Anything else in a bundle is metadata. */+const EVENT_KEYS = new Set([...TOOL_EVENT_KEYS, ...LIFECYCLE_EVENT_KEYS]);++export function buildMergedAntigravityHooks(+ existing: AntigravityHookManifest | null,+ pluginRoot: string,+ manifestFile = "hooks.antigravity.json",+): AntigravityHookManifest {+ const ours = JSON.parse(+ readFileSync(join(pluginRoot, "hooks", manifestFile), "utf-8"),+ ) as AntigravityHookManifest;+ const scriptsDir = join(pluginRoot, "scripts");++ const out: AntigravityHookManifest = {};++ for (const [name, bundle] of Object.entries(existing ?? {})) {+ if (isAgentmemoryBundle(bundle, scriptsDir)) continue;+ out[name] = bundle;+ }++ for (const [name, bundle] of Object.entries(ours)) {+ out[name] = resolveBundle(bundle, pluginRoot);+ }++ return out;+}++/** True when `pluginRoot` cannot be expressed in an Antigravity `command`. */+export function containsSpaces(pluginRoot: string): boolean {+ return /\s/.test(pluginRoot);+}++/**+ * Every handler in a bundle, across both event shapes: an entry that carries+ * no `hooks` array is itself the handler.+ */+function allHandlers(bundle: NamedHook): HookHandler[] {+ const out: HookHandler[] = [];+ for (const [key, value] of Object.entries(bundle)) {+ if (!EVENT_KEYS.has(key) || !Array.isArray(value)) continue;+ for (const entry of value as (HookEntry | HookHandler)[]) {+ if (!entry || typeof entry !== "object") continue;+ const nested = (entry as HookEntry).hooks;+ if (Array.isArray(nested)) out.push(...nested);+ else out.push(entry as HookHandler);+ }+ }+ return out;+}++function isAgentmemoryBundle(bundle: unknown, scriptsDir: string): boolean {+ if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) {+ return false;+ }+ const normalizedScriptsDir = normalizePathForCommandMatch(scriptsDir);+ return allHandlers(bundle as NamedHook).some((handler) =>+ normalizePathForCommandMatch(handler?.command ?? "").includes(+ normalizedScriptsDir,+ ),+ );+}++function resolveBundle(bundle: NamedHook, pluginRoot: string): NamedHook {+ const out: NamedHook = {};+ for (const [key, value] of Object.entries(bundle)) {+ if (!EVENT_KEYS.has(key) || !Array.isArray(value)) {+ out[key] = value as boolean;+ continue;+ }+ if (LIFECYCLE_EVENT_KEYS.has(key)) {+ out[key] = (value as HookHandler[]).map((handler) =>+ resolveHandler(handler, pluginRoot),+ );+ continue;+ }+ out[key] = (value as HookEntry[]).map((entry) => {+ const next: HookEntry = {+ hooks: entry.hooks.map((handler) => resolveHandler(handler, pluginRoot)),+ };+ if (entry.matcher !== undefined) next.matcher = entry.matcher;+ return next;+ });+ }+ return out;+}++function resolveHandler(+ handler: HookHandler,+ pluginRoot: string,+): HookHandler {+ return {+ type: handler.type,+ // Replacer function, not a string: a plugin path containing `$$`, `$&`,+ // "$`" or `$'` would otherwise be read as a replacement pattern and+ // silently mangle the installed command.+ command: handler.command.replace(+ /\$\{CLAUDE_PLUGIN_ROOT\}/g,+ () => pluginRoot,+ ),+ ...(handler.timeout !== undefined && { timeout: handler.timeout }),+ };+}++function normalizePathForCommandMatch(value: string): string {+ return value.replace(/\\/g, "/");+}diff --git a/src/cli/connect/guidelines.ts b/src/cli/connect/guidelines.tsindex d1b95593..26770b6a 100644--- a/src/cli/connect/guidelines.ts+++ b/src/cli/connect/guidelines.ts@@ -120,6 +120,14 @@ export function guidelineTargets(scope: "global",source: "https://antigravity.google/docs/rules-workflows",},+ // The agy CLI reads the same ~/.gemini/GEMINI.md as the IDE.+ "antigravity-cli": {+ globalPath: join(home, ".gemini", "GEMINI.md"),+ projectPath: join(".agents", "rules", "agentmemory.md"),+ format: "block",+ scope: "global",+ source: "https://antigravity.google/docs/rules-workflows",+ },"copilot-cli": {globalPath: join(home, ".copilot", "copilot-instructions.md"),projectPath: join(".github", "copilot-instructions.md"),diff --git a/src/cli/connect/index.ts b/src/cli/connect/index.tsindex 0014e7d4..a0256c7a 100644--- a/src/cli/connect/index.ts+++ b/src/cli/connect/index.ts@@ -4,6 +4,7 @@ import pc from "picocolors";import type { ConnectAdapter, ConnectOptions, ConnectResult } from "./types.js";import { writeGuideline } from "./guidelines.js";import { adapter as antigravity } from "./antigravity.js";+import { adapter as antigravityCli } from "./antigravity-cli.js";import { adapter as claudeCode } from "./claude-code.js";import { adapter as cline } from "./cline.js";import { adapter as copilotCli } from "./copilot-cli.js";@@ -30,6 +31,7 @@ export const ADAPTERS: readonly ConnectAdapter[] = [geminiCli,qwen,antigravity,+ antigravityCli,kiro,warp,cline,diff --git a/src/hooks/antigravity-bridge.ts b/src/hooks/antigravity-bridge.tsnew file mode 100644index 00000000..60e65bac--- /dev/null+++ b/src/hooks/antigravity-bridge.ts@@ -0,0 +1,210 @@+#!/usr/bin/env node+import { spawnSync } from "node:child_process";+import { dirname, join, resolve } from "node:path";+import { fileURLToPath } from "node:url";++// Antigravity CLI (`agy`) bridge — sits in front of the canonical hooks+// because three parts of agy's contract make them unusable as direct+// `command` targets: only five events exist (no SessionStart/SessionEnd/+// UserPromptSubmit, so the lifecycle is synthesized from PreInvocation and+// Stop); the payload is camelCase and nests tool calls under `toolCall`; and+// stdout must be a JSON object, which `pre-tool-use.mjs` breaks when+// AGENTMEMORY_INJECT_CONTEXT=true makes it write raw context text.+//+// Invoked as: node antigravity-bridge.mjs <PreInvocation|PreToolUse|PostToolUse|Stop>+// Sources: antigravity.google/docs/hooks, antigravity.google/docs/cli/using++const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));++// Antigravity inherits Cascade-style tool names. Map them onto the tool+// vocabulary pre-tool-use.ts / post-tool-use.ts already understand so the+// existing file-activity heuristics keep working unchanged.+const TOOL_NAME_MAP: Record<string, string> = {+ view_file: "read",+ view_line_range: "read",+ view_code_item: "read",+ read_file: "read",+ read_url_content: "read",+ edit_file: "edit",+ replace_file_content: "edit",+ propose_code: "edit",+ write_to_file: "write",+ create_file: "write",+ grep_search: "grep",+ codebase_search: "grep",+ find_by_name: "glob",+ list_dir: "glob",+};++// Antigravity tool args are PascalCase; the canonical hooks look for+// snake_case keys. Only the keys those hooks actually read are mapped.+const ARG_KEY_MAP: Record<string, string> = {+ AbsolutePath: "file_path",+ TargetFile: "file_path",+ DirectoryPath: "path",+ SearchDirectory: "path",+ Pattern: "pattern",+ Query: "pattern",+ CommandLine: "command",+};++type Json = Record<string, unknown>;++function asObject(value: unknown): Json | undefined {+ return typeof value === "object" && value !== null && !Array.isArray(value)+ ? (value as Json)+ : undefined;+}++function firstString(...values: unknown[]): string | undefined {+ for (const v of values) {+ if (typeof v === "string" && v.length > 0) return v;+ }+ return undefined;+}++function normalizeToolArgs(args: Json | undefined): Json {+ if (!args) return {};+ const out: Json = { ...args };+ for (const [from, to] of Object.entries(ARG_KEY_MAP)) {+ if (out[to] === undefined && args[from] !== undefined) out[to] = args[from];+ }+ return out;+}++// Translate one Antigravity hook payload into the flat, snake_case shape the+// bundled hooks consume. Unknown fields pass through so future Antigravity+// additions stay visible to the capture pipeline.+export function normalizePayload(event: string, raw: Json): Json {+ const toolCall = asObject(raw["toolCall"]);+ const workspacePaths = Array.isArray(raw["workspacePaths"])+ ? (raw["workspacePaths"] as unknown[])+ : [];++ const sessionId =+ firstString(raw["conversationId"], raw["session_id"], raw["sessionId"]) ??+ "unknown";+ const cwd =+ firstString(raw["cwd"], workspacePaths[0]) ?? process.cwd();++ const out: Json = {+ ...raw,+ session_id: sessionId,+ cwd,+ hook_event_name: event,+ };++ const transcriptPath = firstString(+ raw["transcript_path"],+ raw["transcriptPath"],+ );+ if (transcriptPath) out["transcript_path"] = transcriptPath;++ if (toolCall) {+ const args = normalizeToolArgs(+ asObject(toolCall["args"]) ?? asObject(toolCall["toolArgs"]),+ );+ const rawName = firstString(+ toolCall["name"],+ toolCall["toolName"],+ args["ToolName"],+ args["toolName"],+ );+ if (rawName) {+ out["tool_name"] = TOOL_NAME_MAP[rawName] ?? rawName;+ // Keep the host-native name so captured observations stay traceable+ // back to the tool Antigravity actually ran.+ out["native_tool_name"] = rawName;+ }+ out["tool_input"] = args;+ const result = toolCall["result"] ?? raw["toolResult"] ?? raw["result"];+ if (result !== undefined) out["tool_result"] = result;+ }++ return out;+}++// Map an Antigravity event to the bundled scripts it should drive.+// PreInvocation stands in for both SessionStart and UserPromptSubmit: the+// first invocation of a conversation opens the session, every later one is a+// fresh user turn. PostInvocation is deliberately unmapped — PostToolUse+// already captures the work, and firing again would double-record it.+export function targetsFor(event: string, raw: Json): string[] {+ switch (event) {+ case "PreInvocation": {+ const n = raw["invocationNum"];+ const isFirst = typeof n !== "number" || n <= 1;+ return isFirst+ ? ["session-start.mjs", "prompt-submit.mjs"]+ : ["prompt-submit.mjs"];+ }+ case "PreToolUse":+ return ["pre-tool-use.mjs"];+ case "PostToolUse":+ return ["post-tool-use.mjs"];+ case "Stop":+ return ["stop.mjs", "session-end.mjs"];+ default:+ return [];+ }+}++// The stdout contract, per event. agy treats a PreToolUse response without+// `decision` as a denial, so a bare `{}` there makes it refuse every matched+// tool call (verified on 1.0.15). No other event carries a permission+// decision, so they stay on `{}` — sending one would override user settings.+export function responseFor(event: string): string {+ return event === "PreToolUse" ? '{"decision":"allow"}' : "{}";+}++async function main() {+ const event = process.argv[2];+ if (!event) return;++ let input = "";+ for await (const chunk of process.stdin) {+ input += chunk;+ }++ let raw: Json;+ try {+ raw = JSON.parse(input) as Json;+ } catch {+ return;+ }+ if (!raw || typeof raw !== "object") return;++ const payload = JSON.stringify(normalizePayload(event, raw));++ for (const script of targetsFor(event, raw)) {+ // Synchronous so the hook process does not exit before the capture+ // POSTs are issued. Each bundled hook already caps its own fetch+ // timeout, so the worst case here is bounded by those.+ spawnSync(process.execPath, [join(SCRIPTS_DIR, script)], {+ input: payload,+ // Child stdout is discarded on purpose: Antigravity parses this+ // process's stdout as the hook response, and the bundled scripts+ // emit prose when context injection is enabled.+ stdio: ["pipe", "ignore", "ignore"],+ });+ }+}++// Guarded so the pure helpers above stay importable from tests without the+// module blocking on stdin. Every other bundled hook is a leaf script and+// needs no such guard.+const invokedDirectly =+ process.argv[1] !== undefined &&+ resolve(process.argv[1]) === fileURLToPath(import.meta.url);++if (invokedDirectly) {+ main()+ .catch(() => {})+ .finally(() => {+ // Always a well-formed, non-blocking response, emitted even when the+ // capture above threw or the payload was unparseable — a hook that+ // writes nothing is as fatal to PreToolUse as one that writes `{}`.+ process.stdout.write(responseFor(process.argv[2] ?? ""));+ process.exit(0);+ });+}diff --git a/test/antigravity-connect-hooks.test.ts b/test/antigravity-connect-hooks.test.tsnew file mode 100644index 00000000..7b33f1e6--- /dev/null+++ b/test/antigravity-connect-hooks.test.ts@@ -0,0 +1,375 @@+import { describe, it, expect } from "vitest";+import { execFileSync } from "node:child_process";+import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";+import { tmpdir } from "node:os";+import { join, resolve } from "node:path";+import {+ buildMergedAntigravityHooks,+ containsSpaces,+ type AntigravityHookManifest,+} from "../src/cli/connect/antigravity-hooks.js";+import { findPluginRoot } from "../src/cli/connect/codex-hooks.js";+import {+ normalizePayload,+ responseFor,+ targetsFor,+} from "../src/hooks/antigravity-bridge.js";++const PLUGIN_ROOT = resolve(__dirname, "..", "plugin");++function build(existing: AntigravityHookManifest | null = null) {+ return buildMergedAntigravityHooks(existing, findPluginRoot());+}++type Handler = { type: string; command: string; timeout?: number };++function eventEntries(bundle: unknown, event: string) {+ return (bundle as Record<string, unknown>)[event] as {+ matcher?: string;+ hooks: Handler[];+ }[];+}++function handlers(bundle: unknown, event: string) {+ return (bundle as Record<string, unknown>)[event] as Handler[];+}++/** Every handler in a bundle, across both of agy's event shapes. */+function allCommands(bundle: unknown): string[] {+ const out: string[] = [];+ for (const value of Object.values(bundle as Record<string, unknown>)) {+ if (!Array.isArray(value)) continue;+ for (const entry of value) {+ const nested = (entry as { hooks?: Handler[] }).hooks;+ for (const h of nested ?? [entry as Handler]) out.push(h.command);+ }+ }+ return out;+}++describe("buildMergedAntigravityHooks", () => {+ it("rewrites ${CLAUDE_PLUGIN_ROOT} to absolute pluginRoot in every command", () => {+ for (const bundle of Object.values(build())) {+ for (const command of allCommands(bundle)) {+ expect(command).not.toContain("${CLAUDE_PLUGIN_ROOT}");+ expect(command).toContain(`${PLUGIN_ROOT}/scripts/`);+ }+ }+ });++ it("leaves the resolved script path unquoted, as agy's parser requires", () => {+ // agy does not run `command` through a shell and does not strip quotes+ // before splitting, so `node "<root>/x.mjs"` makes node look for a module+ // whose name literally begins with a double quote. Verified on 1.0.15.+ for (const bundle of Object.values(build())) {+ for (const command of allCommands(bundle)) {+ expect(command).not.toContain('"');+ }+ }+ });++ it("shapes tool events and lifecycle events the way agy parses them", () => {+ // Only tool events take the { matcher, hooks } wrapper. Wrapping a+ // lifecycle event makes agy reject the entire file, which silently+ // disables every other bundle in it too. Verified on agy 1.0.15.+ const bundle = build()["agentmemory"]!;+ for (const event of ["PreToolUse", "PostToolUse"]) {+ for (const entry of eventEntries(bundle, event)) {+ expect(Array.isArray(entry.hooks), event).toBe(true);+ expect(entry, event).not.toHaveProperty("command");+ }+ }+ for (const event of ["PreInvocation", "Stop"]) {+ for (const handler of handlers(bundle, event)) {+ expect(handler.type, event).toBe("command");+ expect(handler.command, event).toContain("antigravity-bridge.mjs");+ expect(handler, event).not.toHaveProperty("hooks");+ expect(handler, event).not.toHaveProperty("matcher");+ }+ }+ });++ it("flags a plugin path that agy could never execute", () => {+ // Quoted or not, a space truncates the argument — there is no escaping+ // form that works, so the installer has to refuse instead of writing a+ // bundle that loads but never fires.+ expect(containsSpaces("C:/Program Files/agentmemory/plugin")).toBe(true);+ expect(containsSpaces("/opt/agentmemory/plugin")).toBe(false);+ });++ it("registers under a single named bundle, as Antigravity's schema requires", () => {+ expect(Object.keys(build())).toEqual(["agentmemory"]);+ expect(build()["agentmemory"]!["enabled"]).toBe(true);+ });++ it("only wires events Antigravity actually dispatches", () => {+ const bundle = build()["agentmemory"]!;+ const events = Object.keys(bundle).filter((k) => k !== "enabled");+ // PostInvocation is intentionally unwired: PostToolUse already captures+ // the work, so firing both would double-record every turn.+ expect(events.sort()).toEqual(+ ["PreInvocation", "PreToolUse", "PostToolUse", "Stop"].sort(),+ );+ });++ it("scopes PreToolUse to the file tools agy actually exposes", () => {+ const matcher = eventEntries(build()["agentmemory"], "PreToolUse")[0]!+ .matcher!;+ for (const tool of ["view_file", "edit_file", "write_to_file", "grep_search"]) {+ expect(matcher.split("|")).toContain(tool);+ }+ // run_command is deliberately excluded — shell invocations are captured+ // on PostToolUse, and matching them here would fire on every command.+ expect(matcher.split("|")).not.toContain("run_command");+ });++ it("keeps user-authored hook bundles untouched", () => {+ const existing: AntigravityHookManifest = {+ "block-run-command": {+ enabled: true,+ PreToolUse: [+ {+ matcher: "run_command",+ hooks: [{ type: "command", command: "/usr/local/bin/deny.sh" }],+ },+ ],+ },+ };+ const merged = build(existing);+ expect(merged["block-run-command"]).toEqual(existing["block-run-command"]);+ expect(merged["agentmemory"]).toBeDefined();+ });++ it("replaces a stale agentmemory bundle instead of duplicating it", () => {+ const stale: AntigravityHookManifest = {+ "agentmemory-legacy": {+ enabled: true,+ Stop: [+ {+ hooks: [+ {+ type: "command",+ command: `node "${PLUGIN_ROOT}/scripts/removed-hook.mjs" Stop`,+ },+ ],+ },+ ],+ },+ };+ const merged = build(stale);+ expect(merged["agentmemory-legacy"]).toBeUndefined();+ expect(Object.keys(merged)).toEqual(["agentmemory"]);+ });++ it("recognises a stale bundle written in the flat lifecycle shape too", () => {+ // Ownership detection has to see through both shapes, or a re-install+ // leaves the old bundle behind and agy runs two copies of every hook.+ const stale: AntigravityHookManifest = {+ "agentmemory-legacy": {+ enabled: true,+ Stop: [+ {+ type: "command",+ command: `node ${PLUGIN_ROOT}/scripts/removed-hook.mjs Stop`,+ },+ ],+ },+ };+ expect(build(stale)["agentmemory-legacy"]).toBeUndefined();+ });++ it("re-install is idempotent", () => {+ const first = build();+ expect(build(first)).toEqual(first);+ });++ it("keeps a pluginRoot containing $-replacement patterns literal", () => {+ // `String.prototype.replace` with a string argument reads `$$`, `$&`,+ // "$`" and `$'` in the replacement as patterns. An install path holding+ // any of them would otherwise be rewritten into a broken command, and+ // the only symptom would be hooks that silently never fire.+ const tmp = mkdtempSync(join(tmpdir(), "am-antigravity-"));+ try {+ const oddRoot = join(tmp, "plug$&$$in");+ mkdirSync(join(oddRoot, "hooks"), { recursive: true });+ copyFileSync(+ join(PLUGIN_ROOT, "hooks", "hooks.antigravity.json"),+ join(oddRoot, "hooks", "hooks.antigravity.json"),+ );++ const command = handlers(+ buildMergedAntigravityHooks(null, oddRoot)["agentmemory"],+ "Stop",+ )[0]!.command;++ expect(command).toContain(`${oddRoot}/scripts/`);+ expect(command).not.toContain("${CLAUDE_PLUGIN_ROOT}");+ } finally {+ rmSync(tmp, { recursive: true, force: true });+ }+ });+});++describe("antigravity bridge payload normalization", () => {+ it("maps conversationId and workspacePaths onto the canonical fields", () => {+ const out = normalizePayload("PostToolUse", {+ conversationId: "conv_123",+ workspacePaths: ["/repo/app"],+ transcriptPath: "/tmp/t.jsonl",+ });+ expect(out["session_id"]).toBe("conv_123");+ expect(out["cwd"]).toBe("/repo/app");+ expect(out["transcript_path"]).toBe("/tmp/t.jsonl");+ expect(out["hook_event_name"]).toBe("PostToolUse");+ });++ it("flattens toolCall into tool_name/tool_input with Cascade names mapped", () => {+ const out = normalizePayload("PreToolUse", {+ conversationId: "c1",+ toolCall: {+ name: "view_file",+ args: { AbsolutePath: "/repo/src/index.ts", StartLine: 1 },+ },+ });+ expect(out["tool_name"]).toBe("read");+ expect(out["native_tool_name"]).toBe("view_file");+ expect((out["tool_input"] as Record<string, unknown>)["file_path"]).toBe(+ "/repo/src/index.ts",+ );+ // Original PascalCase args survive for anything downstream that wants them.+ expect((out["tool_input"] as Record<string, unknown>)["StartLine"]).toBe(1);+ });++ it("normalizes a payload captured verbatim from agy 1.0.15", () => {+ // Recorded by pointing a probe hook at a live `agy --print` run. Note+ // there is no `cwd` key at all, and `workspacePaths` came back empty in+ // headless mode — the session id has to come from `conversationId`.+ const out = normalizePayload("PreToolUse", {+ artifactDirectoryPath:+ "C:/Users/u/.gemini/antigravity-cli/brain/53642203-62f2-45e9-bda3-b1304c61bc99",+ conversationId: "53642203-62f2-45e9-bda3-b1304c61bc99",+ modelName: "gemini-3.6-flash-high",+ stepIdx: 3,+ toolCall: {+ args: { DirectoryPath: "C:\\Users\\u\\.gemini\\antigravity-cli" },+ name: "list_dir",+ },+ transcriptPath:+ "C:/Users/u/.gemini/antigravity-cli/brain/53642203/.system_generated/logs/transcript_full.jsonl",+ workspacePaths: [],+ });++ expect(out["session_id"]).toBe("53642203-62f2-45e9-bda3-b1304c61bc99");+ expect(out["tool_name"]).toBe("glob");+ expect(out["native_tool_name"]).toBe("list_dir");+ expect((out["tool_input"] as Record<string, unknown>)["path"]).toBe(+ "C:\\Users\\u\\.gemini\\antigravity-cli",+ );+ expect(out["transcript_path"]).toContain("transcript_full.jsonl");+ // Fields agy sends that no bundled hook reads still survive the trip.+ expect(out["modelName"]).toBe("gemini-3.6-flash-high");+ expect(out["stepIdx"]).toBe(3);+ });++ it("maps every PascalCase arg the canonical hooks read", () => {+ const cases: [string, string, string][] = [+ ["AbsolutePath", "file_path", "/repo/a.ts"],+ ["TargetFile", "file_path", "/repo/b.ts"],+ ["DirectoryPath", "path", "/repo/src"],+ ["SearchDirectory", "path", "/repo/test"],+ ["Pattern", "pattern", "*.ts"],+ ["Query", "pattern", "normalizePayload"],+ ["CommandLine", "command", "npm test"],+ ];+ for (const [from, to, value] of cases) {+ const input = normalizePayload("PreToolUse", {+ toolCall: { name: "view_file", args: { [from]: value } },+ })["tool_input"] as Record<string, unknown>;+ expect(input[to], `${from} -> ${to}`).toBe(value);+ // The original key survives alongside the canonical one.+ expect(input[from], from).toBe(value);+ }+ });++ it("does not let a mapped alias clobber an explicit canonical key", () => {+ const input = normalizePayload("PreToolUse", {+ toolCall: {+ name: "edit_file",+ args: { TargetFile: "/repo/alias.ts", file_path: "/repo/explicit.ts" },+ },+ })["tool_input"] as Record<string, unknown>;+ expect(input["file_path"]).toBe("/repo/explicit.ts");+ });++ it("passes unmapped tool names through unchanged", () => {+ const out = normalizePayload("PostToolUse", {+ toolCall: { name: "run_command", args: { CommandLine: "npm test" } },+ });+ expect(out["tool_name"]).toBe("run_command");+ expect((out["tool_input"] as Record<string, unknown>)["command"]).toBe(+ "npm test",+ );+ });++ it("falls back to a placeholder session id rather than dropping the event", () => {+ expect(normalizePayload("Stop", {})["session_id"]).toBe("unknown");+ });+});++describe("antigravity bridge stdout contract", () => {+ // agy documents `decision` as required on PreToolUse output and treats a+ // response without it as a denial — a bare `{}` there makes the agent+ // refuse every matched tool call instead of passively capturing it.+ it("answers PreToolUse with an explicit allow, everything else with {}", () => {+ expect(JSON.parse(responseFor("PreToolUse"))).toEqual({+ decision: "allow",+ });+ for (const event of ["PreInvocation", "PostToolUse", "Stop", ""]) {+ expect(JSON.parse(responseFor(event)), event).toEqual({});+ }+ });++ it("writes that contract to stdout when the bundled script actually runs", () => {+ const script = join(PLUGIN_ROOT, "scripts", "antigravity-bridge.mjs");+ const run = (event: string) =>+ execFileSync(process.execPath, [script, event], {+ input: JSON.stringify({+ conversationId: "c1",+ toolCall: { name: "view_file", args: { AbsolutePath: "/repo/a.ts" } },+ }),+ encoding: "utf-8",+ // No server is listening on port 1, so every capture fetch fails+ // fast: this asserts the response survives a failed capture, which+ // is exactly the case where a swallowed error could emit nothing.+ env: { ...process.env, AGENTMEMORY_URL: "http://127.0.0.1:1" },+ stdio: ["pipe", "pipe", "ignore"],+ });++ expect(JSON.parse(run("PreToolUse"))).toEqual({ decision: "allow" });+ expect(JSON.parse(run("PostToolUse"))).toEqual({});+ });+});++describe("antigravity bridge event routing", () => {+ it("opens the session on the first invocation only", () => {+ expect(targetsFor("PreInvocation", { invocationNum: 1 })).toEqual([+ "session-start.mjs",+ "prompt-submit.mjs",+ ]);+ expect(targetsFor("PreInvocation", { invocationNum: 4 })).toEqual([+ "prompt-submit.mjs",+ ]);+ });++ it("treats a missing invocationNum as the first invocation", () => {+ expect(targetsFor("PreInvocation", {})).toContain("session-start.mjs");+ });++ it("closes the session on Stop", () => {+ expect(targetsFor("Stop", {})).toEqual(["stop.mjs", "session-end.mjs"]);+ });++ it("ignores PostInvocation to avoid double-capturing a turn", () => {+ expect(targetsFor("PostInvocation", {})).toEqual([]);+ });+});diff --git a/test/cli-connect.test.ts b/test/cli-connect.test.tsindex 46a1f240..ce43ac83 100644--- a/test/cli-connect.test.ts+++ b/test/cli-connect.test.ts@@ -44,6 +44,7 @@ describe("agentmemory connect — dispatcher", () => {expect(knownAgents().sort()).toEqual(["antigravity",+ "antigravity-cli","claude-code","cline","copilot-cli",@@ -63,7 +64,7 @@ describe("agentmemory connect — dispatcher", () => {"zed",].sort(),);- expect(ADAPTERS.length).toBe(18);+ expect(ADAPTERS.length).toBe(19);});it("every adapter exposes detect() and install()", () => {diff --git a/test/connect-guidelines.test.ts b/test/connect-guidelines.test.tsindex 91727236..633aedc5 100644--- a/test/connect-guidelines.test.ts+++ b/test/connect-guidelines.test.ts@@ -133,6 +133,7 @@ describe("guidelineTargets coverage", () => {expect(names).toEqual(["antigravity",+ "antigravity-cli","cline","continue","copilot-cli",diff --git a/tsdown.config.ts b/tsdown.config.tsindex 390a4df6..0c6426c1 100644--- a/tsdown.config.ts+++ b/tsdown.config.ts@@ -14,6 +14,7 @@ const hookEntries = ["src/hooks/stop.ts","src/hooks/session-end.ts","src/hooks/post-commit.ts",+ "src/hooks/antigravity-bridge.ts",];const shared = {