@ken-jo/agent-connector 0.4.8 → 0.4.43

package/dist/amazon-q-UFLBUSHG.js

@@ -0,0 +1,570 @@
+#!/usr/bin/env node
+import {
+  normalizeSessionSource
+} from "./chunk-H53QZQJI.js";
+import {
+  resolveEnvRefsDeep
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-A767JFHW.js";
+import {
+  buildWrappedStdio,
+  isHomeBinHookCommand
+} from "./chunk-TO57WYBB.js";
+import "./chunk-ZY25RG4Y.js";
+import "./chunk-QY42WGBX.js";
+
+// src/adapters/amazon-q/index.ts
+import { existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOST = "amazon-q";
+var MCP_ROOT_KEY = "mcpServers";
+var DEFAULT_AGENT_FILE = "q_cli_default.json";
+var RESERVED_AGENT_NAME = "q_cli_default";
+var Q_TRIGGER = {
+  preToolUse: "preToolUse",
+  postToolUse: "postToolUse",
+  agentSpawn: "agentSpawn",
+  userPromptSubmit: "userPromptSubmit",
+  stop: "stop"
+};
+var EVENT_MAP = {
+  SessionStart: Q_TRIGGER.agentSpawn,
+  UserPromptSubmit: Q_TRIGGER.userPromptSubmit,
+  PreToolUse: Q_TRIGGER.preToolUse,
+  PostToolUse: Q_TRIGGER.postToolUse,
+  Stop: Q_TRIGGER.stop
+};
+var MATCHER_TRIGGERS = /* @__PURE__ */ new Set([
+  Q_TRIGGER.preToolUse,
+  Q_TRIGGER.postToolUse
+]);
+var CONTEXT_TRIGGERS = /* @__PURE__ */ new Set([
+  Q_TRIGGER.agentSpawn,
+  Q_TRIGGER.userPromptSubmit
+]);
+var AmazonQAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Amazon Q Developer CLI";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Memory surface: WIRED. Amazon Q reads `.amazonq/rules` (NOT AGENTS.md), so
+    // the AGENTS.md-first BaseAdapter default does not apply — memoryTargets()
+    // below overrides it to write a DEDICATED agent-connector-owned file
+    // (<projectDir>/.amazonq/rules/agent-connector.md, plain Markdown, no
+    // frontmatter — auto-applied as context per the AWS docs). Project scope
+    // only; user scope skip-warns (no verified user/global rules dir).
+    supportsMemory: true,
+    //
+    // Hooks: Amazon Q fires agentSpawn / userPromptSubmit / preToolUse /
+    // postToolUse / stop (mapped from SessionStart / UserPromptSubmit /
+    // PreToolUse / PostToolUse / Stop). It has no PreCompact / SessionEnd /
+    // Notification equivalent, nor the E1 extension events (PermissionRequest /
+    // PostToolUseFailure / SubagentStart / SubagentStop) — those warn-skip.
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: false,
+    sessionStart: true,
+    sessionEnd: false,
+    userPromptSubmit: true,
+    stop: true,
+    notification: false,
+    // Exit-code protocol only — a hook can allow (0) or block (2), but it CANNOT
+    // rewrite tool args or output.
+    canModifyArgs: false,
+    canModifyOutput: false,
+    // agentSpawn / userPromptSubmit add a hook's plain STDOUT to the agent's
+    // context (no JSON envelope) — primary-verified via docs/hooks.md.
+    canInjectSessionContext: true,
+    // Amazon Q registers stdio + Streamable HTTP MCP servers (primary-verified).
+    transports: ["stdio", "http"],
+    // Content surfaces:
+    //   subagents: WIRED. Amazon Q's "agents" are per-agent JSON files where the
+    //   FILENAME (minus .json) IS the agent name (primary-verified via the CLI
+    //   repo docs/agent-file-locations.md + docs/agent-format.md). AC maps each
+    //   connector SubagentDef → cli-agents/<name>.json = { name, description,
+    //   prompt } (+ model when non-"inherit"; + tools/allowedTools when the
+    //   SubagentDef carries a tool policy — see renderSubagent). Both scopes:
+    //     user    → ~/.aws/amazonq/cli-agents/<name>.json
+    //     project → <projectDir>/.amazonq/cli-agents/<name>.json
+    //   A subagent named `q_cli_default` would resolve to the hooks/default-agent
+    //   file — the SDK already rejects it (non-kebab name), and installSubagents
+    //   refuses it as defense-in-depth so a subagent write can never clobber it.
+    supportsSubagents: true
+    //   commands (prompt library): DEFERRED — format unverified. The only primary
+    //   doc for the ~/.aws/amazonq/prompts/*.md prompt library is the IDE prompt-
+    //   library page (q-in-IDE-chat → ide-chat-context: prompts saved in
+    //   ~/.aws/amazonq/prompts, invoked via @<name> inside the IDE chat). The Q
+    //   CLI repo (aws/amazon-q-developer-cli/docs) ships NO prompts/saved-prompts
+    //   doc, so whether the `q`/`qchat` CLI reads that folder — and whether a
+    //   project-scoped prompts dir exists — is NOT primary-verified for the CLI
+    //   host this adapter targets. supportsCommands stays UNSET (base skip-warns)
+    //   rather than render an unverified surface (the continue per-server-YAML /
+    //   other deferred-unverified precedent).
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = join(homedir(), ".aws", "amazonq");
+    const userMcp = join(userDir, "mcp.json");
+    const projDir = join(projectDir, ".amazonq");
+    const projMcp = join(projDir, "mcp.json");
+    const userInstalled = existsSync(userDir) || existsSync(userMcp);
+    const projInstalled = existsSync(projDir) || existsSync(projMcp);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projMcp : userMcp;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? `found Amazon Q config (${scope}) at ${configPath}` : `no Amazon Q mcp.json at ${userDir} or ${projDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  /**
+   * Config directory per scope. Amazon Q uses DIFFERENT basenames:
+   *   user:    ~/.aws/amazonq   (two segments — NOT a single dotDir)
+   *   project: <projectDir>/.amazonq
+   * This is the ONE deviation from droid/cursor's single-basename getConfigDir.
+   */
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".amazonq") : join(homedir(), ".aws", "amazonq");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "mcp.json");
+  }
+  /**
+   * Hooks live in a per-agent file, NOT the mcp.json. Amazon Q hooks have no
+   * global file, so AC targets the built-in `q_cli_default` agent file at the
+   * install scope (mirroring kiro's default-agent selection):
+   *   user    → ~/.aws/amazonq/cli-agents/q_cli_default.json
+   *   project → <projectDir>/.amazonq/cli-agents/q_cli_default.json
+   * A project install writes a project-scoped `q_cli_default` that SHADOWS the
+   * user-global one (a local `q_cli_default` takes precedence and auto-loads).
+   */
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "cli-agents", DEFAULT_AGENT_FILE);
+  }
+  // ── Memory surface: the `.amazonq/rules` content tree ─────────────────────
+  // Amazon Q uses `.amazonq/rules` (NOT AGENTS.md) for its OWN project rules, so
+  // this override replaces the AGENTS.md base default entirely:
+  //   project → <projectDir>/.amazonq/rules/agent-connector.md  (DEDICATED file
+  //             AC owns; plain Markdown, auto-applied — no frontmatter needed)
+  //   user    → [] (no verified user/global rules dir → base installMemory
+  //             skip-warns rather than guessing a path the CLI may not read)
+  // When `.amazonq/rules` exists as a single FILE (not a directory) we must NOT
+  // create `.amazonq/rules/agent-connector.md` underneath it (that would throw
+  // ENOTDIR), so memoryTargets() returns [] and installMemory() emits a precise
+  // skip-warn rather than crashing (the cline `.clinerules`-is-a-file precedent).
+  memoryTargets(ctx) {
+    if (this.memoryOverride(ctx)?.path) return super.memoryTargets(ctx);
+    if (ctx.scope === "project") {
+      if (this.rulesDirIsFile(ctx.projectDir)) return [];
+      return [
+        {
+          path: join(ctx.projectDir, ".amazonq", "rules", "agent-connector.md"),
+          reason: "amazon-q project rules dir (.amazonq/rules; agent-connector-owned file)"
+        }
+      ];
+    }
+    return [];
+  }
+  /**
+   * Override installMemory ONLY to surface a precise warn when `.amazonq/rules`
+   * exists as a single FILE at project scope (so memoryTargets() returned []):
+   * we never write under it. All other behavior delegates to the base
+   * implementation (the cline `.clinerules`-is-a-file precedent).
+   */
+  installMemory(ctx) {
+    if (ctx.scope === "project" && !this.memoryOverride(ctx)?.path && (ctx.connector.memory ?? []).length > 0 && ctx.connector.platforms[this.id]?.memory !== false && this.rulesDirIsFile(ctx.projectDir)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: join(ctx.projectDir, ".amazonq", "rules"),
+          detail: "existing .amazonq/rules is a file, not a directory; left untouched \u2014 convert it to a .amazonq/rules/ directory to receive agent-connector memory"
+        }
+      ];
+    }
+    return super.installMemory(ctx);
+  }
+  /** True when `<dir>/.amazonq/rules` exists and is a regular FILE (not a dir). */
+  rulesDirIsFile(dir) {
+    const p = join(dir, ".amazonq", "rules");
+    if (!existsSync(p)) return false;
+    try {
+      return statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for amazon-q" : "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 Amazon Q's native mcpServers entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      ({ command, args } = buildWrappedStdio(ctx, server, this.id, command, args));
+      const entry = {
+        command: resolveEnvRefsDeep(command)
+      };
+      if (args.length > 0) entry.args = resolveEnvRefsDeep(args);
+      const env = this.renderEnv(server.env);
+      if (env) entry.env = env;
+      if (server.timeoutMs !== void 0) entry.timeout = server.timeoutMs;
+      return entry;
+    }
+    return {
+      type: "http",
+      url: resolveEnvRefsDeep(server.url ?? "")
+    };
+  }
+  /**
+   * Render stdio env values. Amazon Q has no documented 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 (merge into the default agent file) ──────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.hooks === false) {
+      return [{ platform: this.id, action: "skip", detail: "hooks disabled for amazon-q" }];
+    }
+    if (connector.hookEvents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    }
+    const pending = connector.hookEvents.map((event) => ({
+      event,
+      matcher: connector.hooks[event]?.matcher ?? ""
+    }));
+    return this.upsertHookEntries(
+      ctx,
+      this.getHookConfigPath(ctx),
+      pending,
+      this.hookDescriptor()
+    );
+  }
+  uninstallHooks(ctx) {
+    return this.removeHookEntries(ctx, this.getHookConfigPath(ctx), this.hookDescriptor());
+  }
+  /**
+   * Amazon Q's hook-merge descriptor (FLAT object-of-arrays shape — each entry is
+   * `{ command, matcher? }`, NO `type` field, unlike kiro's nested
+   * `{ matcher, hooks:[...] }`).
+   *  - mapEvent = EVENT_MAP (canonical → Amazon Q trigger); unmapped events
+   *    (PreCompact / SessionEnd / Notification + the E1 set) warn-skip.
+   *  - renderEntry emits `{ command }`, adding `matcher` ONLY for the
+   *    matcher-meaningful triggers (preToolUse/postToolUse) when one is declared;
+   *    an empty matcher = all tools, so it is OMITTED (no `matcher: ""` noise).
+   *  - entryOwnsCommand / ownsEntryForRemove match the home-bin command string
+   *    (idempotency on re-install; whole-entry removal on uninstall). FLAT host →
+   *    no stripInner; an emptied trigger key is dropped by the engine.
+   */
+  hookDescriptor() {
+    return {
+      mapEvent: (e) => EVENT_MAP[e],
+      unmappedWarnDetail: (e) => `${e} has no Amazon Q hook equivalent \u2014 skipped`,
+      renderEntry: (trigger, matcher, command) => {
+        const entry = { command };
+        if (matcher && MATCHER_TRIGGERS.has(trigger)) entry.matcher = matcher;
+        return entry;
+      },
+      entryOwnsCommand: (entry, command) => entry.command === command,
+      ownsEntryForRemove: (c) => (entry) => this.isOurCommand(entry.command, c),
+      skipDetail: (trigger) => `hooks.${trigger} already registered`,
+      removeDetail: (trigger, removed) => `hooks.${trigger} (${removed})`,
+      absentDetail: "no hooks section present",
+      noMatchDetail: "no matching hook entries"
+    };
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surface: subagents → cli-agents/<name>.json ───────────────────
+  // CONTENT-ONLY: a pure native-file writer — no runtime dispatch, no home-bin
+  // pointer, no telemetry wrap. Amazon Q "agents" are per-agent JSON files where
+  // the FILENAME (minus .json) IS the agent name (agent-file-locations.md). Each
+  // file is a STANDALONE agent definition: we write only { name, description,
+  // prompt } (+ model / tools / allowedTools when the SubagentDef carries them)
+  // and NEVER inject hooks (those live in q_cli_default.json) or mcpServers (those
+  // live in mcp.json). The whole file is AC-owned, so idempotency + reversibility
+  // come from writeContentFile/removeContentFile (byte-identical → skip; uninstall
+  // removes the file → NO_RESIDUE).
+  //   user    → ~/.aws/amazonq/cli-agents/<name>.json
+  //   project → <projectDir>/.amazonq/cli-agents/<name>.json
+  /** Native subagent file path: <configDir>/cli-agents/<name>.json. */
+  subagentPath(ctx, name) {
+    return join(this.getConfigDir(ctx), "cli-agents", `${name}.json`);
+  }
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for amazon-q" }];
+    }
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map((agent) => {
+      if (agent.name === RESERVED_AGENT_NAME) {
+        return {
+          platform: this.id,
+          action: "warn",
+          detail: `subagent "${agent.name}" collides with the built-in default agent file (cli-agents/${DEFAULT_AGENT_FILE}); skipped \u2014 rename the subagent`
+        };
+      }
+      return this.writeContentFile(
+        this.subagentPath(ctx, agent.name),
+        this.renderSubagent(agent),
+        ctx.dryRun
+      );
+    });
+  }
+  uninstallSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map((agent) => {
+      if (agent.name === RESERVED_AGENT_NAME) {
+        return {
+          platform: this.id,
+          action: "warn",
+          detail: `subagent "${agent.name}" was never installed (collides with cli-agents/${DEFAULT_AGENT_FILE}); left untouched`
+        };
+      }
+      return this.removeContentFile(this.subagentPath(ctx, agent.name), ctx.dryRun);
+    });
+  }
+  /**
+   * Render a connector subagent into an Amazon Q agent JSON file
+   * (agent-format.md):
+   *   { name, description, prompt }  — prompt is the INLINE system-prompt string
+   *   (Amazon Q's `prompt` field is "high-level context … similar to a system
+   *   prompt"; we use the inline-text form, NOT a file:// ref).
+   * Plus, when the SubagentDef carries them:
+   *   - model:        only when set and not the platform-agnostic "inherit"
+   *     sentinel (Amazon Q has no "inherit" — omitting it applies the default).
+   *   - tools:        SurfaceToolPolicy.allow → the `tools` array (the tools the
+   *     agent can use). Amazon Q's `tools` accepts plain tool-name strings and
+   *     `*`, the same vocabulary the portable allow-list carries.
+   *   - allowedTools: SurfaceToolPolicy.allow → the `allowedTools` array (tools
+   *     usable WITHOUT a permission prompt) — BUT only when the allow-list holds
+   *     no `*` (Amazon Q's allowedTools does NOT accept the `"*"` wildcard;
+   *     agent-format.md "AllowedTools Field"). When allow is exactly ["*"] we set
+   *     `tools` but omit `allowedTools` (every tool available, none auto-allowed).
+   *   `deny` has no clean Amazon Q analog (there is no disallowedTools field —
+   *   access is an allow-list), so a deny-only policy maps to no tool keys.
+   *   `readonly` is likewise dropped — Amazon Q has no read-only-agent field; the
+   *   permission model IS the allowedTools allow-list (no separate analog).
+   *   `extra` is shallow-merged last (per-platform escape hatch).
+   */
+  renderSubagent(agent) {
+    const obj = {
+      name: agent.name,
+      description: agent.description,
+      prompt: agent.prompt
+    };
+    if (agent.model !== void 0 && agent.model !== "inherit") obj.model = agent.model;
+    const allow = agent.tools?.allow;
+    if (allow && allow.length > 0) {
+      obj.tools = [...allow];
+      const allowed = allow.filter((t) => t !== "*");
+      if (allowed.length > 0) obj.allowedTools = allowed;
+    }
+    if (agent.extra) Object.assign(obj, agent.extra);
+    return `${JSON.stringify(obj, null, 2)}
+`;
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const mcpPath = this.getServerConfigPath(ctx);
+    const agentPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    const checks = [
+      {
+        name: `${this.name}: mcp.json present`,
+        check: () => existsSync(mcpPath) ? { status: "OK", detail: mcpPath } : { status: "FAIL", detail: `not found: ${mcpPath}` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          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}: hook command registered`,
+        check: () => {
+          if (hookEvents.length === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const agent = this.readJson(agentPath);
+          if (!agent) return { status: "FAIL", detail: `cannot read ${agentPath}` };
+          const hooks = agent.hooks ?? {};
+          const registered = Object.values(hooks).some(
+            (entries) => (entries ?? []).some((e) => isHomeBinHookCommand(e.command, homeBin, connectorId))
+          );
+          return registered ? { status: "OK", detail: "hook command present" } : { status: "FAIL", detail: `no hook for ${connectorId} in ${agentPath}` };
+        }
+      }
+    ];
+    for (const agent of ctx.connector.subagents) {
+      if (agent.name === RESERVED_AGENT_NAME) continue;
+      const p = this.subagentPath(ctx, agent.name);
+      checks.push({
+        name: `${this.name}: subagent ${agent.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    return checks;
+  }
+  // ── Runtime: parse Amazon Q stdin JSON → normalized event ─────────────────
+  // Amazon Q's stdin payload shape and exit-code contract are IDENTICAL to kiro's
+  // (both AWS hosts in the same hook family); this parse + the formatReply context
+  // channel below follow Amazon Q's own primary-verified schema (docs/hooks.md):
+  // exit-code reply + PLAIN STDOUT context, gated to agentSpawn / userPromptSubmit.
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = typeof input.session_id === "string" ? input.session_id : "";
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolResponseToString(input.tool_response) !== void 0 ? { toolOutput: toolResponseToString(input.tool_response) } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported amazon-q hook event: ${String(event)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Amazon Q native (exit-code) hook reply ──
+  formatReply(event, response) {
+    const decision = response.decision ?? "allow";
+    if (decision === "deny") {
+      return { exitCode: 2, stderr: response.reason ?? "Blocked by hook" };
+    }
+    if (decision === "ask") {
+      return {
+        exitCode: 2,
+        stderr: response.reason ?? "Action requires user confirmation (security policy)"
+      };
+    }
+    if (event === "Stop") {
+      return { exitCode: 0 };
+    }
+    const trigger = EVENT_MAP[event];
+    if (decision === "context" && response.additionalContext && trigger !== void 0 && CONTEXT_TRIGGERS.has(trigger)) {
+      return { exitCode: 0, stdout: response.additionalContext };
+    }
+    return { exitCode: 0 };
+  }
+};
+function toolResponseToString(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var adapter = new AmazonQAdapter();
+var amazon_q_default = adapter;
+export {
+  AmazonQAdapter,
+  adapter,
+  amazon_q_default as default
+};
+//# sourceMappingURL=amazon-q-UFLBUSHG.js.map