@premierstudio/ai-hooks 1.0.7 → 1.1.0

package/dist/cli/bin.js

@@ -0,0 +1,2588 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'url';
+import { existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { readFile, mkdir, writeFile, rm } from 'fs/promises';
+
+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);
+
+// src/cli/index.ts
+var HELP = `
+ai-hooks - Universal hooks framework for AI coding tools
+
+USAGE:
+  ai-hooks <command> [options]
+
+COMMANDS:
+  init        Create an ai-hooks.config.ts in the current directory
+  detect      Detect which AI tools are installed
+  generate    Generate native configs for detected/specified tools
+  install     Generate and install hooks into detected tools
+  uninstall   Remove ai-hooks from all detected tools
+  list        List all registered hooks from your config
+  status      Show current hook status across tools
+  help        Show this help message
+
+OPTIONS:
+  --tools     Comma-separated list of tools (e.g., --tools=claude-code,codex)
+  --config    Path to config file (default: ai-hooks.config.ts)
+  --verbose   Show detailed output
+  --dry-run   Show what would be generated without writing files
+
+EXAMPLES:
+  ai-hooks init                    # Create config file
+  ai-hooks detect                  # See which AI tools are installed
+  ai-hooks generate                # Generate configs for all detected tools
+  ai-hooks install --tools=claude-code  # Install hooks for Claude Code only
+`;
+async function run(args) {
+  const command = args[0];
+  const flags = parseFlags(args.slice(1));
+  switch (command) {
+    case "init":
+      await cmdInit(flags);
+      break;
+    case "detect":
+      await cmdDetect(flags);
+      break;
+    case "generate":
+      await cmdGenerate(flags);
+      break;
+    case "install":
+      await cmdInstall(flags);
+      break;
+    case "uninstall":
+      await cmdUninstall(flags);
+      break;
+    case "list":
+      await cmdList(flags);
+      break;
+    case "status":
+      await cmdStatus(flags);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+async function cmdInit(flags) {
+  const existing = findConfigFile();
+  if (existing) {
+    console.log(`Config already exists: ${existing}`);
+    return;
+  }
+  const { writeFile: writeFile2 } = await import('fs/promises');
+  const template = `import { defineConfig, hook, builtinHooks } from "@premierstudio/ai-hooks";
+
+export default defineConfig({
+  // Start with built-in security hooks
+  extends: [{ hooks: builtinHooks }],
+
+  hooks: [
+    // Add your custom hooks here:
+    //
+    // hook("before", ["shell:before"], async (ctx, next) => {
+    //   console.log("Running:", ctx.event.command);
+    //   await next();
+    // })
+    //   .id("my-hook")
+    //   .name("Log Shell Commands")
+    //   .build(),
+  ],
+
+  settings: {
+    logLevel: "warn",
+    hookTimeout: 5000,
+    failMode: "open",
+  },
+});
+`;
+  if (flags.dryRun) {
+    console.log("[dry-run] Would create ai-hooks.config.ts");
+    return;
+  }
+  await writeFile2("ai-hooks.config.ts", template, "utf-8");
+  console.log("Created ai-hooks.config.ts");
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Edit ai-hooks.config.ts to add your hooks");
+  console.log("  2. Run: ai-hooks detect    (see which AI tools are installed)");
+  console.log("  3. Run: ai-hooks install   (install hooks into your tools)");
+}
+async function cmdDetect(flags) {
+  console.log("Detecting AI coding tools...\n");
+  const detected = await registry.detectAll();
+  const all = registry.list();
+  for (const id of all) {
+    const adapter10 = registry.get(id);
+    if (!adapter10) 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 (flags.verbose) {
+      line += `  (${adapter10.capabilities.supportedEvents.length} events)`;
+    }
+    console.log(line);
+  }
+  console.log(`
+Detected ${detected.length}/${all.length} tools`);
+  if (detected.length > 0 && !findConfigFile()) {
+    console.log('\nRun "ai-hooks init" to create a config file');
+  }
+}
+async function cmdGenerate(flags) {
+  const config = await loadConfig(flags.config);
+  const adapters = await resolveAdapters(flags);
+  if (adapters.length === 0) {
+    console.log("No AI tools detected. Use --tools to specify manually.");
+    return;
+  }
+  console.log(`Generating configs for ${adapters.length} tool(s)...
+`);
+  for (const adapter10 of adapters) {
+    const configs = await adapter10.generate(config.hooks);
+    for (const cfg of configs) {
+      if (flags.dryRun) {
+        console.log(`  [dry-run] Would write: ${cfg.path}`);
+      } else {
+        console.log(`  Generated: ${cfg.path}`);
+      }
+    }
+    if (!flags.dryRun) {
+      await writeConfigs(configs);
+    }
+  }
+  console.log("\nDone!");
+}
+async function cmdInstall(flags) {
+  const config = await loadConfig(flags.config);
+  const adapters = await resolveAdapters(flags);
+  if (adapters.length === 0) {
+    console.log("No AI tools detected. Use --tools to specify manually.");
+    return;
+  }
+  console.log(`Installing hooks into ${adapters.length} tool(s)...
+`);
+  for (const adapter10 of adapters) {
+    const configs = await adapter10.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}`);
+    }
+  }
+  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}`);
+  }
+  console.log("\nHooks uninstalled.");
+}
+async function cmdList(flags) {
+  const config = await loadConfig(flags.config);
+  const engine = new HookEngine(config);
+  const hooks = engine.getHooks();
+  if (hooks.length === 0) {
+    console.log("No hooks registered. Edit ai-hooks.config.ts to add hooks.");
+    return;
+  }
+  console.log(`${hooks.length} hook(s) registered:
+`);
+  for (const h of hooks) {
+    const status = h.enabled === false ? "\x1B[90m(disabled)\x1B[0m" : "";
+    const priority = h.priority ?? 100;
+    console.log(`  [${h.phase}] ${h.name} ${status}`);
+    console.log(`         id: ${h.id}  priority: ${priority}  events: ${h.events.join(", ")}`);
+    if (h.description && flags.verbose) {
+      console.log(`         ${h.description}`);
+    }
+    console.log("");
+  }
+}
+async function cmdStatus(flags) {
+  const hasConfig = findConfigFile();
+  const detected = await registry.detectAll();
+  console.log("ai-hooks status\n");
+  console.log(`  Config: ${hasConfig ?? "not found"}`);
+  console.log(`  Tools:  ${detected.length} detected`);
+  if (hasConfig) {
+    const config = await loadConfig(flags.config);
+    const engine = new HookEngine(config);
+    const hooks = engine.getHooks();
+    console.log(`  Hooks:  ${hooks.length} registered`);
+  }
+  console.log("");
+  for (const adapter10 of detected) {
+    console.log(`  \u2713 ${adapter10.name} (${adapter10.id})`);
+  }
+}
+function parseFlags(args) {
+  const flags = {};
+  for (const arg of args) {
+    if (arg.startsWith("--tools=")) {
+      flags.tools = arg.slice(8);
+    } else if (arg.startsWith("--config=")) {
+      flags.config = arg.slice(9);
+    } else if (arg === "--verbose") {
+      flags.verbose = true;
+    } else if (arg === "--dry-run") {
+      flags.dryRun = true;
+    }
+  }
+  return flags;
+}
+async function resolveAdapters(flags) {
+  if (flags.tools) {
+    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);
+      } else {
+        console.warn(`  Warning: Unknown adapter "${id}"`);
+      }
+    }
+    return adapters;
+  }
+  return registry.detectAll();
+}
+async function writeConfigs(configs) {
+  const { writeFile: writeFile2, mkdir: mkdir2 } = await import('fs/promises');
+  const { dirname: dirname2, resolve: resolve12 } = 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");
+  }
+}
+
+// src/cli/bin.ts
+run(process.argv.slice(2)).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map