@ken-jo/agent-connector 0.4.79 → 0.4.91

package/dist/codebuddy-RBEZGXBG.js

@@ -0,0 +1,643 @@
+#!/usr/bin/env node
+import {
+  extractSessionId,
+  normalizeSessionSource,
+  toolResponseToString
+} from "./chunk-H53QZQJI.js";
+import {
+  resolveEnvRefsDeep,
+  rewriteEnvRefs
+} from "./chunk-BEFVJ2OE.js";
+import {
+  BaseAdapter,
+  renderCommandMd,
+  renderSkillMd,
+  renderSubagentMd
+} from "./chunk-VVFDU4IX.js";
+import {
+  buildWrappedStdio,
+  isHomeBinHookCommand
+} from "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
+import "./chunk-IXOQDZWC.js";
+
+// src/adapters/codebuddy/index.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOST = "codebuddy";
+var MCP_ROOT_KEY = "mcpServers";
+var CONFIG_DIR_ENV = "CODEBUDDY_CONFIG_DIR";
+var CodeBuddyAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "CodeBuddy";
+  paradigm = "json-stdio";
+  capabilities = {
+    // CodeBuddy ships the full Claude hook set (bundle-confirmed event names).
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: true,
+    userPromptSubmit: true,
+    stop: true,
+    notification: true,
+    permissionRequest: true,
+    postToolUseFailure: true,
+    subagentStart: true,
+    subagentStop: true,
+    // Claude-fork reply envelope: PreToolUse can rewrite input (updatedInput);
+    // a PostToolUse hook cannot rewrite already-emitted output.
+    canModifyArgs: true,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    // settings.json hook keys are free-form event names, so any host event
+    // declared under platforms["codebuddy"].nativeHooks installs verbatim.
+    supportsNativeHooks: true,
+    transports: ["stdio", "http"],
+    // CodeBuddy preserves Claude's native ${VAR} interpolation in mcpServers
+    // env/url, so secret-bearing fields survive into the config (never baked).
+    nativeServerEnvInterpolation: true,
+    // Content surfaces under <configDir>/{commands,skills,agents}.
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true,
+    // Memory surface — EXCEPTION host: CodeBuddy reads CODEBUDDY.md (the fork's
+    // CLAUDE.md rename), NOT AGENTS.md, so memoryTargets below overrides the base
+    // AGENTS.md-first default.
+    supportsMemory: true
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = this.userConfigDir();
+    const userSettings = join(userDir, "settings.json");
+    const userServers = join(homedir(), ".codebuddy.json");
+    const projectServers = join(projectDir, ".mcp.json");
+    const userInstalled = existsSync(userDir) || existsSync(userSettings) || existsSync(userServers);
+    const projInstalled = existsSync(projectServers);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectServers : userSettings;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? scope === "project" ? `found project CodeBuddy config at ${projectServers}` : `found CodeBuddy config under ${userDir}` : `no CodeBuddy config at ${userDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  /** User config dir: `$CODEBUDDY_CONFIG_DIR` || `~/.codebuddy`. */
+  userConfigDir() {
+    const override = process.env[CONFIG_DIR_ENV];
+    return override && override.trim() !== "" ? override : join(homedir(), ".codebuddy");
+  }
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".codebuddy") : this.userConfigDir();
+  }
+  getServerConfigPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".mcp.json") : join(homedir(), ".codebuddy.json");
+  }
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "settings.json");
+  }
+  // ── 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 codebuddy" : "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 CodeBuddy'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 entry2 = { type: "stdio", command, args };
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      if (server.cwd) entry2.cwd = resolveEnvRefsDeep(server.cwd);
+      return entry2;
+    }
+    const entry = {
+      type: "http",
+      url: rewriteEnvRefs(server.url ?? "", codebuddyEnvToken)
+    };
+    if (server.headers) {
+      entry.headers = this.renderEnv(server.headers) ?? {};
+    }
+    return entry;
+  }
+  /**
+   * Render env/header values using CodeBuddy's native `${VAR}` interpolation
+   * (inherited from Claude Code), so `${env:VAR}` refs survive into the config
+   * rather than baking a secret. Literals pass through unchanged.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+      out[k] = rewriteEnvRefs(v, codebuddyEnvToken);
+    }
+    return out;
+  }
+  // ── Hook install / uninstall ─────────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST];
+    const normalizedEvents = override?.hooks === false ? [] : connector.hookEvents;
+    const nativeHooks = override?.nativeHooks ?? {};
+    const nativeEvents = Object.keys(nativeHooks);
+    if (normalizedEvents.length === 0 && nativeEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: override?.hooks === false ? "hooks disabled for codebuddy" : "connector declares no hooks"
+        }
+      ];
+    }
+    const settingsPath = this.getHookConfigPath(ctx);
+    const pending = [
+      ...normalizedEvents.map((event) => ({
+        event,
+        matcher: connector.hooks[event]?.matcher ?? ""
+      })),
+      ...nativeEvents.map((event) => ({
+        event,
+        matcher: nativeHooks[event]?.matcher ?? ""
+      }))
+    ];
+    return this.upsertHookEntries(ctx, settingsPath, pending, this.hookDescriptor());
+  }
+  uninstallHooks(ctx) {
+    return this.removeHookEntries(ctx, this.getHookConfigPath(ctx), this.hookDescriptor());
+  }
+  /**
+   * CodeBuddy's hook-merge descriptor — the Claude NESTED shape
+   * `{ matcher, hooks: [...] }`: install find = THIS command present in the
+   * entry's inner `hooks`; uninstall is inner-strip only (drop entries left
+   * empty); never remove a whole entry by ownership.
+   */
+  hookDescriptor() {
+    return {
+      renderEntry: (_event, matcher, command) => ({
+        matcher,
+        hooks: [{ type: "command", command }]
+      }),
+      entryOwnsCommand: (entry, command) => (entry.hooks ?? []).some((h) => h.command === command),
+      ownsEntryForRemove: () => () => false,
+      stripInner: (ctx) => (entry) => {
+        const innerBefore = entry.hooks?.length ?? 0;
+        const inner = (entry.hooks ?? []).filter((h) => !this.isOurCommand(h.command, ctx));
+        return {
+          next: inner.length > 0 ? { matcher: entry.matcher ?? "", hooks: inner } : null,
+          removed: innerBefore - inner.length
+        };
+      },
+      skipDetail: (event) => `hooks.${event} already registered`,
+      removeDetail: (event, removed) => `hooks.${event} (${removed})`,
+      absentDetail: "no hooks section present",
+      noMatchDetail: "no matching hook entries"
+    };
+  }
+  /** True when a hook command references our home binary AND this connector id. */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surfaces: commands / skills / subagents ──────────────────────
+  // Pure native-file writers under <configDir>/{commands,skills,agents}, the
+  // fork's confirmed surface dirs. Idempotent (byte-identical → skip) and
+  // reversible. Honors platforms["codebuddy"] per-surface `false` to skip.
+  commandsDir(ctx) {
+    return join(this.getConfigDir(ctx), "commands");
+  }
+  skillsDir(ctx) {
+    return join(this.getConfigDir(ctx), "skills");
+  }
+  agentsDir(ctx) {
+    return join(this.getConfigDir(ctx), "agents");
+  }
+  commandPath(ctx, name) {
+    return join(this.commandsDir(ctx), `${name}.md`);
+  }
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  subagentPath(ctx, name) {
+    return join(this.agentsDir(ctx), `${name}.md`);
+  }
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for codebuddy" }];
+    }
+    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)
+    );
+  }
+  renderCommand(cmd) {
+    return renderCommandMd(cmd);
+  }
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for codebuddy" }];
+    }
+    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;
+  }
+  renderSkill(skill) {
+    return renderSkillMd(skill);
+  }
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for codebuddy" }];
+    }
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => 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) => this.removeContentFile(this.subagentPath(ctx, agent.name), ctx.dryRun)
+    );
+  }
+  renderSubagent(agent) {
+    return renderSubagentMd(agent);
+  }
+  // ── Memory surface: CODEBUDDY.md managed block ────────────────────────────
+  // EXCEPTION host. CodeBuddy reads CODEBUDDY.md (the fork's CLAUDE.md rename),
+  // NOT AGENTS.md (bundle-confirmed path list), so the base AGENTS.md-first
+  // default is overridden. HTML-comment markers are correct here for the same
+  // reason as Claude Code (comment-stripped before context injection). Unlike
+  // claude-code this adapter does NOT ship the opt-in agents-import bridge —
+  // only the canonical block in the host's own memory file.
+  memoryFilePath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, "CODEBUDDY.md") : join(this.userConfigDir(), "CODEBUDDY.md");
+  }
+  memoryTargets(ctx) {
+    if (this.memoryOverride(ctx)?.path) return super.memoryTargets(ctx);
+    if (ctx.scope !== "project" && ctx.scope !== "user") return [];
+    return [
+      {
+        path: this.memoryFilePath(ctx),
+        reason: "CODEBUDDY.md (CodeBuddy reads CODEBUDDY.md, not AGENTS.md; HTML-comment markers are stripped from the model's context)"
+      }
+    ];
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const settingsPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const declaredHookCount = ctx.connector.hookEvents.length + Object.keys(ctx.connector.platforms[HOST]?.nativeHooks ?? {}).length;
+    const checks = [
+      {
+        name: `${this.name}: settings.json present`,
+        check: () => {
+          if (declaredHookCount === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          return existsSync(settingsPath) ? { status: "OK", detail: settingsPath } : { status: "FAIL", detail: `not found: ${settingsPath}` };
+        }
+      },
+      {
+        name: `${this.name}: hook command registered`,
+        check: () => {
+          if (declaredHookCount === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const settings = this.readJson(
+            settingsPath
+          );
+          if (!settings) return { status: "FAIL", detail: `cannot read ${settingsPath}` };
+          const hooks = settings.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" } : { status: "FAIL", detail: `no hook for ${connectorId} in ${settingsPath}` };
+        }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = this.commandPath(ctx, cmd.name);
+      checks.push({
+        name: `${this.name}: command ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(this.skillDir(ctx, skill.name), "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const agent of ctx.connector.subagents) {
+      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 CodeBuddy stdin JSON → normalized event ────────────────
+  // CodeBuddy's wire is the Claude shape (snake_case fields, PascalCase events),
+  // so the claude-code/wire helpers (extractSessionId, toolResponseToString,
+  // normalizeSessionSource) apply 1:1.
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = extractSessionId(input);
+    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 "SessionEnd": {
+        const ev = {
+          ...base,
+          ...typeof input.reason === "string" ? { reason: input.reason } : {}
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "PreCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "Notification": {
+        const ev = {
+          ...base,
+          message: typeof input.message === "string" ? input.message : ""
+        };
+        return ev;
+      }
+      case "PermissionRequest": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...Array.isArray(input.permission_suggestions) ? { permissionSuggestions: input.permission_suggestions } : {}
+        };
+        return ev;
+      }
+      case "PostToolUseFailure": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          error: typeof input.error === "string" ? input.error : "",
+          ...typeof input.tool_use_id === "string" ? { toolUseId: input.tool_use_id } : {},
+          ...typeof input.is_interrupt === "boolean" ? { isInterrupt: input.is_interrupt } : {},
+          ...typeof input.duration_ms === "number" ? { durationMs: input.duration_ms } : {}
+        };
+        return ev;
+      }
+      case "SubagentStart": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {}
+        };
+        return ev;
+      }
+      case "SubagentStop": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {},
+          ...typeof input.agent_transcript_path === "string" ? { agentTranscriptPath: input.agent_transcript_path } : {},
+          ...typeof input.last_assistant_message === "string" ? { lastAssistantMessage: input.last_assistant_message } : {},
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "PostCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      default: {
+        const _never = event;
+        throw new Error(`unsupported codebuddy hook event: ${String(_never)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → CodeBuddy native hook reply ────────────
+  // Identical envelope to Claude Code (bundle-confirmed: hookSpecificOutput,
+  // permissionDecision/permissionDecisionReason, additionalContext,
+  // updatedInput; Stop-class blocks use the top-level decision:"block").
+  formatReply(event, response) {
+    const hookEventName = event;
+    const decision = response.decision ?? "allow";
+    if (event === "PermissionRequest") {
+      if (response.decision === "deny") {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: { behavior: "deny", message: response.reason ?? "Blocked by hook" }
+          }
+        });
+      }
+      if (response.decision === "allow" || response.decision === "modify" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: {
+              behavior: "allow",
+              ...response.updatedInput ? { updatedInput: response.updatedInput } : {}
+            }
+          }
+        });
+      }
+      return { exitCode: 0 };
+    }
+    if (event === "PostToolUseFailure" || event === "SubagentStart") {
+      const context = decision === "context" ? response.additionalContext : decision === "deny" ? response.reason ?? response.additionalContext : void 0;
+      if (context) {
+        return this.stdout({ hookSpecificOutput: { hookEventName, additionalContext: context } });
+      }
+      return { exitCode: 0 };
+    }
+    if (decision === "deny") {
+      if (event === "Stop" || event === "SubagentStop" || event === "UserPromptSubmit" || event === "PostToolUse") {
+        return this.stdout({ decision: "block", reason: response.reason ?? "Blocked by hook" });
+      }
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "deny",
+          permissionDecisionReason: response.reason ?? "Blocked by hook"
+        }
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "ask",
+          permissionDecisionReason: response.reason ?? "Confirmation required by hook"
+        }
+      });
+    }
+    if (decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: { hookEventName, updatedInput: response.updatedInput }
+        });
+      }
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({
+        hookSpecificOutput: { hookEventName, additionalContext: response.additionalContext }
+      });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function codebuddyEnvToken(name) {
+  return `\${${name}}`;
+}
+var adapter = new CodeBuddyAdapter();
+var codebuddy_default = adapter;
+export {
+  CodeBuddyAdapter,
+  adapter,
+  codebuddy_default as default
+};
+//# sourceMappingURL=codebuddy-RBEZGXBG.js.map