@ken-jo/agent-connector 0.1.0

package/dist/chunk-TRKWUNO4.js

@@ -0,0 +1,702 @@
+#!/usr/bin/env node
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-TIIP3RG2.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  buildUsageEventCommand,
+  isHomeBinHookCommand,
+  isHostNativeUsageEnabled,
+  isUsageEventCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+
+// src/adapters/antigravity/index.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HOST = "antigravity";
+var MCP_ROOT_KEY = "mcpServers";
+var USER_CONFIG_CANDIDATES = [
+  [".gemini", "antigravity", "mcp_config.json"],
+  [".gemini", "config", "mcp_config.json"],
+  [".gemini", "antigravity-cli", "mcp_config.json"]
+];
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "SessionStart",
+  "Stop"
+]);
+var USAGE_HOOK_EVENT = "AfterModel";
+var AntigravityAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Google Antigravity";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Antigravity 2.0 fires PreToolUse / PostToolUse / SessionStart / Stop.
+    preToolUse: true,
+    postToolUse: true,
+    sessionStart: true,
+    stop: true,
+    // No documented equivalents — kept false; the corresponding normalized
+    // events warn-skip at install time.
+    preCompact: false,
+    sessionEnd: false,
+    userPromptSubmit: false,
+    notification: false,
+    // Transform-category hooks can rewrite tool input and tool output; the
+    // SessionStart hook can inject additional context.
+    canModifyArgs: true,
+    canModifyOutput: true,
+    canInjectSessionContext: true,
+    // Antigravity registers stdio, SSE, and Streamable HTTP MCP servers.
+    transports: ["stdio", "sse", "http"],
+    // Content surfaces: Workflows (markdown commands) + Agent Skills (SKILL.md).
+    // Declarative subagents exist only inside a plugin bundle (not emitted), so
+    // subagents are unsupported and inherit the BaseAdapter skip/warn default.
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: false
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userConfig = this.resolveUserConfigPath();
+    const userDir = join(homedir(), ".gemini");
+    const projectConfig = join(projectDir, ".agents", "mcp_config.json");
+    const userInstalled = existsSync(userDir) || this.userConfigCandidates().some((parts) => existsSync(join(homedir(), ...parts)));
+    const projInstalled = existsSync(projectConfig);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectConfig : userConfig;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? scope === "project" ? `found project Antigravity config at ${projectConfig}` : `found Antigravity config under ${userDir}` : `no Antigravity config at ${userDir} or ${projectConfig}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    if (ctx.scope === "project") return join(ctx.projectDir, ".agents");
+    return dirname(this.resolveUserConfigPath());
+  }
+  getServerConfigPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".agents", "mcp_config.json") : this.resolveUserConfigPath();
+  }
+  /**
+   * Hooks live in a SEPARATE hooks.json in the customization dir — NOT the
+   * mcp_config.json. Project → <proj>/.agents/hooks.json; user →
+   * <resolvedUserConfigDir>/hooks.json (the dir holding the resolved user MCP
+   * config). Path is medium-confidence and surfaced by the doctor.
+   */
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "hooks.json");
+  }
+  /**
+   * The user-scope MCP config candidates, in preference order. Overridable by
+   * forks (e.g. the Antigravity CLI) that resolve a different user-scope root
+   * while reusing resolveUserConfigPath's prefer-existing-else-candidate[0] logic.
+   */
+  userConfigCandidates() {
+    return USER_CONFIG_CANDIDATES;
+  }
+  /**
+   * Pick the user-scope mcp_config.json: prefer a candidate that already exists,
+   * else default to candidate[0] (the CONFIRMED canonical ~/.gemini/antigravity path).
+   */
+  resolveUserConfigPath() {
+    const home = homedir();
+    const candidates = this.userConfigCandidates();
+    for (const parts of candidates) {
+      const p = join(home, ...parts);
+      if (existsSync(p)) return p;
+    }
+    const fallback = candidates[0];
+    if (fallback === void 0) {
+      return join(home, ".gemini", "antigravity", "mcp_config.json");
+    }
+    return join(home, ...fallback);
+  }
+  /**
+   * Resolve the Workflows (slash-command) dir, prefer-existing-else-canonical.
+   *   project → prefer existing <proj>/.agent/workflows or <proj>/.agents/workflows;
+   *             default .agent/workflows (launch-era singular `.agent`).
+   *   user    → ~/.gemini/antigravity/global_workflows.
+   */
+  resolveWorkflowsDir(ctx) {
+    if (ctx.scope === "project") {
+      const singular = join(ctx.projectDir, ".agent", "workflows");
+      const plural = join(ctx.projectDir, ".agents", "workflows");
+      if (existsSync(singular)) return singular;
+      if (existsSync(plural)) return plural;
+      return singular;
+    }
+    return join(homedir(), ".gemini", "antigravity", "global_workflows");
+  }
+  /**
+   * Resolve the Agent Skills dir, prefer-existing-else-canonical.
+   *   project → <proj>/.agents/skills (plural — matches mcp/skills convention).
+   *   user    → prefer existing ~/.gemini/antigravity-cli/skills, else
+   *             ~/.gemini/skills. NEVER ~/.gemini/antigravity/skills
+   *             (reportedly broken), so it is not a candidate.
+   */
+  resolveSkillsDir(ctx) {
+    if (ctx.scope === "project") {
+      return join(ctx.projectDir, ".agents", "skills");
+    }
+    const home = homedir();
+    const cliSkills = join(home, ".gemini", "antigravity-cli", "skills");
+    const sharedSkills = join(home, ".gemini", "skills");
+    if (existsSync(cliSkills)) return cliSkills;
+    if (existsSync(sharedSkills)) return sharedSkills;
+    return cliSkills;
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[this.id]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? `server registration disabled for ${this.id}` : "connector declares no MCP server"
+        }
+      ];
+    }
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const serverPath = this.getServerConfigPath(ctx);
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(serverPath, MCP_ROOT_KEY, connector.id, entry, ctx.dryRun)
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(serverPath, MCP_ROOT_KEY, ctx.connector.id, ctx.dryRun)
+    ];
+  }
+  /** Render a normalized ServerDef into Antigravity's native mcpServers entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      if (shouldWrapForTelemetry(server, ctx.connector.telemetry)) {
+        const wrapped = buildServeWrapperCommand(
+          ctx.homeBinPath,
+          ctx.connector.id,
+          command,
+          args,
+          ctx.scope,
+          this.id
+        );
+        command = wrapped.command;
+        args = wrapped.args;
+      }
+      const entry2 = { command: resolveEnvRefsDeep(command) };
+      if (args.length > 0) entry2.args = resolveEnvRefsDeep(args);
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      return entry2;
+    }
+    const entry = { serverUrl: resolveEnvRefsDeep(server.url ?? "") };
+    const headers = this.renderEnv(server.headers);
+    if (headers) entry.headers = headers;
+    return entry;
+  }
+  /**
+   * Render env/header values. Antigravity documents no native interpolation
+   * token, so resolve `${env:VAR}` references to literals at install time.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    return resolveEnvRefsDeep({ ...env });
+  }
+  // ── Hook install / uninstall ─────────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.hooks === false) {
+      return [{ platform: this.id, action: "skip", detail: `hooks disabled for ${this.id}` }];
+    }
+    const hostNative = isHostNativeUsageEnabled(connector.telemetry);
+    if (connector.hookEvents.length === 0 && !hostNative) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    }
+    const hooksPath = this.getHookConfigPath(ctx);
+    if (this.isPresentButUnparseable(hooksPath)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: hooksPath,
+          detail: `existing ${hooksPath} is not parseable; left untouched (back it up / fix it, then re-run)`
+        }
+      ];
+    }
+    const file = this.readJson(hooksPath) ?? {};
+    const hooks = file.hooks ??= {};
+    const changes = [];
+    let mutated = false;
+    for (const event of connector.hookEvents) {
+      if (!SUPPORTED_EVENTS.has(event)) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: hooksPath,
+          detail: `${event} has no Antigravity hook equivalent \u2014 skipped`
+        });
+        continue;
+      }
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, this.id, event, connector.id);
+      const matcher = connector.hooks[event]?.matcher ?? "";
+      const entry = {
+        matcher,
+        hooks: [{ type: "command", command }]
+      };
+      const bucket = hooks[event] ??= [];
+      const existingIdx = bucket.findIndex((e) => this.entryHasOurCommand(e, ctx));
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: hooksPath,
+            detail: `hooks.${event} already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: hooksPath,
+          detail: `hooks.${event}`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: hooksPath,
+          detail: `hooks.${event}`
+        });
+      }
+      mutated = true;
+    }
+    if (hostNative) {
+      if (this.installUsageHook(hooks, ctx, hooksPath, changes)) mutated = true;
+    }
+    if (mutated) this.writeJson(hooksPath, file, ctx.dryRun);
+    return changes;
+  }
+  /**
+   * Register the opt-in AfterModel host-native usage hook (4a) into `hooks`.
+   * Idempotent (byte-identical → skip, drift → update); returns true on mutation.
+   * The command is the hidden `usage-event` entrypoint (NOT a connector hook), so
+   * it carries an empty matcher. Reads `this.id` so the CLI fork installs its own
+   * `usage-event antigravity-cli …` variant.
+   */
+  installUsageHook(hooks, ctx, hooksPath, changes) {
+    const command = buildUsageEventCommand(ctx.homeBinPath, this.id, ctx.connector.id);
+    const entry = {
+      matcher: "",
+      hooks: [{ type: "command", command }]
+    };
+    const bucket = hooks[USAGE_HOOK_EVENT] ??= [];
+    const existingIdx = bucket.findIndex(
+      (e) => (e.hooks ?? []).some((h) => isUsageEventCommand(h.command, ctx.homeBinPath, ctx.connector.id))
+    );
+    if (existingIdx >= 0) {
+      if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+        changes.push({
+          platform: this.id,
+          action: "skip",
+          path: hooksPath,
+          detail: `hooks.${USAGE_HOOK_EVENT} (host-native usage) already registered`
+        });
+        return false;
+      }
+      bucket[existingIdx] = entry;
+      changes.push({
+        platform: this.id,
+        action: "update",
+        path: hooksPath,
+        detail: `hooks.${USAGE_HOOK_EVENT} (host-native usage)`
+      });
+    } else {
+      bucket.push(entry);
+      changes.push({
+        platform: this.id,
+        action: "create",
+        path: hooksPath,
+        detail: `hooks.${USAGE_HOOK_EVENT} (host-native usage)`
+      });
+    }
+    return true;
+  }
+  uninstallHooks(ctx) {
+    const hooksPath = this.getHookConfigPath(ctx);
+    const file = this.readJson(hooksPath);
+    const hooks = file?.hooks;
+    if (!file || !hooks) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: hooksPath,
+          detail: "no hooks section present"
+        }
+      ];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const event of Object.keys(hooks)) {
+      const bucket = hooks[event];
+      if (!Array.isArray(bucket)) continue;
+      const next = [];
+      let removed = 0;
+      for (const e of bucket) {
+        const innerBefore = e.hooks?.length ?? 0;
+        const inner = (e.hooks ?? []).filter((h) => !this.isOurCommand(h.command, ctx));
+        removed += innerBefore - inner.length;
+        if (inner.length > 0) next.push({ matcher: e.matcher ?? "", hooks: inner });
+      }
+      if (removed > 0) {
+        if (next.length > 0) hooks[event] = next;
+        else delete hooks[event];
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: hooksPath,
+          detail: `hooks.${event} (${removed})`
+        });
+        mutated = true;
+      }
+    }
+    if (mutated) this.writeJson(hooksPath, file, ctx.dryRun);
+    if (changes.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: hooksPath,
+        detail: "no matching hook entries"
+      });
+    }
+    return changes;
+  }
+  entryHasOurCommand(entry, ctx) {
+    return (entry.hooks ?? []).some((h) => this.isOurCommand(h.command, ctx));
+  }
+  /**
+   * True when a hook command is ONE OF OURS for this connector — the universal
+   * `hook` dispatcher OR the opt-in `usage-event` sink. Both are anchored on the
+   * connector id (see isHomeBinHookCommand) so a shared-prefix id can't collide,
+   * and so uninstall reverses the AfterModel usage hook too.
+   */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id) || isUsageEventCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surfaces: commands (Workflows) / skills ───────────────────────
+  // CONTENT-ONLY: pure native-file writers under the probed workflows / skills
+  // dirs. No runtime dispatch, no home-bin pointer, no telemetry wrap. Each
+  // method is idempotent (byte-identical → skip) via BaseAdapter.writeContentFile
+  // and reversible via removeContentFile. Honors platforms["antigravity"]
+  // per-surface false to skip. Commands are markdown Workflows (NOT TOML, unlike
+  // gemini-cli); skills are the uniform Claude-compatible SKILL.md. Subagents are
+  // unsupported (plugin-bundle-only) and inherit the BaseAdapter skip/warn.
+  /** Native Workflow file path: <workflowsDir>/<name>.md. */
+  commandPath(ctx, name) {
+    return join(this.resolveWorkflowsDir(ctx), `${name}.md`);
+  }
+  /** Native skill dir: <skillsDir>/<name>. */
+  skillDir(ctx, name) {
+    return join(this.resolveSkillsDir(ctx), name);
+  }
+  // ── Commands (Workflows) ──────────────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: `commands disabled for ${this.id}` }];
+    }
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.writeContentFile(this.commandPath(ctx, cmd.name), this.renderCommand(cmd), ctx.dryRun)
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.removeContentFile(this.commandPath(ctx, cmd.name), ctx.dryRun)
+    );
+  }
+  /**
+   * Render a command to an Antigravity Workflow: a plain markdown `.md` whose
+   * body is the command prompt, optionally preceded by a leading description
+   * line. No frontmatter / TOML (unlike gemini-cli).
+   */
+  renderCommand(cmd) {
+    const body = cmd.prompt.endsWith("\n") ? cmd.prompt : `${cmd.prompt}
+`;
+    if (cmd.description !== void 0 && cmd.description !== "") {
+      return `${cmd.description}
+
+${body}`;
+    }
+    return body;
+  }
+  // ── Skills ────────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[this.id]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: `skills disabled for ${this.id}` }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /**
+   * Render a skill's SKILL.md: frontmatter (name, description + optional model,
+   * allowed-tools, disable-model-invocation) + body. Uniform across platforms.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.model !== void 0) frontmatter.model = skill.model;
+    const allow = skill.tools?.allow;
+    if (allow && allow.length > 0) frontmatter["allowed-tools"] = allow.join(", ");
+    if (skill.disableModelInvocation !== void 0) {
+      frontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    }
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const mcpPath = this.getServerConfigPath(ctx);
+    const hooksPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    const workflowsDir = this.resolveWorkflowsDir(ctx);
+    const skillsDir = this.resolveSkillsDir(ctx);
+    const checks = [
+      {
+        name: `${this.name}: mcp_config.json present`,
+        check: () => existsSync(mcpPath) ? { status: "OK", detail: `${mcpPath} (path probed; verify for your Antigravity version)` } : { status: "FAIL", detail: `not found: ${mcpPath} (path probed; verify for your Antigravity version)` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          const cfg = this.readJson(mcpPath);
+          const bucket = cfg?.[MCP_ROOT_KEY];
+          if (!cfg || !bucket) {
+            return { status: "FAIL", detail: `no ${MCP_ROOT_KEY} in ${mcpPath}` };
+          }
+          return connectorId in bucket ? { status: "OK", detail: `${MCP_ROOT_KEY}.${connectorId} present` } : {
+            status: "FAIL",
+            detail: `no ${MCP_ROOT_KEY}.${connectorId} in ${mcpPath}`
+          };
+        }
+      },
+      {
+        name: `${this.name}: hooks.json hook command registered`,
+        check: () => {
+          if (hookEvents.length === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const file = this.readJson(hooksPath);
+          if (!file) {
+            return {
+              status: "FAIL",
+              detail: `not found: ${hooksPath} (path probed; verify for your Antigravity version)`
+            };
+          }
+          const hooks = file.hooks ?? {};
+          const registered = Object.values(hooks).some(
+            (entries) => (entries ?? []).some(
+              (e) => (e.hooks ?? []).some(
+                (h) => isHomeBinHookCommand(h.command, homeBin, connectorId)
+              )
+            )
+          );
+          return registered ? { status: "OK", detail: `hook command present in ${hooksPath}` } : { status: "FAIL", detail: `no hook for ${connectorId} in ${hooksPath}` };
+        }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = join(workflowsDir, `${cmd.name}.md`);
+      checks.push({
+        name: `${this.name}: workflow ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: `${p} (workflows dir probed; verify for your version)` } : { status: "FAIL", detail: `not found: ${p} (workflows dir probed; verify for your version)` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(skillsDir, skill.name, "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: `${p} (skills dir probed; verify for your version)` } : { status: "FAIL", detail: `not found: ${p} (skills dir probed; verify for your version)` }
+      });
+    }
+    return checks;
+  }
+  // ── Runtime: parse Antigravity stdin JSON → normalized event ──────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = typeof input.sessionId === "string" ? input.sessionId : "";
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: this.id,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.toolName ?? "",
+          toolInput: input.toolInput ?? {},
+          ...input.toolOutput !== void 0 ? { toolOutput: input.toolOutput } : {},
+          ...input.isError === true ? { isError: true } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stopHookActive === "boolean" ? { stopHookActive: input.stopHookActive } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported ${this.id} hook event: ${String(event)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Antigravity native hook reply ──────────
+  formatReply(event, response) {
+    const decision = response.decision ?? "allow";
+    if (decision === "deny") {
+      return this.stdout({
+        decision: "deny",
+        reason: response.reason ?? "Blocked by hook"
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        decision: "deny",
+        reason: response.reason ?? "Action requires user confirmation (security policy)"
+      });
+    }
+    if (decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return this.stdout({ updatedInput: response.updatedInput });
+      }
+      if (event === "PostToolUse" && response.updatedOutput !== void 0) {
+        return this.stdout({ updatedOutput: response.updatedOutput });
+      }
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({ additionalContext: response.additionalContext });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function normalizeSessionSource(source) {
+  switch (source) {
+    case "compact":
+      return "compact";
+    case "resume":
+      return "resume";
+    case "clear":
+      return "clear";
+    default:
+      return "startup";
+  }
+}
+var adapter = new AntigravityAdapter();
+var antigravity_default = adapter;
+
+export {
+  AntigravityAdapter,
+  adapter,
+  antigravity_default
+};
+//# sourceMappingURL=chunk-TRKWUNO4.js.map