claude-code-hookkit 1.0.0

package/dist/chunk-XLX5K6TZ.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+// src/registry/index.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/registry/types.ts
+import { z as z2 } from "zod";
+
+// src/types/hooks.ts
+import { z } from "zod";
+var hookEventSchema = z.enum([
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PermissionRequest",
+  "SessionStart",
+  "Stop",
+  "StopFailure",
+  "SessionEnd",
+  "Notification",
+  "SubagentStart",
+  "SubagentStop",
+  "UserPromptSubmit",
+  "ConfigChange",
+  "PreCompact",
+  "PostCompact",
+  "WorktreeCreate",
+  "WorktreeRemove",
+  "TeammateIdle",
+  "TaskCompleted",
+  "InstructionsLoaded",
+  "Elicitation",
+  "ElicitationResult"
+]);
+var hookEntrySchema = z.object({
+  type: z.literal("command"),
+  command: z.string().min(1)
+});
+var hookGroupSchema = z.object({
+  matcher: z.string().optional(),
+  hooks: z.array(hookEntrySchema)
+});
+var claudeSettingsSchema = z.object({
+  env: z.record(z.string()).optional(),
+  hooks: z.record(z.array(hookGroupSchema)).optional(),
+  mcpServers: z.record(z.unknown()).optional(),
+  enabledPlugins: z.record(z.boolean()).optional(),
+  statusLine: z.unknown().optional()
+}).passthrough();
+
+// src/registry/types.ts
+var hookDefinitionSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  event: hookEventSchema,
+  matcher: z2.string().optional(),
+  pack: z2.string().optional(),
+  scriptFile: z2.string().min(1)
+});
+var hookPackSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  hooks: z2.array(z2.string())
+});
+var registrySchema = z2.object({
+  hooks: z2.record(hookDefinitionSchema),
+  packs: z2.record(hookPackSchema)
+});
+
+// src/registry/index.ts
+import { existsSync } from "fs";
+var _require = createRequire(import.meta.url);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function findRegistryPath() {
+  let dir = __dirname;
+  for (let i = 0; i < 4; i++) {
+    const candidate = join(dir, "registry", "registry.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(`registry/registry.json not found searching up from: ${__dirname}`);
+}
+var _cache = null;
+function loadRegistry() {
+  if (_cache !== null) {
+    return _cache;
+  }
+  const registryPath = findRegistryPath();
+  const raw = _require(registryPath);
+  const parsed = registrySchema.parse(raw);
+  _cache = parsed;
+  return _cache;
+}
+function getHook(name) {
+  return loadRegistry().hooks[name];
+}
+function getPack(name) {
+  return loadRegistry().packs[name];
+}
+function listHooks() {
+  return Object.values(loadRegistry().hooks);
+}
+
+export {
+  getHook,
+  getPack,
+  listHooks
+};

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+var program = new Command().name("claude-code-hookkit").description("Hook manager for Claude Code \u2014 install, manage, test, and share hooks").version("1.0.0");
+program.command("init").description("Initialize claude-code-hookkit in your project").option("--scope <scope>", "Settings scope: user, project, or local", "project").option("--dry-run", "Preview changes without writing").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit init
+  $ claude-code-hookkit init --scope user
+  $ claude-code-hookkit init --dry-run`).action(async (opts) => {
+  const { initCommand } = await import("./init-RHEFGGUF.js");
+  await initCommand(opts);
+});
+program.command("restore").description("Restore settings.json from the last backup").option("--scope <scope>", "Settings scope: user, project, or local", "project").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit restore
+  $ claude-code-hookkit restore --scope user`).action(async (opts) => {
+  const { restoreCommand } = await import("./restore-7JQ3CHWZ.js");
+  await restoreCommand(opts);
+});
+program.command("add <name>").description("Install a hook from the registry into your project").option("--scope <scope>", "Settings scope: user, project, or local", "project").option("--dry-run", "Preview changes without writing").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit add sensitive-path-guard
+  $ claude-code-hookkit add security-pack
+  $ claude-code-hookkit add cost-tracker --scope user
+  $ claude-code-hookkit add post-edit-lint --dry-run`).action(async (name, opts) => {
+  const { addCommand } = await import("./add-O4OSFQ76.js");
+  await addCommand({ ...opts, hookName: name });
+});
+program.command("remove <name>").description("Remove an installed hook from your project").option("--scope <scope>", "Settings scope: user, project, or local", "project").option("--dry-run", "Preview changes without writing").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit remove sensitive-path-guard
+  $ claude-code-hookkit remove post-edit-lint --scope user
+  $ claude-code-hookkit remove web-budget-gate --dry-run`).action(async (name, opts) => {
+  const { removeCommand } = await import("./remove-Z5QIW45P.js");
+  await removeCommand({ ...opts, hookName: name });
+});
+program.command("list").description("List all available hooks with installed status").option("--scope <scope>", "Settings scope: user, project, or local", "project").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit list
+  $ claude-code-hookkit list --scope user`).action(async (opts) => {
+  const { listCommand } = await import("./list-SCSGYOBR.js");
+  await listCommand(opts);
+});
+program.command("doctor").description("Validate hook installation health").option("--scope <scope>", "Settings scope: user, project, or local", "project").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit doctor
+  $ claude-code-hookkit doctor --scope user
+  $ claude-code-hookkit doctor --scope project`).action(async (opts) => {
+  const { doctorCommand } = await import("./doctor-UBK2C2TW.js");
+  await doctorCommand(opts);
+});
+program.command("test [hook]").description("Test hooks with fixture data").option("--all", "Test all installed hooks").option("--scope <scope>", "Settings scope: user, project, or local", "project").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit test sensitive-path-guard
+  $ claude-code-hookkit test --all`).action(async (hook, opts) => {
+  const { testCommand } = await import("./test-ZRRLZ62R.js");
+  await testCommand({ hookName: hook, ...opts });
+});
+program.command("create <name>").description("Scaffold a new custom hook from a template").requiredOption("--event <type>", "Hook event type (PreToolUse, PostToolUse, SessionStart, Stop)").option("--matcher <pattern>", 'Tool matcher pattern (e.g., "Bash", "Edit|Write")').option("--scope <scope>", "Settings scope: user, project, or local", "project").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit create my-guard --event PreToolUse --matcher Bash
+  $ claude-code-hookkit create session-logger --event SessionStart
+  $ claude-code-hookkit create cleanup --event Stop`).action(async (name, opts) => {
+  const { createCommand } = await import("./create-DBLA6PTS.js");
+  await createCommand({ name, ...opts });
+});
+program.command("info <hook>").description("Show details for a hook: description, event, matcher, pack, and examples").addHelpText("after", `
+Examples:
+  $ claude-code-hookkit info sensitive-path-guard
+  $ claude-code-hookkit info web-budget-gate
+  $ claude-code-hookkit info error-advisor`).action(async (hook) => {
+  const { infoCommand } = await import("./info-FLYMAHDX.js");
+  await infoCommand({ hookName: hook });
+});
+program.parse();

package/dist/create-DBLA6PTS.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-2BZZUQQ3.js";
+import {
+  getHooksDir
+} from "./chunk-PEDGREZY.js";
+
+// src/commands/create.ts
+import { mkdirSync, writeFileSync, chmodSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/templates/index.ts
+var SUPPORTED_EVENTS = ["PreToolUse", "PostToolUse", "SessionStart", "Stop"];
+function listTemplateEvents() {
+  return [...SUPPORTED_EVENTS];
+}
+function getTemplate(event, name, matcher) {
+  switch (event) {
+    case "PreToolUse":
+      return preToolUseTemplate(name, matcher);
+    case "PostToolUse":
+      return postToolUseTemplate(name, matcher);
+    case "SessionStart":
+      return sessionStartTemplate(name);
+    case "Stop":
+      return stopTemplate(name);
+    default:
+      return genericTemplate(name, event);
+  }
+}
+function preToolUseTemplate(name, matcher) {
+  const matcherLine = matcher ? `# Matcher: ${matcher}` : "# Matcher: (all tools)";
+  return `#!/usr/bin/env bash
+# ${name} \u2014 PreToolUse hook
+${matcherLine}
+# Created by claude-code-hookkit create
+#
+# PreToolUse hooks can block tool execution:
+#   exit 0  \u2192 allow the tool to run
+#   exit 2  \u2192 block the tool (stderr is shown to Claude as feedback)
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract fields using grep (pure bash, no external JSON parser required)
+TOOL_NAME=$(echo "$INPUT" | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4)
+FILE_PATH=$(echo "$INPUT" | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+COMMAND=$(echo "$INPUT" | grep -o '"command":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+# TODO: Add your blocking logic here
+# Example: block if file_path matches a sensitive pattern
+# if echo "$FILE_PATH" | grep -qE '\\.env|\\.secret|credentials'; then
+#   echo "BLOCKED: Sensitive file access denied" >&2
+#   exit 2
+# fi
+
+# Allow by default
+exit 0
+`;
+}
+function postToolUseTemplate(name, matcher) {
+  const matcherLine = matcher ? `# Matcher: ${matcher}` : "# Matcher: (all tools)";
+  return `#!/usr/bin/env bash
+# ${name} \u2014 PostToolUse hook
+${matcherLine}
+# Created by claude-code-hookkit create
+#
+# PostToolUse hooks are informational \u2014 they should always exit 0.
+# They run after the tool has already executed.
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract fields using grep (pure bash, no external JSON parser required, bash 3.2+ compatible)
+TOOL_NAME=$(echo "$INPUT" | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4)
+TOOL_RESPONSE=$(echo "$INPUT" | grep -o '"tool_response":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+# TODO: Add your post-tool logic here (informational only)
+# Example: log tool invocations, trigger notifications, update metrics
+# echo "[$TOOL_NAME] completed" >> /tmp/tool-log.txt
+
+# PostToolUse hooks should always exit 0
+exit 0
+`;
+}
+function sessionStartTemplate(name) {
+  return `#!/usr/bin/env bash
+# ${name} \u2014 SessionStart hook
+# Created by claude-code-hookkit create
+#
+# SessionStart hooks run when a new Claude Code session begins.
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract fields using grep (pure bash, no external JSON parser required, bash 3.2+ compatible)
+SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | cut -d'"' -f4)
+CWD=$(echo "$INPUT" | grep -o '"cwd":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+# TODO: Add your session initialization logic here
+# Example: log session start, set up environment, notify external services
+# echo "[$SESSION_ID] Session started in $CWD" >> /tmp/session-log.txt
+
+exit 0
+`;
+}
+function stopTemplate(name) {
+  return `#!/usr/bin/env bash
+# ${name} \u2014 Stop hook
+# Created by claude-code-hookkit create
+#
+# Stop hooks run when a Claude Code session ends.
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract fields using grep (pure bash, no external JSON parser required, bash 3.2+ compatible)
+SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+# TODO: Add your cleanup/summary logic here
+# Example: summarize session, flush logs, send notifications
+# echo "[$SESSION_ID] Session ended" >> /tmp/session-log.txt
+
+exit 0
+`;
+}
+function genericTemplate(name, event) {
+  return `#!/usr/bin/env bash
+# ${name} \u2014 ${event} hook
+# Created by claude-code-hookkit create
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract session_id using grep (pure bash, no external JSON parser required, bash 3.2+ compatible)
+SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+# TODO: Add your hook logic here
+
+exit 0
+`;
+}
+
+// src/commands/create.ts
+function buildFixtures(event) {
+  switch (event) {
+    case "PreToolUse":
+      return {
+        allow: {
+          description: "Example: allows safe input",
+          input: { tool_input: { command: "echo hello" } },
+          expectedExitCode: 0
+        },
+        block: {
+          description: "Example: blocks dangerous input",
+          input: { tool_input: { command: "REPLACE_ME" } },
+          expectedExitCode: 2
+        }
+      };
+    case "PostToolUse":
+      return {
+        allow: {
+          description: "Example: processes tool output",
+          input: { tool_name: "Bash", tool_response: "output here" },
+          expectedExitCode: 0
+        }
+      };
+    case "SessionStart":
+      return {
+        allow: {
+          description: "Example: session initialization",
+          input: { session_id: "test-session", cwd: "/tmp" },
+          expectedExitCode: 0
+        }
+      };
+    case "Stop":
+      return {
+        allow: {
+          description: "Example: session cleanup",
+          input: { session_id: "test-session" },
+          expectedExitCode: 0
+        }
+      };
+    default:
+      return {
+        allow: {
+          description: "Example: allow input",
+          input: { session_id: "test-session" },
+          expectedExitCode: 0
+        }
+      };
+  }
+}
+async function _createAt(opts) {
+  const { name, event, matcher, hooksDir } = opts;
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+    return { invalidName: true };
+  }
+  const supportedEvents = listTemplateEvents();
+  if (!supportedEvents.includes(event)) {
+    return { invalidEvent: true };
+  }
+  const scriptPath = join(hooksDir, `${name}.sh`);
+  const fixturesDir = join(hooksDir, "fixtures", name);
+  if (existsSync(scriptPath)) {
+    return { skipped: true };
+  }
+  mkdirSync(hooksDir, { recursive: true });
+  mkdirSync(fixturesDir, { recursive: true });
+  const template = getTemplate(event, name, matcher);
+  writeFileSync(scriptPath, template, "utf8");
+  chmodSync(scriptPath, 493);
+  const fixtures = buildFixtures(event);
+  writeFileSync(
+    join(fixturesDir, "allow-example.json"),
+    JSON.stringify(fixtures.allow, null, 2) + "\n",
+    "utf8"
+  );
+  if (fixtures.block) {
+    writeFileSync(
+      join(fixturesDir, "block-example.json"),
+      JSON.stringify(fixtures.block, null, 2) + "\n",
+      "utf8"
+    );
+  }
+  return { created: true, scriptPath, fixturesDir };
+}
+async function createCommand(opts) {
+  const { name, event, matcher, scope = "project" } = opts;
+  const hooksDir = getHooksDir(scope);
+  const result = await _createAt({ name, event, matcher, hooksDir });
+  if (result.invalidName) {
+    log.error(
+      `Invalid hook name: "${name}". Names must be lowercase alphanumeric with hyphens (e.g., my-guard).`
+    );
+    return;
+  }
+  if (result.invalidEvent) {
+    const supported = listTemplateEvents().join(", ");
+    log.error(`Unsupported event type: "${event}". Supported types: ${supported}`);
+    return;
+  }
+  if (result.skipped) {
+    log.warn(`Hook already exists: ${join(hooksDir, name + ".sh")}. Remove it first to recreate.`);
+    return;
+  }
+  if (result.created) {
+    log.success(`Created hook: ${result.scriptPath}`);
+    log.dim(`  Fixtures: ${result.fixturesDir}/allow-example.json`);
+    if (event === "PreToolUse") {
+      log.dim(`  Fixtures: ${result.fixturesDir}/block-example.json`);
+    }
+    log.info("");
+    log.info("Next steps:");
+    log.dim(`  1. Edit ${result.scriptPath} to add your logic`);
+    log.dim(`  2. Run: claude-code-hookkit test ${name}`);
+  }
+}
+export {
+  _createAt,
+  createCommand
+};

package/dist/doctor-UBK2C2TW.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import {
+  readSettings
+} from "./chunk-LRXKKJDU.js";
+import "./chunk-QKT647BI.js";
+import {
+  getHooksDir,
+  getSettingsPath
+} from "./chunk-PEDGREZY.js";
+
+// src/commands/doctor.ts
+import { existsSync, accessSync, constants } from "fs";
+import pc from "picocolors";
+function extractCommands(hooks) {
+  const result = [];
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (!group.hooks || !Array.isArray(group.hooks)) continue;
+      for (const entry of group.hooks) {
+        if (entry.type === "command" && entry.command) {
+          result.push({ event, matcher: group.matcher, command: entry.command });
+        }
+      }
+    }
+  }
+  return result;
+}
+async function _doctorAt(opts) {
+  const { settingsPath, hooksDir } = opts;
+  const checks = [];
+  let settings;
+  if (!existsSync(settingsPath)) {
+    checks.push({ level: "warn", message: `Settings file not found: ${settingsPath}` });
+  } else {
+    try {
+      settings = await readSettings(settingsPath);
+      checks.push({ level: "pass", message: "Settings file valid" });
+    } catch {
+      checks.push({ level: "fail", message: `Settings file parse error: malformed JSON at ${settingsPath}` });
+    }
+  }
+  if (!existsSync(hooksDir)) {
+    checks.push({ level: "fail", message: `Hooks dir not found: ${hooksDir}` });
+  } else {
+    checks.push({ level: "pass", message: "Hooks directory exists" });
+  }
+  if (settings !== void 0) {
+    const hookDefs = settings.hooks;
+    const allEntries = hookDefs ? extractCommands(hookDefs) : [];
+    if (allEntries.length === 0) {
+      checks.push({ level: "pass", message: "No hook scripts to validate" });
+    } else {
+      for (const { command: scriptPath } of allEntries) {
+        if (!existsSync(scriptPath)) {
+          checks.push({ level: "fail", message: `Script not found: ${scriptPath}` });
+        } else {
+          try {
+            accessSync(scriptPath, constants.X_OK);
+            checks.push({ level: "pass", message: `Script OK: ${scriptPath}` });
+          } catch {
+            checks.push({ level: "fail", message: `Script not executable: ${scriptPath}` });
+          }
+        }
+      }
+    }
+    if (hookDefs) {
+      const tupleMap = /* @__PURE__ */ new Map();
+      for (const { event, matcher, command } of allEntries) {
+        const key = `${event}::${matcher ?? "__none__"}`;
+        if (!tupleMap.has(key)) {
+          tupleMap.set(key, /* @__PURE__ */ new Set());
+        }
+        tupleMap.get(key).add(command);
+      }
+      let conflictFound = false;
+      for (const [key, commands] of tupleMap.entries()) {
+        if (commands.size > 1) {
+          const parts = key.split("::");
+          const event = parts[0];
+          const matcher = parts[1];
+          const label = matcher === "__none__" ? event : `${event}/${matcher}`;
+          checks.push({
+            level: "warn",
+            message: `Conflicting hooks: ${label} has ${commands.size} commands`
+          });
+          conflictFound = true;
+        }
+      }
+      if (!conflictFound) {
+        checks.push({ level: "pass", message: "No conflicting hooks" });
+      }
+    } else {
+      checks.push({ level: "pass", message: "No conflicting hooks" });
+    }
+  }
+  const passed = checks.filter((c) => c.level === "pass").length;
+  const failed = checks.filter((c) => c.level === "fail").length;
+  const warnings = checks.filter((c) => c.level === "warn").length;
+  const exitCode = failed > 0 ? 1 : 0;
+  return { checks, passed, failed, warnings, exitCode };
+}
+function printResults(result) {
+  console.log("");
+  for (const check of result.checks) {
+    if (check.level === "pass") {
+      console.log(pc.green("[PASS]") + " " + check.message);
+    } else if (check.level === "fail") {
+      console.log(pc.red("[FAIL]") + " " + check.message);
+    } else {
+      console.log(pc.yellow("[WARN]") + " " + check.message);
+    }
+  }
+  console.log("");
+  const summary = `${result.passed} passed, ${result.failed} failed, ${result.warnings} warning${result.warnings !== 1 ? "s" : ""}`;
+  if (result.failed > 0) {
+    console.log(pc.red(summary));
+  } else if (result.warnings > 0) {
+    console.log(pc.yellow(summary));
+  } else {
+    console.log(pc.green(summary));
+  }
+}
+async function doctorCommand(opts) {
+  const validScopes = ["user", "project", "local"];
+  const scope = validScopes.includes(opts.scope) ? opts.scope : "project";
+  const result = await _doctorAt({
+    settingsPath: getSettingsPath(scope),
+    hooksDir: getHooksDir(scope)
+  });
+  printResults(result);
+  process.exit(result.exitCode);
+}
+export {
+  _doctorAt,
+  doctorCommand
+};

package/dist/info-FLYMAHDX.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  getHook
+} from "./chunk-XLX5K6TZ.js";
+
+// src/commands/info.ts
+import { readdir, readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import pc from "picocolors";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function fixturesDir(hookName) {
+  let dir = __dirname;
+  for (let i = 0; i < 4; i++) {
+    const candidate = join(dir, "registry", "hooks", "fixtures", hookName);
+    if (existsSync(candidate)) return candidate;
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(__dirname, "..", "registry", "hooks", "fixtures", hookName);
+}
+async function loadFixtures(hookName) {
+  const dir = fixturesDir(hookName);
+  if (!existsSync(dir)) return [];
+  let files;
+  try {
+    files = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json")).sort();
+  const fixtures = [];
+  for (const file of jsonFiles) {
+    try {
+      const raw = await readFile(join(dir, file), "utf8");
+      const parsed = JSON.parse(raw);
+      fixtures.push(parsed);
+    } catch {
+    }
+  }
+  return fixtures;
+}
+async function infoCommand(opts) {
+  const { hookName } = opts;
+  const hook = getHook(hookName);
+  if (!hook) {
+    console.error(pc.red(`Hook "${hookName}" not found in registry.`));
+    console.error(pc.dim("Run `claude-code-hookkit list` to see all available hooks."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(pc.bold(pc.cyan(`${hook.name}`)));
+  console.log(pc.dim("\u2500".repeat(50)));
+  console.log(`${pc.bold("Description:")} ${hook.description}`);
+  console.log(`${pc.bold("Event:")}       ${pc.yellow(hook.event)}`);
+  console.log(`${pc.bold("Matcher:")}     ${hook.matcher ?? pc.dim("(all tools)")}`);
+  console.log(`${pc.bold("Pack:")}        ${pc.cyan(hook.pack ?? pc.dim("(standalone)"))}`);
+  console.log(`${pc.bold("Script:")}      ${hook.scriptFile}`);
+  const fixtures = await loadFixtures(hookName);
+  if (fixtures.length === 0) {
+    console.log("");
+    console.log(pc.dim("No example fixtures found."));
+  } else {
+    console.log("");
+    console.log(pc.bold("Examples:"));
+    console.log("");
+    for (const fixture of fixtures) {
+      const exitLabel = fixture.expectedExitCode === 0 ? pc.green(`exit ${fixture.expectedExitCode} (allow)`) : pc.red(`exit ${fixture.expectedExitCode} (block)`);
+      console.log(`  ${pc.bold(fixture.description)}`);
+      console.log(`  ${pc.dim("Input:")}    ${JSON.stringify(fixture.input)}`);
+      console.log(`  ${pc.dim("Outcome:")}  ${exitLabel}`);
+      console.log("");
+    }
+  }
+  console.log(pc.dim(`Install with: claude-code-hookkit add ${hookName}`));
+  console.log(pc.dim(`Test with:    claude-code-hookkit test ${hookName}`));
+  console.log("");
+}
+export {
+  infoCommand
+};