@premierstudio/ai-hooks 1.1.3 → 1.1.5

package/dist/adapters/all.js

@@ -1,2058 +1,4 @@
-import { existsSync } from 'fs';
-import { readFile, mkdir, writeFile, rm } from 'fs/promises';
-import { resolve, dirname } from 'path';
-
-// src/adapters/registry.ts
-var AdapterRegistry = class {
-  adapters = /* @__PURE__ */ new Map();
-  factories = /* @__PURE__ */ new Map();
-  /**
-   * Register an adapter instance.
-   */
-  register(adapter10) {
-    this.adapters.set(adapter10.id, adapter10);
-  }
-  /**
-   * Register an adapter factory for lazy instantiation.
-   */
-  registerFactory(id, factory) {
-    this.factories.set(id, factory);
-  }
-  /**
-   * Get a registered adapter by ID.
-   */
-  get(id) {
-    const existing = this.adapters.get(id);
-    if (existing) return existing;
-    const factory = this.factories.get(id);
-    if (factory) {
-      const adapter10 = factory();
-      this.adapters.set(id, adapter10);
-      return adapter10;
-    }
-    return void 0;
-  }
-  /**
-   * Get all registered adapter IDs.
-   */
-  list() {
-    return [.../* @__PURE__ */ new Set([...this.adapters.keys(), ...this.factories.keys()])];
-  }
-  /**
-   * Detect which tools are available in the current environment.
-   * Returns adapters that successfully detect their tool.
-   */
-  async detectAll() {
-    const detected = [];
-    for (const id of this.list()) {
-      const adapter10 = this.get(id);
-      if (adapter10) {
-        try {
-          const found = await adapter10.detect();
-          if (found) {
-            detected.push(adapter10);
-          }
-        } catch {
-        }
-      }
-    }
-    return detected;
-  }
-  /**
-   * Clear the registry. Useful for testing.
-   */
-  clear() {
-    this.adapters.clear();
-    this.factories.clear();
-  }
-};
-var registry = new AdapterRegistry();
-var BaseAdapter = class {
-  /**
-   * Default install: write generated configs to disk.
-   */
-  async install(configs) {
-    for (const config of configs) {
-      const fullPath = resolve(process.cwd(), config.path);
-      await mkdir(dirname(fullPath), { recursive: true });
-      await writeFile(fullPath, config.content, "utf-8");
-    }
-  }
-  /**
-   * Default uninstall: remove generated config files.
-   */
-  async uninstall() {
-  }
-  // ── Utility Methods ───────────────────────────────────────
-  async fileExists(path) {
-    return existsSync(resolve(process.cwd(), path));
-  }
-  async readJsonFile(path) {
-    const fullPath = resolve(process.cwd(), path);
-    if (!existsSync(fullPath)) return null;
-    const content = await readFile(fullPath, "utf-8");
-    return JSON.parse(content);
-  }
-  async writeJsonFile(path, data) {
-    const fullPath = resolve(process.cwd(), path);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
-  }
-  async removeFile(path) {
-    const fullPath = resolve(process.cwd(), path);
-    if (existsSync(fullPath)) {
-      await rm(fullPath);
-    }
-  }
-  /**
-   * Check if a CLI command exists on PATH.
-   */
-  async commandExists(command) {
-    const { exec } = await import('child_process');
-    return new Promise((resolve11) => {
-      exec(`which ${command}`, (error) => {
-        resolve11(!error);
-      });
-    });
-  }
-};
-var EVENT_MAP = {
-  "session:start": [],
-  "session:end": [],
-  "prompt:submit": [],
-  "prompt:response": [],
-  "tool:before": ["tool:pre-execute"],
-  "tool:after": ["tool:post-execute"],
-  "file:write": ["tool:pre-execute"],
-  "file:edit": ["tool:pre-execute"],
-  "file:delete": ["tool:pre-execute"],
-  "shell:before": ["tool:pre-execute"],
-  "shell:after": ["tool:post-execute"],
-  "mcp:before": ["tool:pre-execute"],
-  "mcp:after": ["tool:post-execute"]
-};
-var REVERSE_MAP = {
-  "tool:pre-execute": [
-    "tool:before",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  "tool:post-execute": ["tool:after", "shell:after", "mcp:after"]
-};
-var AmpAdapter = class extends BaseAdapter {
-  id = "amp";
-  name = "Amp";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: false,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "tool:before",
-      "tool:after",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after"
-    ],
-    blockableEvents: []
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("amp");
-    const hasDir = existsSync(resolve(process.cwd(), ".amp"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const mcpConfig = {
-      mcpServers: {
-        "ai-hooks": {
-          command: "npx",
-          args: ["@premierstudio/mcp-server"],
-          env: {
-            AI_HOOKS_CONFIG: resolve(process.cwd(), "ai-hooks.config.ts")
-          }
-        }
-      }
-    };
-    configs.push({
-      path: ".amp/mcp.json",
-      content: JSON.stringify(mcpConfig, null, 2) + "\n",
-      format: "json"
-    });
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    const hooksList = hooks.map((h) => ({
-      id: h.id,
-      name: h.name,
-      events: h.events,
-      phase: h.phase,
-      nativeEvents: h.events.flatMap((e) => this.mapEvent(e))
-    }));
-    configs.push({
-      path: ".amp/ai-hooks-manifest.json",
-      content: JSON.stringify(
-        {
-          adapter: "amp",
-          version: "1.0",
-          hooks: hooksList,
-          nativeEvents: [...neededEvents],
-          mcpServer: "@premierstudio/mcp-server"
-        },
-        null,
-        2
-      ) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".amp/mcp.json");
-    await this.removeFile(".amp/ai-hooks-manifest.json");
-  }
-};
-var adapter = new AmpAdapter();
-registry.register(adapter);
-var EVENT_MAP2 = {
-  "session:start": ["SessionStart"],
-  "session:end": [],
-  "prompt:submit": ["UserPromptSubmit"],
-  "prompt:response": ["PostToolUse"],
-  // approximate - Claude doesn't expose response directly
-  "tool:before": ["PreToolUse"],
-  "tool:after": ["PostToolUse"],
-  "file:read": ["PreToolUse"],
-  // Read tool
-  "file:write": ["PreToolUse"],
-  // Write tool
-  "file:edit": ["PreToolUse"],
-  // Edit tool
-  "file:delete": ["PreToolUse"],
-  "shell:before": ["PreToolUse"],
-  // Bash tool
-  "shell:after": ["PostToolUse"],
-  // Bash tool
-  "mcp:before": ["PreToolUse"],
-  "mcp:after": ["PostToolUse"],
-  notification: ["Notification"]
-};
-var REVERSE_MAP2 = {
-  SessionStart: ["session:start"],
-  UserPromptSubmit: ["prompt:submit"],
-  PreToolUse: [
-    "tool:before",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  PostToolUse: ["tool:after", "shell:after", "mcp:after"],
-  Notification: ["notification"]
-};
-var ClaudeCodeAdapter = class extends BaseAdapter {
-  id = "claude-code";
-  name = "Claude Code";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "prompt:submit",
-      "tool:before",
-      "tool:after",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after",
-      "notification"
-    ],
-    blockableEvents: [
-      "prompt:submit",
-      "tool:before",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("claude");
-    const hasDir = existsSync(resolve(process.cwd(), ".claude"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    configs.push(this.generateRunner());
-    configs.push(await this.generateSettings(hooks));
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP2[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP2[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".claude/hooks/ai-hooks-runner.js");
-  }
-  // -- Private Methods ---------------------------------------------
-  /**
-   * Generate the hook runner script that Claude Code hooks call.
-   * This script loads the ai-hooks config and runs the appropriate chain.
-   */
-  generateRunner() {
-    const script = `#!/usr/bin/env node
-/**
- * ai-hooks runner for Claude Code.
- * Generated by: ai-hooks generate
- *
- * This script is called by Claude Code hooks. It loads your
- * ai-hooks.config.ts and runs the matching hook chain.
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-
-import { loadConfig } from "@premierstudio/ai-hooks";
-import { HookEngine } from "@premierstudio/ai-hooks";
-
-const hookEvent = process.env.CLAUDE_HOOK_EVENT;
-const toolName = process.env.CLAUDE_TOOL_NAME;
-const inputJson = process.env.CLAUDE_TOOL_INPUT;
-
-async function run() {
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-
-  // Build the event from Claude Code's environment variables
-  const event = buildEvent(hookEvent, toolName, inputJson);
-  if (!event) {
-    process.exit(0);
-  }
-
-  const toolInfo = { name: "claude-code", version: "1.0" };
-  const results = await engine.emit(event, toolInfo);
-
-  // Check for blocks
-  const blocked = results.find((r) => r.blocked);
-  if (blocked) {
-    // Claude Code reads stdout JSON for hook results
-    const output = JSON.stringify({
-      decision: "block",
-      reason: blocked.reason ?? "Blocked by ai-hooks",
-    });
-    process.stdout.write(output);
-    process.exit(0);
-  }
-
-  process.exit(0);
-}
-
-function buildEvent(hookEvent, toolName, inputJson) {
-  const timestamp = Date.now();
-  const metadata = {};
-
-  try {
-    const input = inputJson ? JSON.parse(inputJson) : {};
-
-    switch (hookEvent) {
-      case "PreToolUse":
-        return resolvePreToolUse(toolName, input, timestamp, metadata);
-      case "PostToolUse":
-        return resolvePostToolUse(toolName, input, timestamp, metadata);
-      case "SessionStart":
-        return {
-          type: "session:start",
-          tool: "claude-code",
-          version: "1.0",
-          workingDirectory: process.cwd(),
-          timestamp,
-          metadata,
-        };
-      case "UserPromptSubmit":
-        return {
-          type: "prompt:submit",
-          prompt: input.prompt ?? "",
-          timestamp,
-          metadata,
-        };
-      default:
-        return null;
-    }
-  } catch {
-    return null;
-  }
-}
-
-function resolvePreToolUse(toolName, input, timestamp, metadata) {
-  switch (toolName) {
-    case "Write":
-      return {
-        type: "file:write",
-        path: input.file_path ?? "",
-        content: input.content ?? "",
-        timestamp,
-        metadata,
-      };
-    case "Edit":
-      return {
-        type: "file:edit",
-        path: input.file_path ?? "",
-        oldContent: input.old_string ?? "",
-        newContent: input.new_string ?? "",
-        timestamp,
-        metadata,
-      };
-    case "Bash":
-      return {
-        type: "shell:before",
-        command: input.command ?? "",
-        cwd: process.cwd(),
-        timestamp,
-        metadata,
-      };
-    default:
-      return {
-        type: "tool:before",
-        toolName: toolName ?? "unknown",
-        input: input ?? {},
-        timestamp,
-        metadata,
-      };
-  }
-}
-
-function resolvePostToolUse(toolName, input, timestamp, metadata) {
-  switch (toolName) {
-    case "Bash":
-      return {
-        type: "shell:after",
-        command: input.command ?? "",
-        cwd: process.cwd(),
-        exitCode: input.exitCode ?? 0,
-        stdout: input.stdout ?? "",
-        stderr: input.stderr ?? "",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-    default:
-      return {
-        type: "tool:after",
-        toolName: toolName ?? "unknown",
-        input: input ?? {},
-        output: {},
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-  }
-}
-
-run().catch((err) => {
-  console.error("[ai-hooks] Error:", err.message);
-  process.exit(1);
-});
-`;
-    return {
-      path: ".claude/hooks/ai-hooks-runner.js",
-      content: script,
-      format: "js",
-      gitignore: false
-    };
-  }
-  /**
-   * Generate the Claude Code settings.json hook entries.
-   */
-  async generateSettings(hooks) {
-    const settingsPath = ".claude/settings.json";
-    let existing = {};
-    const fullPath = resolve(process.cwd(), settingsPath);
-    if (existsSync(fullPath)) {
-      const raw = await readFile(fullPath, "utf-8");
-      existing = JSON.parse(raw);
-    }
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    const hooksConfig = {};
-    for (const event of neededEvents) {
-      const hookEntry = {
-        type: "command",
-        command: `node .claude/hooks/ai-hooks-runner.js`,
-        timeout: 10,
-        description: `ai-hooks: ${event}`
-      };
-      if (!hooksConfig[event]) {
-        hooksConfig[event] = [];
-      }
-      hooksConfig[event].push({
-        hooks: [hookEntry]
-      });
-    }
-    const existingHooks = existing.hooks ?? {};
-    const mergedHooks = { ...existingHooks };
-    for (const [event, entries] of Object.entries(hooksConfig)) {
-      if (!mergedHooks[event]) {
-        mergedHooks[event] = [];
-      }
-      mergedHooks[event] = mergedHooks[event].filter((entry) => !entry.hooks?.some((h) => h.description?.startsWith("ai-hooks:")));
-      mergedHooks[event].push(...entries);
-    }
-    const mergedSettings = {
-      ...existing,
-      hooks: mergedHooks
-    };
-    return {
-      path: settingsPath,
-      content: JSON.stringify(mergedSettings, null, 2) + "\n",
-      format: "json",
-      gitignore: false
-    };
-  }
-};
-var adapter2 = new ClaudeCodeAdapter();
-registry.register(adapter2);
-var EVENT_MAP3 = {
-  "session:start": ["TaskStart"],
-  "session:end": ["TaskCancel"],
-  "prompt:submit": ["UserPromptSubmit"],
-  "prompt:response": [],
-  "tool:before": ["PreToolUse"],
-  "tool:after": ["PostToolUse"],
-  "file:read": ["PreToolUse"],
-  "file:write": ["PreToolUse"],
-  "file:edit": ["PreToolUse"],
-  "file:delete": ["PreToolUse"],
-  "shell:before": ["PreToolUse"],
-  "shell:after": ["PostToolUse"],
-  "mcp:before": ["PreToolUse"],
-  "mcp:after": ["PostToolUse"],
-  notification: []
-};
-var REVERSE_MAP3 = {
-  TaskStart: ["session:start"],
-  TaskCancel: ["session:end"],
-  TaskResume: ["session:start"],
-  UserPromptSubmit: ["prompt:submit"],
-  PreToolUse: [
-    "tool:before",
-    "file:read",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  PostToolUse: ["tool:after", "shell:after", "mcp:after"],
-  PreCompact: []
-};
-var ClineAdapter = class extends BaseAdapter {
-  id = "cline";
-  name = "Cline";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "tool:before",
-      "tool:after",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after"
-    ],
-    blockableEvents: [
-      "tool:before",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("cline");
-    const hasDir = existsSync(resolve(process.cwd(), ".clinerules"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    for (const event of neededEvents) {
-      configs.push({
-        path: `.clinerules/hooks/${event}`,
-        content: this.generateHookScript(event),
-        format: "js"
-      });
-    }
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP3[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP3[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    const hookNames = [
-      "PreToolUse",
-      "PostToolUse",
-      "UserPromptSubmit",
-      "TaskStart",
-      "TaskResume",
-      "TaskCancel",
-      "PreCompact"
-    ];
-    for (const name of hookNames) {
-      await this.removeFile(`.clinerules/hooks/${name}`);
-    }
-  }
-  generateHookScript(eventName) {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Cline (${eventName}).
- * Generated by: ai-hooks generate
- *
- * Cline passes hook event data as JSON via STDIN with:
- *   hookName, taskId, workspaceRoots, pendingToolInfo, etc.
- *
- * Output JSON with { cancel: true, errorMessage: "..." } to block.
- * Output JSON with { cancel: false } to allow.
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-
-async function run() {
-  const raw = await readStdin();
-  const input = JSON.parse(raw || "{}");
-  const hookName = input.hookName ?? "${eventName}";
-  const pendingToolInfo = input.pendingToolInfo ?? {};
-  const toolName = pendingToolInfo.toolName ?? "";
-
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "cline", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = { taskId: input.taskId ?? "" };
-
-  let event;
-  switch (hookName) {
-    case "TaskStart":
-    case "TaskResume":
-      event = {
-        type: "session:start",
-        tool: "cline",
-        version: "1.0",
-        workingDirectory: (input.workspaceRoots ?? [])[0] ?? process.cwd(),
-        timestamp,
-        metadata,
-      };
-      break;
-    case "TaskCancel":
-      event = { type: "session:end", tool: "cline", duration: 0, timestamp, metadata };
-      break;
-    case "UserPromptSubmit":
-      event = { type: "prompt:submit", prompt: input.userMessage ?? "", timestamp, metadata };
-      break;
-    case "PreToolUse":
-      event = resolvePreToolEvent(toolName, pendingToolInfo, timestamp, metadata);
-      break;
-    case "PostToolUse":
-      event = resolvePostToolEvent(toolName, pendingToolInfo, timestamp, metadata);
-      break;
-    default:
-      process.stdout.write(JSON.stringify({ cancel: false }));
-      process.exit(0);
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    process.stdout.write(JSON.stringify({
-      cancel: true,
-      errorMessage: blocked.reason ?? "Blocked by ai-hooks",
-    }));
-    process.exit(0);
-  }
-
-  process.stdout.write(JSON.stringify({ cancel: false }));
-}
-
-function resolvePreToolEvent(toolName, info, timestamp, metadata) {
-  switch (toolName) {
-    case "write_to_file":
-      return { type: "file:write", path: info.path ?? "", content: info.content ?? "", timestamp, metadata };
-    case "replace_in_file":
-      return { type: "file:edit", path: info.path ?? "", oldContent: info.diff ?? "", newContent: "", timestamp, metadata };
-    case "read_file":
-      return { type: "file:read", path: info.path ?? "", timestamp, metadata };
-    case "execute_command":
-      return { type: "shell:before", command: info.command ?? "", cwd: process.cwd(), timestamp, metadata };
-    case "use_mcp_tool":
-      return { type: "mcp:before", server: info.mcpServer ?? "", tool: info.mcpTool ?? "", input: {}, timestamp, metadata };
-    default:
-      return { type: "tool:before", toolName: toolName || "unknown", input: info, timestamp, metadata };
-  }
-}
-
-function resolvePostToolEvent(toolName, info, timestamp, metadata) {
-  switch (toolName) {
-    case "execute_command":
-      return {
-        type: "shell:after",
-        command: info.command ?? "",
-        cwd: process.cwd(),
-        exitCode: 0,
-        stdout: "",
-        stderr: "",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-    default:
-      return { type: "tool:after", toolName: toolName || "unknown", input: info, output: {}, duration: 0, timestamp, metadata };
-  }
-}
-
-run().catch((err) => {
-  console.error("[ai-hooks] Error:", err.message);
-  process.stdout.write(JSON.stringify({ cancel: false }));
-  process.exit(0);
-});
-`;
-  }
-};
-var adapter3 = new ClineAdapter();
-registry.register(adapter3);
-var EVENT_MAP4 = {
-  "session:start": ["session_start"],
-  "session:end": ["session_end"],
-  "prompt:submit": ["user_message"],
-  "prompt:response": ["assistant_message"],
-  "tool:before": ["before_tool_call"],
-  "tool:after": ["after_tool_call"],
-  "file:write": ["before_file_write"],
-  "file:edit": ["before_file_edit"],
-  "file:delete": ["before_file_delete"],
-  "shell:before": ["before_shell"],
-  "shell:after": ["after_shell"],
-  "mcp:before": ["before_mcp_call"],
-  "mcp:after": ["after_mcp_call"]
-};
-var REVERSE_MAP4 = {
-  session_start: ["session:start"],
-  session_end: ["session:end"],
-  user_message: ["prompt:submit"],
-  assistant_message: ["prompt:response"],
-  before_tool_call: ["tool:before"],
-  after_tool_call: ["tool:after"],
-  before_file_write: ["file:write"],
-  before_file_edit: ["file:edit"],
-  before_file_delete: ["file:delete"],
-  before_shell: ["shell:before"],
-  after_shell: ["shell:after"],
-  before_mcp_call: ["mcp:before"],
-  after_mcp_call: ["mcp:after"]
-};
-var CodexAdapter = class extends BaseAdapter {
-  id = "codex";
-  name = "Codex CLI";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "tool:after",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after"
-    ],
-    blockableEvents: [
-      "tool:before",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("codex");
-    const hasConfig = existsSync(resolve(process.cwd(), "codex.json")) || existsSync(resolve(process.cwd(), ".codex"));
-    return hasCommand || hasConfig;
-  }
-  async generate(hooks) {
-    const hookEntries = {};
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          hookEntries[ne] = {
-            command: "node .codex/hooks/ai-hooks-runner.js",
-            timeout: 10
-          };
-        }
-      }
-    }
-    return [
-      {
-        path: ".codex/hooks/ai-hooks-runner.js",
-        content: this.generateRunner(),
-        format: "js"
-      },
-      {
-        path: "codex.json",
-        content: JSON.stringify({ hooks: hookEntries }, null, 2) + "\n",
-        format: "json"
-      }
-    ];
-  }
-  mapEvent(event) {
-    return EVENT_MAP4[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP4[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".codex/hooks/ai-hooks-runner.js");
-  }
-  generateRunner() {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Codex CLI.
- * Generated by: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-const hookEvent = process.env.CODEX_HOOK_EVENT;
-const toolInput = process.env.CODEX_TOOL_INPUT;
-
-async function run() {
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "codex", version: "1.0" };
-
-  const input = toolInput ? JSON.parse(toolInput) : {};
-  const timestamp = Date.now();
-  const metadata = {};
-
-  let event;
-  switch (hookEvent) {
-    case "before_shell":
-      event = { type: "shell:before", command: input.command ?? "", cwd: process.cwd(), timestamp, metadata };
-      break;
-    case "before_file_write":
-      event = { type: "file:write", path: input.path ?? "", content: input.content ?? "", timestamp, metadata };
-      break;
-    case "before_file_edit":
-      event = { type: "file:edit", path: input.path ?? "", oldContent: input.old ?? "", newContent: input.new ?? "", timestamp, metadata };
-      break;
-    default:
-      event = { type: "tool:before", toolName: hookEvent ?? "unknown", input, timestamp, metadata };
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    console.log(JSON.stringify({ blocked: true, reason: blocked.reason }));
-    process.exit(1);
-  }
-}
-
-run().catch(() => process.exit(1));
-`;
-  }
-};
-var adapter4 = new CodexAdapter();
-registry.register(adapter4);
-var EVENT_MAP5 = {
-  "session:start": [],
-  "session:end": ["stop"],
-  "prompt:submit": ["beforeSubmitPrompt"],
-  "prompt:response": ["stop"],
-  "tool:before": ["beforeMCPExecution"],
-  "tool:after": [],
-  "file:read": ["beforeReadFile"],
-  "file:write": ["afterFileEdit"],
-  "file:edit": ["afterFileEdit"],
-  "file:delete": [],
-  "shell:before": ["beforeShellExecution"],
-  "shell:after": [],
-  "mcp:before": ["beforeMCPExecution"],
-  "mcp:after": []
-};
-var REVERSE_MAP5 = {
-  beforeSubmitPrompt: ["prompt:submit"],
-  beforeShellExecution: ["shell:before"],
-  beforeMCPExecution: ["tool:before", "mcp:before"],
-  beforeReadFile: ["file:read"],
-  afterFileEdit: ["file:write", "file:edit"],
-  stop: ["session:end", "prompt:response"]
-};
-var CursorAdapter = class extends BaseAdapter {
-  id = "cursor";
-  name = "Cursor";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "shell:before",
-      "mcp:before"
-    ],
-    blockableEvents: ["shell:before", "mcp:before", "tool:before"]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("cursor");
-    const hasDir = existsSync(resolve(process.cwd(), ".cursor"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    configs.push({
-      path: ".cursor/hooks/ai-hooks-runner.js",
-      content: this.generateRunner(),
-      format: "js"
-    });
-    const hooksConfig = {};
-    for (const event of neededEvents) {
-      if (!hooksConfig[event]) {
-        hooksConfig[event] = [];
-      }
-      hooksConfig[event].push({
-        command: `node hooks/ai-hooks-runner.js ${event}`
-      });
-    }
-    configs.push({
-      path: ".cursor/hooks.json",
-      content: JSON.stringify({ version: 1, hooks: hooksConfig }, null, 2) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP5[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP5[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".cursor/hooks/ai-hooks-runner.js");
-    await this.removeFile(".cursor/hooks.json");
-  }
-  generateRunner() {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Cursor.
- * Generated by: ai-hooks generate
- *
- * Cursor passes the hook event name as a CLI argument.
- * Blocking hooks (beforeShellExecution, beforeMCPExecution)
- * return JSON: { "permission": "deny", "agentMessage": "reason" }
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-
-async function run() {
-  const hookEventName = process.argv[2] ?? "";
-  let input = {};
-  try {
-    const raw = await readStdin();
-    input = JSON.parse(raw || "{}");
-  } catch {
-    input = {};
-  }
-
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "cursor", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = {};
-
-  let event;
-  switch (hookEventName) {
-    case "beforeSubmitPrompt":
-      event = { type: "prompt:submit", prompt: input.prompt ?? "", timestamp, metadata };
-      break;
-    case "beforeShellExecution":
-      event = { type: "shell:before", command: input.command ?? "", cwd: process.cwd(), timestamp, metadata };
-      break;
-    case "beforeMCPExecution":
-      event = { type: "mcp:before", server: input.server ?? "", method: input.method ?? "", params: input.params ?? {}, timestamp, metadata };
-      break;
-    case "beforeReadFile":
-      event = { type: "file:read", path: input.path ?? "", timestamp, metadata };
-      break;
-    case "afterFileEdit":
-      event = { type: "file:edit", path: input.path ?? "", oldContent: "", newContent: "", timestamp, metadata };
-      break;
-    case "stop":
-      event = { type: "session:end", tool: "cursor", duration: 0, timestamp, metadata };
-      break;
-    default:
-      process.exit(0);
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    const response = JSON.stringify({
-      permission: "deny",
-      agentMessage: blocked.reason ?? "Blocked by ai-hooks",
-      userMessage: blocked.reason ?? "Blocked by ai-hooks",
-    });
-    process.stdout.write(response);
-    process.exit(0);
-  }
-
-  if (hookEventName === "beforeShellExecution" || hookEventName === "beforeMCPExecution") {
-    process.stdout.write(JSON.stringify({ permission: "allow" }));
-  }
-}
-
-run().catch((err) => {
-  console.error("[ai-hooks] Error:", err.message);
-  process.exit(1);
-});
-`;
-  }
-};
-var adapter5 = new CursorAdapter();
-registry.register(adapter5);
-var EVENT_MAP6 = {
-  "session:start": ["SessionStart"],
-  "session:end": ["SessionEnd"],
-  "prompt:submit": ["UserPromptSubmit"],
-  "prompt:response": ["Stop"],
-  "tool:before": ["PreToolUse"],
-  "tool:after": ["PostToolUse"],
-  "file:read": ["PreToolUse"],
-  "file:write": ["PreToolUse"],
-  "file:edit": ["PreToolUse"],
-  "file:delete": ["PreToolUse"],
-  "shell:before": ["PreToolUse"],
-  "shell:after": ["PostToolUse"],
-  "mcp:before": ["PreToolUse"],
-  "mcp:after": ["PostToolUse"],
-  notification: ["Notification"]
-};
-var REVERSE_MAP6 = {
-  SessionStart: ["session:start"],
-  SessionEnd: ["session:end"],
-  UserPromptSubmit: ["prompt:submit"],
-  Stop: ["prompt:response"],
-  PreToolUse: [
-    "tool:before",
-    "file:read",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  PostToolUse: ["tool:after", "shell:after", "mcp:after"],
-  Notification: ["notification"]
-};
-var DroidAdapter = class extends BaseAdapter {
-  id = "droid";
-  name = "Factory Droid";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "tool:after",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after",
-      "notification"
-    ],
-    blockableEvents: [
-      "tool:before",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("droid");
-    const hasDir = existsSync(resolve(process.cwd(), ".factory"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    configs.push({
-      path: ".factory/hooks/ai-hooks-runner.js",
-      content: this.generateRunner(),
-      format: "js"
-    });
-    const hooksConfig = {};
-    const runnerAbsPath = resolve(process.cwd(), ".factory/hooks/ai-hooks-runner.js");
-    for (const event of neededEvents) {
-      const hookEntry = {
-        hooks: [
-          {
-            type: "command",
-            command: `node ${runnerAbsPath}`,
-            timeout: 30
-          }
-        ]
-      };
-      if (event === "PreToolUse" || event === "PostToolUse") {
-        hookEntry.matcher = "*";
-      }
-      if (!hooksConfig[event]) {
-        hooksConfig[event] = [];
-      }
-      hooksConfig[event].push(hookEntry);
-    }
-    const settingsConfig = await this.mergeSettings(hooksConfig);
-    configs.push({
-      path: ".factory/settings.json",
-      content: JSON.stringify(settingsConfig, null, 2) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP6[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP6[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".factory/hooks/ai-hooks-runner.js");
-  }
-  async mergeSettings(hooksConfig) {
-    const settingsPath = resolve(process.cwd(), ".factory/settings.json");
-    let existing = {};
-    if (existsSync(settingsPath)) {
-      const raw = await readFile(settingsPath, "utf-8");
-      existing = JSON.parse(raw);
-    }
-    const existingHooks = existing.hooks ?? {};
-    const mergedHooks = { ...existingHooks };
-    for (const [event, entries] of Object.entries(hooksConfig)) {
-      if (!mergedHooks[event]) {
-        mergedHooks[event] = [];
-      }
-      mergedHooks[event] = mergedHooks[event].filter((entry) => !entry.hooks?.some((h) => h.command?.includes("ai-hooks-runner")));
-      mergedHooks[event].push(...entries);
-    }
-    return {
-      ...existing,
-      hooks: mergedHooks
-    };
-  }
-  generateRunner() {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Factory Droid.
- * Generated by: ai-hooks generate
- *
- * Droid passes hook event data as JSON via STDIN with:
- *   hook_event_name, session_id, cwd, tool_name, tool_input, tool_response
- *
- * Exit code 0 = success, exit code 2 = block (PreToolUse).
- * STDERR on exit code 2 is fed back to Droid as context.
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-
-async function run() {
-  const raw = await readStdin();
-  const input = JSON.parse(raw || "{}");
-  const hookEventName = input.hook_event_name ?? "";
-  const toolName = input.tool_name ?? "";
-  const toolInput = input.tool_input ?? {};
-  const toolResponse = input.tool_response ?? {};
-
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "droid", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = { sessionId: input.session_id ?? "" };
-
-  let event;
-  switch (hookEventName) {
-    case "SessionStart":
-      event = {
-        type: "session:start",
-        tool: "droid",
-        version: "1.0",
-        workingDirectory: input.cwd ?? process.cwd(),
-        timestamp,
-        metadata,
-      };
-      break;
-    case "SessionEnd":
-      event = { type: "session:end", tool: "droid", duration: 0, timestamp, metadata };
-      break;
-    case "UserPromptSubmit":
-      event = { type: "prompt:submit", prompt: toolInput.prompt ?? "", timestamp, metadata };
-      break;
-    case "Notification":
-      event = { type: "notification", level: "info", message: toolInput.message ?? "", timestamp, metadata };
-      break;
-    case "Stop":
-      event = { type: "session:end", tool: "droid", duration: 0, timestamp, metadata };
-      break;
-    case "PreToolUse":
-      event = resolvePreToolEvent(toolName, toolInput, timestamp, metadata);
-      break;
-    case "PostToolUse":
-      event = resolvePostToolEvent(toolName, toolInput, toolResponse, timestamp, metadata);
-      break;
-    default:
-      process.exit(0);
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    process.stderr.write(blocked.reason ?? "Blocked by ai-hooks");
-    process.exit(2);
-  }
-}
-
-function resolvePreToolEvent(toolName, toolInput, timestamp, metadata) {
-  switch (toolName) {
-    case "Write":
-      return { type: "file:write", path: toolInput.file_path ?? "", content: toolInput.content ?? "", timestamp, metadata };
-    case "Edit":
-      return { type: "file:edit", path: toolInput.file_path ?? "", oldContent: toolInput.old_string ?? "", newContent: toolInput.new_string ?? "", timestamp, metadata };
-    case "Read":
-      return { type: "file:read", path: toolInput.file_path ?? "", timestamp, metadata };
-    case "Bash":
-      return { type: "shell:before", command: toolInput.command ?? "", cwd: process.cwd(), timestamp, metadata };
-    default:
-      return { type: "tool:before", toolName: toolName || "unknown", input: toolInput, timestamp, metadata };
-  }
-}
-
-function resolvePostToolEvent(toolName, toolInput, toolResponse, timestamp, metadata) {
-  switch (toolName) {
-    case "Bash":
-      return {
-        type: "shell:after",
-        command: toolInput.command ?? "",
-        cwd: process.cwd(),
-        exitCode: toolResponse.exitCode ?? 0,
-        stdout: toolResponse.stdout ?? "",
-        stderr: toolResponse.stderr ?? "",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-    default:
-      return { type: "tool:after", toolName: toolName || "unknown", input: toolInput, output: toolResponse, duration: 0, timestamp, metadata };
-  }
-}
-
-run().catch((err) => {
-  console.error("[ai-hooks] Error:", err.message);
-  process.exit(1);
-});
-`;
-  }
-};
-var adapter6 = new DroidAdapter();
-registry.register(adapter6);
-var EVENT_MAP7 = {
-  "session:start": ["SessionStart"],
-  "session:end": ["SessionEnd"],
-  "prompt:submit": ["BeforePrompt"],
-  "prompt:response": ["AfterResponse"],
-  "tool:before": ["BeforeTool"],
-  "tool:after": ["AfterTool"],
-  "file:write": ["BeforeTool"],
-  // FileWrite tool
-  "file:edit": ["BeforeTool"],
-  // FileEdit tool
-  "file:delete": ["BeforeTool"],
-  // FileDelete tool
-  "shell:before": ["BeforeShell"],
-  "shell:after": ["AfterShell"],
-  "mcp:before": ["BeforeTool"],
-  "mcp:after": ["AfterTool"]
-};
-var REVERSE_MAP7 = {
-  SessionStart: ["session:start"],
-  SessionEnd: ["session:end"],
-  BeforePrompt: ["prompt:submit"],
-  AfterResponse: ["prompt:response"],
-  BeforeTool: ["tool:before", "file:write", "file:edit", "file:delete", "mcp:before"],
-  AfterTool: ["tool:after", "mcp:after"],
-  BeforeShell: ["shell:before"],
-  AfterShell: ["shell:after"]
-};
-var GeminiCliAdapter = class extends BaseAdapter {
-  id = "gemini-cli";
-  name = "Gemini CLI";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "tool:after",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after"
-    ],
-    blockableEvents: [
-      "prompt:submit",
-      "tool:before",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("gemini");
-    const hasConfig = existsSync(resolve(process.cwd(), ".gemini"));
-    return hasCommand || hasConfig;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    for (const event of neededEvents) {
-      configs.push({
-        path: `.gemini/hooks/${event}.js`,
-        content: this.generateEventScript(event),
-        format: "js"
-      });
-    }
-    configs.push({
-      path: ".gemini/settings.json",
-      content: JSON.stringify(
-        {
-          hooks: {
-            enabled: true,
-            directory: ".gemini/hooks"
-          }
-        },
-        null,
-        2
-      ) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP7[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP7[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    for (const event of Object.keys(REVERSE_MAP7)) {
-      await this.removeFile(`.gemini/hooks/${event}.js`);
-    }
-  }
-  generateEventScript(nativeEvent) {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Gemini CLI (${nativeEvent}).
- * Generated by: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-const input = JSON.parse(process.env.GEMINI_HOOK_INPUT ?? "{}");
-
-async function run() {
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "gemini-cli", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = {};
-
-  let event;
-  switch ("${nativeEvent}") {
-    case "SessionStart":
-      event = { type: "session:start", tool: "gemini-cli", version: "1.0", workingDirectory: process.cwd(), timestamp, metadata };
-      break;
-    case "BeforeShell":
-      event = { type: "shell:before", command: input.command ?? "", cwd: process.cwd(), timestamp, metadata };
-      break;
-    case "BeforeTool":
-      event = { type: "tool:before", toolName: input.toolName ?? "unknown", input, timestamp, metadata };
-      break;
-    case "BeforePrompt":
-      event = { type: "prompt:submit", prompt: input.prompt ?? "", timestamp, metadata };
-      break;
-    default:
-      event = { type: "tool:after", toolName: "${nativeEvent}", input, output: {}, duration: 0, timestamp, metadata };
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    console.log(JSON.stringify({ blocked: true, reason: blocked.reason }));
-    process.exit(1);
-  }
-}
-
-run().catch(() => process.exit(1));
-`;
-  }
-};
-var adapter7 = new GeminiCliAdapter();
-registry.register(adapter7);
-var EVENT_MAP8 = {
-  "session:start": ["agentSpawn"],
-  "session:end": ["stop"],
-  "prompt:submit": ["userPromptSubmit"],
-  "prompt:response": ["stop"],
-  "tool:before": ["preToolUse"],
-  "tool:after": ["postToolUse"],
-  "file:read": ["preToolUse"],
-  "file:write": ["preToolUse"],
-  "file:edit": ["preToolUse"],
-  "file:delete": ["preToolUse"],
-  "shell:before": ["preToolUse"],
-  "shell:after": ["postToolUse"],
-  "mcp:before": ["preToolUse"],
-  "mcp:after": ["postToolUse"]
-};
-var REVERSE_MAP8 = {
-  agentSpawn: ["session:start"],
-  userPromptSubmit: ["prompt:submit"],
-  preToolUse: [
-    "tool:before",
-    "file:read",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  postToolUse: ["tool:after", "shell:after", "mcp:after"],
-  stop: ["session:end", "prompt:response"]
-};
-var KiroAdapter = class extends BaseAdapter {
-  id = "kiro";
-  name = "Kiro CLI";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "tool:after",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after"
-    ],
-    blockableEvents: [
-      "tool:before",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("kiro");
-    const hasDir = existsSync(resolve(process.cwd(), ".kiro"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    configs.push({
-      path: ".kiro/hooks/ai-hooks-runner.js",
-      content: this.generateRunner(),
-      format: "js"
-    });
-    const hooksConfig = {};
-    for (const event of neededEvents) {
-      const entry = {
-        command: "node .kiro/hooks/ai-hooks-runner.js"
-      };
-      if (event === "preToolUse" || event === "postToolUse") {
-        entry.matcher = "*";
-      }
-      if (!hooksConfig[event]) {
-        hooksConfig[event] = [];
-      }
-      hooksConfig[event].push(entry);
-    }
-    configs.push({
-      path: ".kiro/hooks/ai-hooks.json",
-      content: JSON.stringify({ hooks: hooksConfig }, null, 2) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP8[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP8[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".kiro/hooks/ai-hooks-runner.js");
-    await this.removeFile(".kiro/hooks/ai-hooks.json");
-  }
-  generateRunner() {
-    return `#!/usr/bin/env node
-/**
- * ai-hooks runner for Kiro CLI.
- * Generated by: ai-hooks generate
- *
- * Kiro passes hook event data as JSON via STDIN.
- * Exit code 0 = success, exit code 2 = block (preToolUse only).
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-
-async function run() {
-  const raw = await readStdin();
-  const input = JSON.parse(raw || "{}");
-  const hookEventName = input.hook_event_name ?? "";
-  const toolName = input.tool_name ?? "";
-  const toolInput = input.tool_input ?? {};
-
-  const config = await loadConfig();
-  const engine = new HookEngine(config);
-  const toolInfo = { name: "kiro", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = {};
-
-  let event;
-  switch (hookEventName) {
-    case "agentSpawn":
-      event = {
-        type: "session:start",
-        tool: "kiro",
-        version: "1.0",
-        workingDirectory: input.cwd ?? process.cwd(),
-        timestamp,
-        metadata,
-      };
-      break;
-    case "userPromptSubmit":
-      event = {
-        type: "prompt:submit",
-        prompt: toolInput.prompt ?? "",
-        timestamp,
-        metadata,
-      };
-      break;
-    case "preToolUse":
-      event = resolvePreToolEvent(toolName, toolInput, timestamp, metadata);
-      break;
-    case "postToolUse":
-      event = resolvePostToolEvent(toolName, toolInput, input.tool_response ?? {}, timestamp, metadata);
-      break;
-    case "stop":
-      event = {
-        type: "session:end",
-        tool: "kiro",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-      break;
-    default:
-      process.exit(0);
-  }
-
-  const results = await engine.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked) {
-    process.stderr.write(blocked.reason ?? "Blocked by ai-hooks");
-    process.exit(2);
-  }
-}
-
-function resolvePreToolEvent(toolName, toolInput, timestamp, metadata) {
-  switch (toolName) {
-    case "fs_write":
-    case "write":
-      return { type: "file:write", path: toolInput.path ?? "", content: toolInput.content ?? "", timestamp, metadata };
-    case "fs_edit":
-    case "edit":
-      return { type: "file:edit", path: toolInput.path ?? "", oldContent: toolInput.old_string ?? "", newContent: toolInput.new_string ?? "", timestamp, metadata };
-    case "fs_read":
-    case "read":
-      return { type: "file:read", path: toolInput.path ?? "", timestamp, metadata };
-    case "execute_bash":
-    case "shell":
-      return { type: "shell:before", command: toolInput.command ?? "", cwd: process.cwd(), timestamp, metadata };
-    default:
-      return { type: "tool:before", toolName: toolName || "unknown", input: toolInput, timestamp, metadata };
-  }
-}
-
-function resolvePostToolEvent(toolName, toolInput, toolResponse, timestamp, metadata) {
-  switch (toolName) {
-    case "execute_bash":
-    case "shell":
-      return {
-        type: "shell:after",
-        command: toolInput.command ?? "",
-        cwd: process.cwd(),
-        exitCode: toolResponse.exitCode ?? 0,
-        stdout: toolResponse.stdout ?? "",
-        stderr: toolResponse.stderr ?? "",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-    default:
-      return { type: "tool:after", toolName: toolName || "unknown", input: toolInput, output: toolResponse, duration: 0, timestamp, metadata };
-  }
-}
-
-run().catch((err) => {
-  console.error("[ai-hooks] Error:", err.message);
-  process.exit(1);
-});
-`;
-  }
-};
-var adapter8 = new KiroAdapter();
-registry.register(adapter8);
-var EVENT_MAP9 = {
-  "session:start": ["session.created"],
-  "session:end": ["session.idle"],
-  "prompt:submit": ["message.updated"],
-  "prompt:response": ["message.part.updated"],
-  "tool:before": ["tool.execute.before"],
-  "tool:after": ["tool.execute.after"],
-  "file:read": ["tool.execute.before"],
-  "file:write": ["tool.execute.before", "file.edited"],
-  "file:edit": ["tool.execute.before", "file.edited"],
-  "file:delete": ["tool.execute.before"],
-  "shell:before": ["tool.execute.before"],
-  "shell:after": ["tool.execute.after"],
-  "mcp:before": ["tool.execute.before"],
-  "mcp:after": ["tool.execute.after"],
-  notification: ["tui.toast.show"]
-};
-var REVERSE_MAP9 = {
-  "session.created": ["session:start"],
-  "session.idle": ["session:end"],
-  "message.updated": ["prompt:submit"],
-  "message.part.updated": ["prompt:response"],
-  "tool.execute.before": [
-    "tool:before",
-    "file:read",
-    "file:write",
-    "file:edit",
-    "file:delete",
-    "shell:before",
-    "mcp:before"
-  ],
-  "tool.execute.after": ["tool:after", "shell:after", "mcp:after"],
-  "file.edited": ["file:write", "file:edit"],
-  "tui.toast.show": ["notification"]
-};
-var OpenCodeAdapter = class extends BaseAdapter {
-  id = "opencode";
-  name = "OpenCode";
-  version = "1.0";
-  capabilities = {
-    beforeHooks: true,
-    afterHooks: true,
-    mcp: true,
-    configFile: true,
-    supportedEvents: [
-      "session:start",
-      "session:end",
-      "prompt:submit",
-      "prompt:response",
-      "tool:before",
-      "tool:after",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "shell:after",
-      "mcp:before",
-      "mcp:after",
-      "notification"
-    ],
-    blockableEvents: [
-      "tool:before",
-      "file:read",
-      "file:write",
-      "file:edit",
-      "file:delete",
-      "shell:before",
-      "mcp:before"
-    ]
-  };
-  async detect() {
-    const hasCommand = await this.commandExists("opencode");
-    const hasDir = existsSync(resolve(process.cwd(), ".opencode"));
-    return hasCommand || hasDir;
-  }
-  async generate(hooks) {
-    const configs = [];
-    const neededEvents = /* @__PURE__ */ new Set();
-    for (const hook of hooks) {
-      for (const event of hook.events) {
-        const nativeEvents = this.mapEvent(event);
-        for (const ne of nativeEvents) {
-          neededEvents.add(ne);
-        }
-      }
-    }
-    configs.push({
-      path: ".opencode/plugins/ai-hooks-plugin.js",
-      content: this.generatePlugin(neededEvents),
-      format: "js"
-    });
-    configs.push({
-      path: ".opencode/plugins/package.json",
-      content: JSON.stringify(
-        {
-          name: "ai-hooks-opencode-plugin",
-          version: "1.0.0",
-          type: "module",
-          main: "ai-hooks-plugin.js",
-          dependencies: {
-            "@premierstudio/ai-hooks": "*"
-          }
-        },
-        null,
-        2
-      ) + "\n",
-      format: "json"
-    });
-    return configs;
-  }
-  mapEvent(event) {
-    return EVENT_MAP9[event] ?? [];
-  }
-  mapNativeEvent(nativeEvent) {
-    return REVERSE_MAP9[nativeEvent] ?? [];
-  }
-  async uninstall() {
-    await this.removeFile(".opencode/plugins/ai-hooks-plugin.js");
-    await this.removeFile(".opencode/plugins/package.json");
-  }
-  generatePlugin(neededEvents) {
-    const hookEntries = [...neededEvents].map((event) => {
-      return `    "${event}": async (input, output) => {
-      await handleHook("${event}", input, output);
-    }`;
-    }).join(",\n");
-    return `/**
- * ai-hooks plugin for OpenCode.
- * Generated by: ai-hooks generate
- *
- * This plugin hooks into OpenCode's lifecycle events and delegates
- * to the ai-hooks engine for unified hook management.
- *
- * DO NOT EDIT - regenerate with: ai-hooks generate
- */
-import { loadConfig, HookEngine } from "@premierstudio/ai-hooks";
-
-let engine;
-
-async function getEngine() {
-  if (!engine) {
-    const config = await loadConfig();
-    engine = new HookEngine(config);
-  }
-  return engine;
-}
-
-async function handleHook(hookName, input, output) {
-  const eng = await getEngine();
-  const toolInfo = { name: "opencode", version: "1.0" };
-  const timestamp = Date.now();
-  const metadata = {};
-
-  let event;
-  switch (hookName) {
-    case "session.created":
-      event = { type: "session:start", tool: "opencode", version: "1.0", workingDirectory: process.cwd(), timestamp, metadata };
-      break;
-    case "session.idle":
-      event = { type: "session:end", tool: "opencode", duration: 0, timestamp, metadata };
-      break;
-    case "tool.execute.before":
-      event = resolveToolBefore(input, timestamp, metadata);
-      break;
-    case "tool.execute.after":
-      event = resolveToolAfter(input, timestamp, metadata);
-      break;
-    case "file.edited":
-      event = { type: "file:edit", path: input.path ?? "", oldContent: "", newContent: "", timestamp, metadata };
-      break;
-    case "message.updated":
-      event = { type: "prompt:submit", prompt: input.content ?? "", timestamp, metadata };
-      break;
-    case "message.part.updated":
-      event = { type: "prompt:response", response: input.content ?? "", model: "unknown", tokens: { input: 0, output: 0 }, timestamp, metadata };
-      break;
-    case "tui.toast.show":
-      event = { type: "notification", level: "info", message: input.message ?? "", timestamp, metadata };
-      break;
-    default:
-      return output;
-  }
-
-  const results = await eng.emit(event, toolInfo);
-  const blocked = results.find((r) => r.blocked);
-
-  if (blocked && hookName === "tool.execute.before") {
-    return { ...output, blocked: true, reason: blocked.reason ?? "Blocked by ai-hooks" };
-  }
-
-  return output;
-}
-
-function resolveToolBefore(input, timestamp, metadata) {
-  const toolName = input.tool ?? input.name ?? "unknown";
-  const toolInput = input.input ?? input.args ?? {};
-
-  switch (toolName) {
-    case "file_write":
-    case "write":
-      return { type: "file:write", path: toolInput.path ?? "", content: toolInput.content ?? "", timestamp, metadata };
-    case "file_edit":
-    case "edit":
-      return { type: "file:edit", path: toolInput.path ?? "", oldContent: toolInput.old ?? "", newContent: toolInput.new ?? "", timestamp, metadata };
-    case "file_read":
-    case "read":
-      return { type: "file:read", path: toolInput.path ?? "", timestamp, metadata };
-    case "bash":
-    case "shell":
-      return { type: "shell:before", command: toolInput.command ?? "", cwd: process.cwd(), timestamp, metadata };
-    default:
-      return { type: "tool:before", toolName, input: toolInput, timestamp, metadata };
-  }
-}
-
-function resolveToolAfter(input, timestamp, metadata) {
-  const toolName = input.tool ?? input.name ?? "unknown";
-  const toolInput = input.input ?? input.args ?? {};
-  const toolOutput = input.output ?? input.result ?? {};
-
-  switch (toolName) {
-    case "bash":
-    case "shell":
-      return {
-        type: "shell:after",
-        command: toolInput.command ?? "",
-        cwd: process.cwd(),
-        exitCode: toolOutput.exitCode ?? 0,
-        stdout: toolOutput.stdout ?? "",
-        stderr: toolOutput.stderr ?? "",
-        duration: 0,
-        timestamp,
-        metadata,
-      };
-    default:
-      return { type: "tool:after", toolName, input: toolInput, output: toolOutput, duration: 0, timestamp, metadata };
-  }
-}
-
-export const AiHooksPlugin = async ({ project, directory }) => {
-  return {
-${hookEntries}
-  };
-};
-`;
-  }
-};
-var adapter9 = new OpenCodeAdapter();
-registry.register(adapter9);
+import '../chunk-ZOWUSGNF.js';
+import '../chunk-FHFRGMW6.js';
 //# sourceMappingURL=all.js.map
 //# sourceMappingURL=all.js.map