@hasna/hooks 0.0.1

package/src/cli/index.tsx

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+import React from "react";
+import { render } from "ink";
+import { Command } from "commander";
+import chalk from "chalk";
+import { App } from "./components/App.js";
+import {
+  HOOKS,
+  CATEGORIES,
+  getHooksByCategory,
+  searchHooks,
+  getHook,
+} from "../lib/registry.js";
+import {
+  installHook,
+  getInstalledHooks,
+  getRegisteredHooks,
+  removeHook,
+} from "../lib/installer.js";
+
+const program = new Command();
+
+program
+  .name("hooks")
+  .description("Install Claude Code hooks for your project")
+  .version("0.0.1");
+
+// Interactive mode (default)
+program
+  .command("interactive", { isDefault: true })
+  .alias("i")
+  .description("Interactive hook browser")
+  .action(() => {
+    render(<App />);
+  });
+
+// Install command
+program
+  .command("install")
+  .alias("add")
+  .argument("[hooks...]", "Hooks to install")
+  .option("-o, --overwrite", "Overwrite existing hooks", false)
+  .description("Install one or more hooks")
+  .action((hooks: string[], options) => {
+    if (hooks.length === 0) {
+      render(<App />);
+      return;
+    }
+
+    console.log(chalk.bold("\nInstalling hooks...\n"));
+
+    for (const name of hooks) {
+      const result = installHook(name, { overwrite: options.overwrite });
+      if (result.success) {
+        const meta = getHook(name);
+        console.log(chalk.green(`✓ ${name}`));
+        if (meta) {
+          console.log(
+            chalk.dim(`  ${meta.event}${meta.matcher ? ` [${meta.matcher}]` : ""} → hook-${name}`)
+          );
+        }
+      } else {
+        console.log(chalk.red(`✗ ${name}: ${result.error}`));
+      }
+    }
+
+    console.log(chalk.dim("\nHooks installed to .hooks/ and registered in ~/.claude/settings.json"));
+  });
+
+// List command
+program
+  .command("list")
+  .alias("ls")
+  .option("-c, --category <category>", "Filter by category")
+  .option("-a, --all", "Show all available hooks", false)
+  .option("-i, --installed", "Show only installed hooks", false)
+  .option("-r, --registered", "Show hooks registered in Claude settings", false)
+  .description("List available or installed hooks")
+  .action((options) => {
+    if (options.registered) {
+      const registered = getRegisteredHooks();
+      if (registered.length === 0) {
+        console.log(chalk.dim("No hooks registered in Claude settings"));
+        return;
+      }
+      console.log(chalk.bold(`\nRegistered hooks (${registered.length}):\n`));
+      for (const name of registered) {
+        const meta = getHook(name);
+        console.log(
+          `  ${chalk.cyan(name)} ${chalk.dim(`[${meta?.event || "unknown"}]`)} - ${meta?.description || ""}`
+        );
+      }
+      return;
+    }
+
+    if (options.installed) {
+      const installed = getInstalledHooks();
+      if (installed.length === 0) {
+        console.log(chalk.dim("No hooks installed"));
+        return;
+      }
+      console.log(chalk.bold(`\nInstalled hooks (${installed.length}):\n`));
+      for (const name of installed) {
+        console.log(`  ${name}`);
+      }
+      return;
+    }
+
+    if (options.category) {
+      const category = CATEGORIES.find(
+        (c) => c.toLowerCase() === options.category.toLowerCase()
+      );
+      if (!category) {
+        console.log(chalk.red(`Unknown category: ${options.category}`));
+        console.log(chalk.dim(`Available: ${CATEGORIES.join(", ")}`));
+        return;
+      }
+      const hooks = getHooksByCategory(category);
+      console.log(chalk.bold(`\n${category} (${hooks.length}):\n`));
+      for (const h of hooks) {
+        console.log(
+          `  ${chalk.cyan(h.name)} ${chalk.dim(`[${h.event}]`)} - ${h.description}`
+        );
+      }
+      return;
+    }
+
+    // Show all by category
+    console.log(chalk.bold(`\nAvailable hooks (${HOOKS.length}):\n`));
+    for (const category of CATEGORIES) {
+      const hooks = getHooksByCategory(category);
+      console.log(chalk.bold(`${category} (${hooks.length}):`));
+      for (const h of hooks) {
+        console.log(
+          `  ${chalk.cyan(h.name)} ${chalk.dim(`[${h.event}]`)} - ${h.description}`
+        );
+      }
+      console.log();
+    }
+  });
+
+// Search command
+program
+  .command("search")
+  .argument("<query>", "Search term")
+  .description("Search for hooks")
+  .action((query: string) => {
+    const results = searchHooks(query);
+    if (results.length === 0) {
+      console.log(chalk.dim(`No hooks found for "${query}"`));
+      return;
+    }
+    console.log(chalk.bold(`\nFound ${results.length} hook(s):\n`));
+    for (const h of results) {
+      console.log(
+        `  ${chalk.cyan(h.name)} ${chalk.dim(`[${h.event}] [${h.category}]`)}`
+      );
+      console.log(`    ${h.description}`);
+    }
+  });
+
+// Remove command
+program
+  .command("remove")
+  .alias("rm")
+  .argument("<hook>", "Hook to remove")
+  .description("Remove an installed hook")
+  .action((hook: string) => {
+    const removed = removeHook(hook);
+    if (removed) {
+      console.log(chalk.green(`✓ Removed ${hook} (unregistered from Claude settings)`));
+    } else {
+      console.log(chalk.red(`✗ ${hook} is not installed`));
+    }
+  });
+
+// Categories command
+program
+  .command("categories")
+  .description("List all categories")
+  .action(() => {
+    console.log(chalk.bold("\nCategories:\n"));
+    for (const category of CATEGORIES) {
+      const count = getHooksByCategory(category).length;
+      console.log(`  ${category} (${count})`);
+    }
+  });
+
+// Info command
+program
+  .command("info")
+  .argument("<hook>", "Hook name")
+  .description("Show detailed info about a hook")
+  .action((hook: string) => {
+    const meta = getHook(hook);
+    if (!meta) {
+      console.log(chalk.red(`Hook '${hook}' not found`));
+      return;
+    }
+    console.log(chalk.bold(`\n${meta.displayName}\n`));
+    console.log(`  ${meta.description}`);
+    console.log();
+    console.log(`  ${chalk.dim("Category:")}  ${meta.category}`);
+    console.log(`  ${chalk.dim("Event:")}     ${meta.event}`);
+    console.log(`  ${chalk.dim("Matcher:")}   ${meta.matcher || "(none)"}`);
+    console.log(`  ${chalk.dim("Tags:")}      ${meta.tags.join(", ")}`);
+    console.log(`  ${chalk.dim("Package:")}   hook-${meta.name}`);
+    console.log();
+
+    const registered = getRegisteredHooks();
+    if (registered.includes(meta.name)) {
+      console.log(chalk.green("  ● Registered in Claude settings"));
+    } else {
+      console.log(chalk.dim("  ○ Not registered"));
+    }
+  });
+
+program.parse();

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @hasna/hooks - Open source Claude Code hooks library
+ *
+ * Install hooks with a single command:
+ *   npx @hasna/hooks install gitguard branchprotect
+ *
+ * Or use the interactive CLI:
+ *   npx @hasna/hooks
+ */
+
+export {
+  HOOKS,
+  CATEGORIES,
+  getHook,
+  getHooksByCategory,
+  searchHooks,
+  type HookMeta,
+  type Category,
+} from "./lib/registry.js";
+
+export {
+  installHook,
+  installHooks,
+  getInstalledHooks,
+  getRegisteredHooks,
+  removeHook,
+  hookExists,
+  getHookPath,
+  type InstallResult,
+  type InstallOptions,
+} from "./lib/installer.js";

package/src/lib/installer.ts

@@ -0,0 +1,288 @@
+/**
+ * Hook installer - handles copying hooks to user projects and configuring settings
+ */
+
+import { existsSync, cpSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { getHook } from "./registry.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOKS_DIR = join(__dirname, "..", "..", "hooks");
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+
+export interface InstallResult {
+  hook: string;
+  success: boolean;
+  error?: string;
+  path?: string;
+}
+
+export interface InstallOptions {
+  targetDir?: string;
+  overwrite?: boolean;
+}
+
+/**
+ * Get the path to a hook in the package
+ */
+export function getHookPath(name: string): string {
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  return join(HOOKS_DIR, hookName);
+}
+
+/**
+ * Check if a hook exists in the package
+ */
+export function hookExists(name: string): boolean {
+  return existsSync(getHookPath(name));
+}
+
+/**
+ * Read Claude settings.json
+ */
+function readSettings(): Record<string, any> {
+  try {
+    if (existsSync(SETTINGS_PATH)) {
+      return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+
+/**
+ * Write Claude settings.json
+ */
+function writeSettings(settings: Record<string, any>): void {
+  const dir = dirname(SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+}
+
+/**
+ * Install a single hook to the target directory and register in settings
+ */
+export function installHook(
+  name: string,
+  options: InstallOptions = {}
+): InstallResult {
+  const { targetDir = process.cwd(), overwrite = false } = options;
+
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  const shortName = hookName.replace("hook-", "");
+  const sourcePath = getHookPath(name);
+  const destDir = join(targetDir, ".hooks");
+  const destPath = join(destDir, hookName);
+
+  // Check if hook exists in package
+  if (!existsSync(sourcePath)) {
+    return {
+      hook: shortName,
+      success: false,
+      error: `Hook '${shortName}' not found`,
+    };
+  }
+
+  // Check if already installed
+  if (existsSync(destPath) && !overwrite) {
+    return {
+      hook: shortName,
+      success: false,
+      error: `Already installed. Use --overwrite to replace.`,
+      path: destPath,
+    };
+  }
+
+  try {
+    // Ensure .hooks directory exists
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    // Copy hook
+    cpSync(sourcePath, destPath, { recursive: true });
+
+    // Register hook in Claude settings
+    registerHookInSettings(shortName);
+
+    // Update .hooks/index.ts
+    updateHooksIndex(destDir);
+
+    return {
+      hook: shortName,
+      success: true,
+      path: destPath,
+    };
+  } catch (error) {
+    return {
+      hook: shortName,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Register a hook in ~/.claude/settings.json
+ */
+function registerHookInSettings(name: string): void {
+  const meta = getHook(name);
+  if (!meta) return;
+
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+
+  const eventKey = meta.event;
+  if (!settings.hooks[eventKey]) settings.hooks[eventKey] = [];
+
+  // Check if already registered
+  const hookCommand = `hook-${name}`;
+  const existing = settings.hooks[eventKey].find((entry: any) =>
+    entry.hooks?.some((h: any) => h.command?.includes(hookCommand))
+  );
+  if (existing) return;
+
+  const entry: Record<string, any> = {
+    hooks: [{ type: "command", command: hookCommand }],
+  };
+  if (meta.matcher) {
+    entry.matcher = meta.matcher;
+  }
+
+  settings.hooks[eventKey].push(entry);
+  writeSettings(settings);
+}
+
+/**
+ * Unregister a hook from ~/.claude/settings.json
+ */
+function unregisterHookFromSettings(name: string): void {
+  const meta = getHook(name);
+  if (!meta) return;
+
+  const settings = readSettings();
+  if (!settings.hooks) return;
+
+  const eventKey = meta.event;
+  if (!settings.hooks[eventKey]) return;
+
+  const hookCommand = `hook-${name}`;
+  settings.hooks[eventKey] = settings.hooks[eventKey].filter(
+    (entry: any) =>
+      !entry.hooks?.some((h: any) => h.command?.includes(hookCommand))
+  );
+
+  // Clean up empty arrays
+  if (settings.hooks[eventKey].length === 0) {
+    delete settings.hooks[eventKey];
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  writeSettings(settings);
+}
+
+/**
+ * Install multiple hooks
+ */
+export function installHooks(
+  names: string[],
+  options: InstallOptions = {}
+): InstallResult[] {
+  return names.map((name) => installHook(name, options));
+}
+
+/**
+ * Update the .hooks/index.ts file to export all installed hooks
+ */
+function updateHooksIndex(hooksDir: string): void {
+  const indexPath = join(hooksDir, "index.ts");
+  const { readdirSync } = require("fs");
+  const hooks = readdirSync(hooksDir).filter(
+    (f: string) => f.startsWith("hook-") && !f.includes(".")
+  );
+
+  const exports = hooks
+    .map((h: string) => {
+      const name = h.replace("hook-", "");
+      return `export * as ${name} from './${h}/src/index.js';`;
+    })
+    .join("\n");
+
+  const content = `/**
+ * Auto-generated index of installed hooks
+ * Do not edit manually - run 'hooks install' to update
+ */
+
+${exports}
+`;
+
+  writeFileSync(indexPath, content);
+}
+
+/**
+ * Get list of installed hooks in a directory
+ */
+export function getInstalledHooks(targetDir: string = process.cwd()): string[] {
+  const hooksDir = join(targetDir, ".hooks");
+
+  if (!existsSync(hooksDir)) {
+    return [];
+  }
+
+  const { readdirSync, statSync } = require("fs");
+  return readdirSync(hooksDir)
+    .filter((f: string) => {
+      const fullPath = join(hooksDir, f);
+      return f.startsWith("hook-") && statSync(fullPath).isDirectory();
+    })
+    .map((f: string) => f.replace("hook-", ""));
+}
+
+/**
+ * Check which hooks are registered in Claude settings
+ */
+export function getRegisteredHooks(): string[] {
+  const settings = readSettings();
+  if (!settings.hooks) return [];
+
+  const registered: string[] = [];
+  for (const eventKey of Object.keys(settings.hooks)) {
+    for (const entry of settings.hooks[eventKey]) {
+      for (const hook of entry.hooks || []) {
+        const match = hook.command?.match(/hook-(\w+)/);
+        if (match) {
+          registered.push(match[1]);
+        }
+      }
+    }
+  }
+  return [...new Set(registered)];
+}
+
+/**
+ * Remove an installed hook
+ */
+export function removeHook(
+  name: string,
+  targetDir: string = process.cwd()
+): boolean {
+  const { rmSync } = require("fs");
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  const shortName = hookName.replace("hook-", "");
+  const hooksDir = join(targetDir, ".hooks");
+  const hookPath = join(hooksDir, hookName);
+
+  if (!existsSync(hookPath)) {
+    return false;
+  }
+
+  rmSync(hookPath, { recursive: true });
+  unregisterHookFromSettings(shortName);
+  updateHooksIndex(hooksDir);
+  return true;
+}