@premierstudio/ai-hooks 1.1.3 → 1.1.4

package/dist/cli/index.js

@@ -1,2314 +1,7 @@
-import { pathToFileURL } from 'url';
-import { existsSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { readFile, mkdir, writeFile, rm } from 'fs/promises';
-
-// src/config/loader.ts
-var CONFIG_FILENAMES = [
-  "ai-hooks.config.ts",
-  "ai-hooks.config.js",
-  "ai-hooks.config.mjs",
-  "ai-hooks.config.mts"
-];
-function findConfigFile(cwd = process.cwd()) {
-  for (const name of CONFIG_FILENAMES) {
-    const fullPath = resolve(cwd, name);
-    if (existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
-async function loadConfig(configPath, cwd) {
-  const resolvedPath = configPath ?? findConfigFile(cwd);
-  if (!resolvedPath) {
-    throw new ConfigNotFoundError(process.cwd());
-  }
-  if (!existsSync(resolvedPath)) {
-    throw new ConfigNotFoundError(resolvedPath);
-  }
-  const fileUrl = pathToFileURL(resolve(resolvedPath)).href;
-  const mod = await import(fileUrl);
-  const config = mod.default ?? mod;
-  if (!config.hooks || !Array.isArray(config.hooks)) {
-    throw new ConfigValidationError(
-      "Config must have a `hooks` array. Did you forget to use `defineConfig()`?"
-    );
-  }
-  if (config.extends && config.extends.length > 0) {
-    const mergedHooks = [...config.extends.flatMap((preset) => preset.hooks), ...config.hooks];
-    return { ...config, hooks: mergedHooks, extends: void 0 };
-  }
-  return config;
-}
-var ConfigNotFoundError = class extends Error {
-  constructor(searchPath) {
-    super(
-      `No ai-hooks config found. Searched in: ${searchPath}
-Create an ai-hooks.config.ts file or run: ai-hooks init`
-    );
-    this.name = "ConfigNotFoundError";
-  }
-};
-var ConfigValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ConfigValidationError";
-  }
-};
-
-// src/types/hooks.ts
-function isBeforeEvent(event) {
-  return event.type === "session:start" || event.type === "prompt:submit" || event.type === "tool:before" || event.type === "file:write" || event.type === "file:edit" || event.type === "file:delete" || event.type === "shell:before" || event.type === "mcp:before";
-}
-
-// src/runtime/chain.ts
-async function executeChain(hooks, ctx, timeout) {
-  const sorted = [...hooks].toSorted((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
-  let index = 0;
-  const next = async () => {
-    if (index >= sorted.length) return;
-    const hook2 = sorted[index];
-    if (!hook2) return;
-    index++;
-    if (hook2.enabled === false) {
-      await next();
-      return;
-    }
-    if (hook2.filter && !hook2.filter(ctx.event)) {
-      await next();
-      return;
-    }
-    const blocked = ctx.results.some((r) => r.blocked);
-    if (blocked && hook2.phase === "before") {
-      return;
-    }
-    await Promise.race([
-      Promise.resolve(hook2.handler(ctx, next)),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new HookTimeoutError(hook2.id, timeout)), timeout)
-      )
-    ]);
-  };
-  try {
-    await next();
-  } catch (error) {
-    if (error instanceof HookTimeoutError) {
-      ctx.results.push({
-        blocked: false,
-        reason: `Hook "${error.hookId}" timed out after ${error.timeout}ms`
-      });
-    } else {
-      throw error;
-    }
-  }
-  return ctx.results;
-}
-var HookTimeoutError = class extends Error {
-  constructor(hookId, timeout) {
-    super(`Hook "${hookId}" timed out after ${timeout}ms`);
-    this.hookId = hookId;
-    this.timeout = timeout;
-    this.name = "HookTimeoutError";
-  }
-};
-
-// src/runtime/engine.ts
-var DEFAULT_SETTINGS = {
-  cwd: process.cwd(),
-  logLevel: "warn",
-  hookTimeout: 5e3,
-  failMode: "open",
-  telemetry: false
-};
-var HookEngine = class {
-  hooks = /* @__PURE__ */ new Map();
-  settings;
-  constructor(config) {
-    this.settings = { ...DEFAULT_SETTINGS, ...config?.settings };
-    if (config) {
-      if (config.extends) {
-        for (const preset of config.extends) {
-          this.registerAll(preset.hooks);
-        }
-      }
-      this.registerAll(config.hooks);
-    }
-  }
-  /**
-   * Register a single hook definition.
-   */
-  register(hook2) {
-    for (const event of hook2.events) {
-      const existing = this.hooks.get(event) ?? [];
-      existing.push(hook2);
-      this.hooks.set(event, existing);
-    }
-  }
-  /**
-   * Register multiple hook definitions.
-   */
-  registerAll(hooks) {
-    for (const hook2 of hooks) {
-      this.register(hook2);
-    }
-  }
-  /**
-   * Unregister a hook by ID.
-   */
-  unregister(hookId) {
-    for (const [event, hooks] of this.hooks) {
-      const filtered = hooks.filter((h) => h.id !== hookId);
-      if (filtered.length === 0) {
-        this.hooks.delete(event);
-      } else {
-        this.hooks.set(event, filtered);
-      }
-    }
-  }
-  /**
-   * Emit an event and run the matching hook chain.
-   *
-   * For "before" events: returns results that may include blocks.
-   * For "after" events: returns observation results (no blocking).
-   */
-  async emit(event, toolInfo) {
-    const eventType = event.type;
-    const phase = isBeforeEvent(event) ? "before" : "after";
-    const allHooks = this.hooks.get(eventType) ?? [];
-    const phaseHooks = allHooks.filter((h) => h.phase === phase);
-    if (phaseHooks.length === 0) {
-      return [];
-    }
-    const ctx = {
-      event,
-      tool: toolInfo,
-      cwd: this.settings.cwd,
-      state: /* @__PURE__ */ new Map(),
-      results: [],
-      startedAt: Date.now()
-    };
-    try {
-      return await executeChain(phaseHooks, ctx, this.settings.hookTimeout);
-    } catch (error) {
-      if (this.settings.failMode === "open") {
-        this.log("error", `Hook chain error (fail-open): ${error}`);
-        return [];
-      }
-      return [
-        {
-          blocked: true,
-          reason: `Hook chain error (fail-closed): ${error}`
-        }
-      ];
-    }
-  }
-  /**
-   * Check if an event is blocked by running before hooks.
-   * Convenience wrapper around emit().
-   */
-  async isBlocked(event, toolInfo) {
-    if (!isBeforeEvent(event)) {
-      return { blocked: false };
-    }
-    const results = await this.emit(event, toolInfo);
-    const blockResult = results.find((r) => r.blocked);
-    return blockResult ? { blocked: true, reason: blockResult.reason } : { blocked: false };
-  }
-  /**
-   * Get all registered hooks, optionally filtered by event type.
-   */
-  getHooks(eventType) {
-    if (eventType) {
-      return this.hooks.get(eventType) ?? [];
-    }
-    const all = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const hooks of this.hooks.values()) {
-      for (const hook2 of hooks) {
-        if (!seen.has(hook2.id)) {
-          seen.add(hook2.id);
-          all.push(hook2);
-        }
-      }
-    }
-    return all;
-  }
-  /**
-   * Get current engine settings.
-   */
-  getSettings() {
-    return { ...this.settings };
-  }
-  log(level, message) {
-    const levels = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
-    const threshold = levels[this.settings.logLevel];
-    const messageLevel = levels[level];
-    if (messageLevel <= threshold) {
-      const prefix = `[ai-hooks:${level}]`;
-      if (level === "error") {
-        console.error(prefix, message);
-      } else if (level === "warn") {
-        console.warn(prefix, message);
-      } else {
-        console.log(prefix, message);
-      }
-    }
-  }
-};
-
-// 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((resolve12) => {
-      exec(`which ${command}`, (error) => {
-        resolve12(!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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 hook2 of hooks) {
-      for (const event of hook2.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 { findConfigFile, loadConfig, HookEngine } from '../chunk-HCEOWJK3.js';
+import '../chunk-ZOWUSGNF.js';
+import { registry } from '../chunk-FHFRGMW6.js';
+import '../chunk-N7ASBTX5.js';
 
 // src/cli/index.ts
 var HELP = `
@@ -2382,7 +75,7 @@ async function cmdInit(flags) {
     console.log(`Config already exists: ${existing}`);
     return;
   }
-  const { writeFile: writeFile2 } = await import('fs/promises');
+  const { writeFile } = await import('fs/promises');
   const template = `import { defineConfig, hook, builtinHooks } from "@premierstudio/ai-hooks";
 
 export default defineConfig({
@@ -2412,7 +105,7 @@ export default defineConfig({
     console.log("[dry-run] Would create ai-hooks.config.ts");
     return;
   }
-  await writeFile2("ai-hooks.config.ts", template, "utf-8");
+  await writeFile("ai-hooks.config.ts", template, "utf-8");
   console.log("Created ai-hooks.config.ts");
   console.log("");
   console.log("Next steps:");
@@ -2425,18 +118,18 @@ async function cmdDetect(flags) {
   const detected = await registry.detectAll();
   const all = registry.list();
   for (const id of all) {
-    const adapter10 = registry.get(id);
-    if (!adapter10) continue;
+    const adapter = registry.get(id);
+    if (!adapter) continue;
     const isDetected = detected.some((d) => d.id === id);
     const icon = isDetected ? "\u2713" : "\u2717";
     const color = isDetected ? "\x1B[32m" : "\x1B[90m";
     const reset = "\x1B[0m";
     const caps = [];
-    if (adapter10.capabilities.beforeHooks) caps.push("hooks");
-    if (adapter10.capabilities.mcp) caps.push("mcp");
-    let line = `  ${color}${icon}${reset} ${adapter10.name.padEnd(20)} ${caps.join(", ")}`;
+    if (adapter.capabilities.beforeHooks) caps.push("hooks");
+    if (adapter.capabilities.mcp) caps.push("mcp");
+    let line = `  ${color}${icon}${reset} ${adapter.name.padEnd(20)} ${caps.join(", ")}`;
     if (flags.verbose) {
-      line += `  (${adapter10.capabilities.supportedEvents.length} events)`;
+      line += `  (${adapter.capabilities.supportedEvents.length} events)`;
     }
     console.log(line);
   }
@@ -2455,8 +148,8 @@ async function cmdGenerate(flags) {
   }
   console.log(`Generating configs for ${adapters.length} tool(s)...
 `);
-  for (const adapter10 of adapters) {
-    const configs = await adapter10.generate(config.hooks);
+  for (const adapter of adapters) {
+    const configs = await adapter.generate(config.hooks);
     for (const cfg of configs) {
       if (flags.dryRun) {
         console.log(`  [dry-run] Would write: ${cfg.path}`);
@@ -2479,24 +172,24 @@ async function cmdInstall(flags) {
   }
   console.log(`Installing hooks into ${adapters.length} tool(s)...
 `);
-  for (const adapter10 of adapters) {
-    const configs = await adapter10.generate(config.hooks);
+  for (const adapter of adapters) {
+    const configs = await adapter.generate(config.hooks);
     if (flags.dryRun) {
       for (const cfg of configs) {
         console.log(`  [dry-run] Would install: ${cfg.path}`);
       }
     } else {
-      await adapter10.install(configs);
-      console.log(`  \u2713 ${adapter10.name}`);
+      await adapter.install(configs);
+      console.log(`  \u2713 ${adapter.name}`);
     }
   }
   console.log("\nHooks installed!");
 }
 async function cmdUninstall(flags) {
   const adapters = await resolveAdapters(flags);
-  for (const adapter10 of adapters) {
-    await adapter10.uninstall();
-    console.log(`  \u2713 Removed from ${adapter10.name}`);
+  for (const adapter of adapters) {
+    await adapter.uninstall();
+    console.log(`  \u2713 Removed from ${adapter.name}`);
   }
   console.log("\nHooks uninstalled.");
 }
@@ -2534,8 +227,8 @@ async function cmdStatus(flags) {
     console.log(`  Hooks:  ${hooks.length} registered`);
   }
   console.log("");
-  for (const adapter10 of detected) {
-    console.log(`  \u2713 ${adapter10.name} (${adapter10.id})`);
+  for (const adapter of detected) {
+    console.log(`  \u2713 ${adapter.name} (${adapter.id})`);
   }
 }
 function parseFlags(args) {
@@ -2558,9 +251,9 @@ async function resolveAdapters(flags) {
     const ids = flags.tools.split(",").map((t) => t.trim());
     const adapters = [];
     for (const id of ids) {
-      const adapter10 = registry.get(id);
-      if (adapter10) {
-        adapters.push(adapter10);
+      const adapter = registry.get(id);
+      if (adapter) {
+        adapters.push(adapter);
       } else {
         console.warn(`  Warning: Unknown adapter "${id}"`);
       }
@@ -2570,12 +263,12 @@ async function resolveAdapters(flags) {
   return registry.detectAll();
 }
 async function writeConfigs(configs) {
-  const { writeFile: writeFile2, mkdir: mkdir2 } = await import('fs/promises');
-  const { dirname: dirname2, resolve: resolve12 } = await import('path');
+  const { writeFile, mkdir } = await import('fs/promises');
+  const { dirname, resolve } = await import('path');
   for (const cfg of configs) {
-    const fullPath = resolve12(process.cwd(), cfg.path);
-    await mkdir2(dirname2(fullPath), { recursive: true });
-    await writeFile2(fullPath, cfg.content, "utf-8");
+    const fullPath = resolve(process.cwd(), cfg.path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, cfg.content, "utf-8");
   }
 }