@hasna/hooks 0.0.6 → 0.1.0

package/bin/index.js

@@ -17,6 +17,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // node_modules/commander/lib/error.js
@@ -1858,6 +1868,335 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/lib/registry.ts
+function getHooksByCategory(category) {
+  return HOOKS.filter((h) => h.category === category);
+}
+function searchHooks(query) {
+  const q = query.toLowerCase();
+  return HOOKS.filter((h) => h.name.toLowerCase().includes(q) || h.displayName.toLowerCase().includes(q) || h.description.toLowerCase().includes(q) || h.tags.some((t) => t.includes(q)));
+}
+function getHook(name) {
+  return HOOKS.find((h) => h.name === name);
+}
+var CATEGORIES, HOOKS;
+var init_registry = __esm(() => {
+  CATEGORIES = [
+    "Git Safety",
+    "Code Quality",
+    "Security",
+    "Notifications",
+    "Context Management",
+    "Workflow Automation",
+    "Environment",
+    "Permissions",
+    "Observability",
+    "Agent Teams"
+  ];
+  HOOKS = [
+    {
+      name: "gitguard",
+      displayName: "Git Guard",
+      description: "Blocks destructive git operations like reset --hard, push --force, clean -f",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["git", "safety", "destructive", "guard"]
+    },
+    {
+      name: "branchprotect",
+      displayName: "Branch Protect",
+      description: "Prevents editing files directly on main/master branch",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Write|Edit|NotebookEdit",
+      tags: ["git", "branch", "protection", "main"]
+    },
+    {
+      name: "checkpoint",
+      displayName: "Checkpoint",
+      description: "Creates shadow git snapshots before file modifications for easy rollback",
+      version: "0.1.0",
+      category: "Git Safety",
+      event: "PreToolUse",
+      matcher: "Write|Edit|NotebookEdit",
+      tags: ["git", "snapshot", "rollback", "backup"]
+    },
+    {
+      name: "checktests",
+      displayName: "Check Tests",
+      description: "Checks for missing tests after file edits",
+      version: "0.1.6",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tests", "coverage", "quality"]
+    },
+    {
+      name: "checklint",
+      displayName: "Check Lint",
+      description: "Runs linting after file edits and creates tasks for errors",
+      version: "0.1.7",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["lint", "style", "quality"]
+    },
+    {
+      name: "checkfiles",
+      displayName: "Check Files",
+      description: "Runs headless agent to review files and create tasks",
+      version: "0.1.4",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["review", "files", "quality"]
+    },
+    {
+      name: "checkbugs",
+      displayName: "Check Bugs",
+      description: "Checks for bugs via Codex headless agent",
+      version: "0.1.6",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["bugs", "analysis", "quality"]
+    },
+    {
+      name: "checkdocs",
+      displayName: "Check Docs",
+      description: "Checks for missing documentation and creates tasks",
+      version: "0.2.1",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["docs", "documentation", "quality"]
+    },
+    {
+      name: "checktasks",
+      displayName: "Check Tasks",
+      description: "Validates task completion and tracks progress",
+      version: "1.0.8",
+      category: "Code Quality",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["tasks", "tracking", "quality"]
+    },
+    {
+      name: "checksecurity",
+      displayName: "Check Security",
+      description: "Runs security checks via Claude and Codex headless agents",
+      version: "0.1.6",
+      category: "Security",
+      event: "PostToolUse",
+      matcher: "Edit|Write|NotebookEdit",
+      tags: ["security", "audit", "vulnerabilities"]
+    },
+    {
+      name: "packageage",
+      displayName: "Package Age",
+      description: "Checks package age before install to prevent typosquatting",
+      version: "0.1.1",
+      category: "Security",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["npm", "packages", "typosquatting", "supply-chain"]
+    },
+    {
+      name: "phonenotify",
+      displayName: "Phone Notify",
+      description: "Sends push notifications to phone via ntfy.sh",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "phone", "push", "ntfy"]
+    },
+    {
+      name: "agentmessages",
+      displayName: "Agent Messages",
+      description: "Inter-agent messaging integration for service-message",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["messaging", "agents", "inter-agent"]
+    },
+    {
+      name: "contextrefresh",
+      displayName: "Context Refresh",
+      description: "Re-injects important context every N prompts to prevent drift",
+      version: "0.1.0",
+      category: "Context Management",
+      event: "Notification",
+      matcher: "",
+      tags: ["context", "memory", "prompts", "refresh"]
+    },
+    {
+      name: "precompact",
+      displayName: "Pre-Compact",
+      description: "Saves session state before context compaction",
+      version: "0.1.0",
+      category: "Context Management",
+      event: "Notification",
+      matcher: "",
+      tags: ["context", "compaction", "state", "backup"]
+    },
+    {
+      name: "autoformat",
+      displayName: "Auto Format",
+      description: "Runs project formatter (Prettier, Biome, Ruff, Black, gofmt) after file edits",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Edit|Write",
+      tags: ["format", "prettier", "biome", "ruff", "black", "gofmt", "style"]
+    },
+    {
+      name: "autostage",
+      displayName: "Auto Stage",
+      description: "Automatically git-stages files after Claude edits them",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PostToolUse",
+      matcher: "Edit|Write",
+      tags: ["git", "stage", "add", "auto"]
+    },
+    {
+      name: "tddguard",
+      displayName: "TDD Guard",
+      description: "Blocks implementation edits unless corresponding test files exist",
+      version: "0.1.0",
+      category: "Workflow Automation",
+      event: "PreToolUse",
+      matcher: "Edit|Write",
+      tags: ["tdd", "tests", "red-green-refactor", "enforcement"]
+    },
+    {
+      name: "envsetup",
+      displayName: "Env Setup",
+      description: "Warns when nvm, virtualenv, asdf, or rbenv may need activation before commands",
+      version: "0.1.0",
+      category: "Environment",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["nvm", "virtualenv", "asdf", "rbenv", "environment", "python", "node"]
+    },
+    {
+      name: "permissionguard",
+      displayName: "Permission Guard",
+      description: "Auto-approves safe read-only commands and blocks dangerous operations",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "Bash",
+      tags: ["permission", "allowlist", "blocklist", "safety", "auto-approve"]
+    },
+    {
+      name: "protectfiles",
+      displayName: "Protect Files",
+      description: "Blocks access to .env, secrets, SSH keys, and lock files",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "Edit|Write|Read|Bash",
+      tags: ["security", "env", "secrets", "keys", "lock-files", "protect"]
+    },
+    {
+      name: "promptguard",
+      displayName: "Prompt Guard",
+      description: "Blocks prompt injection attempts and credential access requests",
+      version: "0.1.0",
+      category: "Permissions",
+      event: "PreToolUse",
+      matcher: "",
+      tags: ["prompt", "injection", "security", "validation", "guard"]
+    },
+    {
+      name: "desktopnotify",
+      displayName: "Desktop Notify",
+      description: "Sends native desktop notifications via osascript (macOS) or notify-send (Linux)",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "desktop", "macos", "linux", "native"]
+    },
+    {
+      name: "slacknotify",
+      displayName: "Slack Notify",
+      description: "Sends Slack webhook notifications when Claude finishes",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "slack", "webhook", "team"]
+    },
+    {
+      name: "soundnotify",
+      displayName: "Sound Notify",
+      description: "Plays a system sound when Claude finishes (macOS/Linux)",
+      version: "0.1.0",
+      category: "Notifications",
+      event: "Stop",
+      matcher: "",
+      tags: ["notification", "sound", "audio", "alert"]
+    },
+    {
+      name: "sessionlog",
+      displayName: "Session Log",
+      description: "Logs every tool call to .claude/session-log-<date>.jsonl",
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["logging", "audit", "session", "history", "jsonl"]
+    },
+    {
+      name: "commandlog",
+      displayName: "Command Log",
+      description: "Logs every bash command Claude runs to .claude/commands.log",
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "Bash",
+      tags: ["logging", "bash", "commands", "audit"]
+    },
+    {
+      name: "costwatch",
+      displayName: "Cost Watch",
+      description: "Estimates session token usage and warns when budget threshold is exceeded",
+      version: "0.1.0",
+      category: "Observability",
+      event: "Stop",
+      matcher: "",
+      tags: ["cost", "tokens", "budget", "usage", "monitoring"]
+    },
+    {
+      name: "errornotify",
+      displayName: "Error Notify",
+      description: "Detects tool failures and logs errors to .claude/errors.log",
+      version: "0.1.0",
+      category: "Observability",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["errors", "failures", "logging", "debugging"]
+    },
+    {
+      name: "taskgate",
+      displayName: "Task Gate",
+      description: "Validates task completion criteria before allowing tasks to be marked done",
+      version: "0.1.0",
+      category: "Agent Teams",
+      event: "PostToolUse",
+      matcher: "",
+      tags: ["tasks", "completion", "gate", "quality", "agent-teams"]
+    }
+  ];
+});
+
 // node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports, module) => {
   module.exports = {
@@ -3498,6 +3837,397 @@ var require_cli_spinners = __commonJS((exports, module) => {
   module.exports = spinners;
 });
 
+// src/lib/installer.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+function getSettingsPath(scope = "global") {
+  if (scope === "project") {
+    return join(process.cwd(), ".claude", "settings.json");
+  }
+  return join(homedir(), ".claude", "settings.json");
+}
+function getHookPath(name) {
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  return join(HOOKS_DIR, hookName);
+}
+function hookExists(name) {
+  return existsSync(getHookPath(name));
+}
+function readSettings(scope = "global") {
+  const path = getSettingsPath(scope);
+  try {
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+function writeSettings(settings, scope = "global") {
+  const path = getSettingsPath(scope);
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(settings, null, 2) + `
+`);
+}
+function installHook(name, options = {}) {
+  const { scope = "global", overwrite = false } = options;
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  const shortName = hookName.replace("hook-", "");
+  if (!hookExists(shortName)) {
+    return { hook: shortName, success: false, error: `Hook '${shortName}' not found` };
+  }
+  const registered = getRegisteredHooks(scope);
+  if (registered.includes(shortName) && !overwrite) {
+    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope };
+  }
+  try {
+    registerHook(shortName, scope);
+    return { hook: shortName, success: true, scope };
+  } catch (error) {
+    return {
+      hook: shortName,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function registerHook(name, scope = "global") {
+  const meta = getHook(name);
+  if (!meta)
+    return;
+  const settings = readSettings(scope);
+  if (!settings.hooks)
+    settings.hooks = {};
+  const eventKey = meta.event;
+  if (!settings.hooks[eventKey])
+    settings.hooks[eventKey] = [];
+  const hookCommand = `hooks run ${name}`;
+  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry2) => !entry2.hooks?.some((h) => h.command === hookCommand));
+  const entry = {
+    hooks: [{ type: "command", command: hookCommand }]
+  };
+  if (meta.matcher) {
+    entry.matcher = meta.matcher;
+  }
+  settings.hooks[eventKey].push(entry);
+  writeSettings(settings, scope);
+}
+function unregisterHook(name, scope = "global") {
+  const meta = getHook(name);
+  if (!meta)
+    return;
+  const settings = readSettings(scope);
+  if (!settings.hooks)
+    return;
+  const eventKey = meta.event;
+  if (!settings.hooks[eventKey])
+    return;
+  const hookCommand = `hooks run ${name}`;
+  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry) => !entry.hooks?.some((h) => h.command === hookCommand));
+  if (settings.hooks[eventKey].length === 0) {
+    delete settings.hooks[eventKey];
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings, scope);
+}
+function getRegisteredHooks(scope = "global") {
+  const settings = readSettings(scope);
+  if (!settings.hooks)
+    return [];
+  const registered = [];
+  for (const eventKey of Object.keys(settings.hooks)) {
+    for (const entry of settings.hooks[eventKey]) {
+      for (const hook of entry.hooks || []) {
+        const newMatch = hook.command?.match(/^hooks run (\w+)$/);
+        const oldMatch = hook.command?.match(/^hook-(\w+)$/);
+        const match = newMatch || oldMatch;
+        if (match) {
+          registered.push(match[1]);
+        }
+      }
+    }
+  }
+  return [...new Set(registered)];
+}
+function getInstalledHooks(scope = "global") {
+  return getRegisteredHooks(scope);
+}
+function removeHook(name, scope = "global") {
+  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
+  const shortName = hookName.replace("hook-", "");
+  const registered = getRegisteredHooks(scope);
+  if (!registered.includes(shortName)) {
+    return false;
+  }
+  unregisterHook(shortName, scope);
+  return true;
+}
+var __dirname2, HOOKS_DIR;
+var init_installer = __esm(() => {
+  init_registry();
+  __dirname2 = dirname(fileURLToPath(import.meta.url));
+  HOOKS_DIR = existsSync(join(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join(__dirname2, "..", "..", "hooks") : join(__dirname2, "..", "hooks");
+});
+
+// src/mcp/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startStdioServer: () => startStdioServer,
+  startSSEServer: () => startSSEServer,
+  createHooksServer: () => createHooksServer,
+  MCP_PORT: () => MCP_PORT
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { createServer } from "http";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function createHooksServer() {
+  const server = new McpServer({
+    name: "@hasna/hooks",
+    version: "0.0.7"
+  });
+  server.tool("hooks_list", "List all available Claude Code hooks, optionally filtered by category", { category: z.string().optional().describe("Filter by category name (e.g. 'Git Safety', 'Code Quality', 'Security', 'Notifications', 'Context Management')") }, async ({ category }) => {
+    if (category) {
+      const cat = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
+      if (!cat) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown category: ${category}`, available: [...CATEGORIES] }) }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(getHooksByCategory(cat)) }] };
+    }
+    const result = {};
+    for (const cat of CATEGORIES) {
+      result[cat] = getHooksByCategory(cat);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  server.tool("hooks_search", "Search for hooks by name, description, or tags", { query: z.string().describe("Search query") }, async ({ query }) => {
+    const results = searchHooks(query);
+    return { content: [{ type: "text", text: JSON.stringify(results) }] };
+  });
+  server.tool("hooks_info", "Get detailed information about a specific hook including install status", { name: z.string().describe("Hook name (e.g. 'gitguard', 'checkpoint')") }, async ({ name }) => {
+    const meta = getHook(name);
+    if (!meta) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
+    }
+    const globalInstalled = getRegisteredHooks("global").includes(meta.name);
+    const projectInstalled = getRegisteredHooks("project").includes(meta.name);
+    return { content: [{ type: "text", text: JSON.stringify({ ...meta, global: globalInstalled, project: projectInstalled }) }] };
+  });
+  server.tool("hooks_install", "Install one or more hooks by registering them in Claude settings. Use scope 'global' for ~/.claude/settings.json or 'project' for .claude/settings.json", {
+    hooks: z.array(z.string()).describe("Hook names to install"),
+    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z.boolean().default(false).describe("Overwrite if already installed")
+  }, async ({ hooks, scope, overwrite }) => {
+    const results = hooks.map((name) => installHook(name, { scope, overwrite }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          installed: results.filter((r) => r.success).map((r) => r.hook),
+          failed: results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error })),
+          total: results.length,
+          success: results.filter((r) => r.success).length,
+          scope
+        })
+      }]
+    };
+  });
+  server.tool("hooks_install_category", "Install all hooks in a category", {
+    category: z.string().describe("Category name"),
+    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z.boolean().default(false).describe("Overwrite if already installed")
+  }, async ({ category, scope, overwrite }) => {
+    const cat = CATEGORIES.find((c) => c.toLowerCase() === category.toLowerCase());
+    if (!cat) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: `Unknown category: ${category}`, available: [...CATEGORIES] }) }] };
+    }
+    const hooks = getHooksByCategory(cat).map((h) => h.name);
+    const results = hooks.map((name) => installHook(name, { scope, overwrite }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          installed: results.filter((r) => r.success).map((r) => r.hook),
+          failed: results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error })),
+          category: cat,
+          scope
+        })
+      }]
+    };
+  });
+  server.tool("hooks_install_all", "Install all available hooks", {
+    scope: z.enum(["global", "project"]).default("global").describe("Install scope"),
+    overwrite: z.boolean().default(false).describe("Overwrite if already installed")
+  }, async ({ scope, overwrite }) => {
+    const results = HOOKS.map((h) => installHook(h.name, { scope, overwrite }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          installed: results.filter((r) => r.success).map((r) => r.hook),
+          failed: results.filter((r) => !r.success).map((r) => ({ hook: r.hook, error: r.error })),
+          total: results.length,
+          success: results.filter((r) => r.success).length,
+          scope
+        })
+      }]
+    };
+  });
+  server.tool("hooks_remove", "Remove (unregister) a hook from Claude settings", {
+    name: z.string().describe("Hook name to remove"),
+    scope: z.enum(["global", "project"]).default("global").describe("Scope to remove from")
+  }, async ({ name, scope }) => {
+    const removed = removeHook(name, scope);
+    return { content: [{ type: "text", text: JSON.stringify({ hook: name, removed, scope }) }] };
+  });
+  server.tool("hooks_doctor", "Check health of installed hooks \u2014 verifies hook source exists, settings are correct", {
+    scope: z.enum(["global", "project"]).default("global").describe("Scope to check")
+  }, async ({ scope }) => {
+    const settingsPath = getSettingsPath(scope);
+    const issues = [];
+    const healthy = [];
+    const settingsExist = existsSync2(settingsPath);
+    if (!settingsExist) {
+      issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
+    }
+    const registered = getRegisteredHooks(scope);
+    for (const name of registered) {
+      const meta = getHook(name);
+      let hookHealthy = true;
+      if (!hookExists(name)) {
+        issues.push({ hook: name, issue: "Hook not found in @hasna/hooks package", severity: "error" });
+        continue;
+      }
+      const hookDir = getHookPath(name);
+      if (!existsSync2(join2(hookDir, "src", "hook.ts"))) {
+        issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
+        hookHealthy = false;
+      }
+      if (meta && settingsExist) {
+        try {
+          const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+          const eventHooks = settings.hooks?.[meta.event] || [];
+          const found = eventHooks.some((entry) => entry.hooks?.some((h) => h.command === `hooks run ${name}`));
+          if (!found) {
+            issues.push({ hook: name, issue: `Not registered under correct event (${meta.event})`, severity: "error" });
+            hookHealthy = false;
+          }
+        } catch {}
+      }
+      if (hookHealthy)
+        healthy.push(name);
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ healthy, issues, registered, scope }) }] };
+  });
+  server.tool("hooks_categories", "List all hook categories with counts", {}, async () => {
+    const result = CATEGORIES.map((cat) => ({
+      name: cat,
+      count: getHooksByCategory(cat).length
+    }));
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  server.tool("hooks_docs", "Get documentation \u2014 general overview or README for a specific hook", { name: z.string().optional().describe("Hook name for specific docs, omit for general docs") }, async ({ name }) => {
+    if (name) {
+      const meta = getHook(name);
+      if (!meta) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: `Hook '${name}' not found` }) }] };
+      }
+      const hookPath = getHookPath(name);
+      const readmePath = join2(hookPath, "README.md");
+      let readme = "";
+      if (existsSync2(readmePath)) {
+        readme = readFileSync2(readmePath, "utf-8");
+      }
+      return { content: [{ type: "text", text: JSON.stringify({ ...meta, readme }) }] };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          overview: "Claude Code hooks are scripts that run at specific points in a Claude Code session. Install @hasna/hooks globally, then register hooks \u2014 no files are copied to your project.",
+          events: {
+            PreToolUse: "Fires before a tool executes. Can block the operation.",
+            PostToolUse: "Fires after a tool executes. Runs asynchronously.",
+            Stop: "Fires when a session ends. Useful for notifications.",
+            Notification: "Fires on notification events like context compaction."
+          },
+          commands: {
+            install: "hooks install <name>",
+            installProject: "hooks install <name> --project",
+            installAll: "hooks install --all",
+            remove: "hooks remove <name>",
+            list: "hooks list",
+            search: "hooks search <query>",
+            doctor: "hooks doctor"
+          }
+        })
+      }]
+    };
+  });
+  server.tool("hooks_registered", "Get list of currently registered hooks for a scope", {
+    scope: z.enum(["global", "project"]).default("global").describe("Scope to check")
+  }, async ({ scope }) => {
+    const registered = getRegisteredHooks(scope);
+    const result = registered.map((name) => {
+      const meta = getHook(name);
+      return { name, event: meta?.event, version: meta?.version, description: meta?.description };
+    });
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  return server;
+}
+async function startSSEServer(port = MCP_PORT) {
+  const server = createHooksServer();
+  const transports = new Map;
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    if (url.pathname === "/sse") {
+      const transport = new SSEServerTransport("/messages", res);
+      transports.set(transport.sessionId, transport);
+      res.on("close", () => transports.delete(transport.sessionId));
+      await server.connect(transport);
+    } else if (url.pathname === "/messages") {
+      const sessionId = url.searchParams.get("sessionId");
+      if (!sessionId || !transports.has(sessionId)) {
+        res.writeHead(400);
+        res.end("Invalid session");
+        return;
+      }
+      const transport = transports.get(sessionId);
+      let body = "";
+      for await (const chunk of req)
+        body += chunk;
+      await transport.handlePostMessage(req, res, body);
+    } else {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ name: "@hasna/hooks", version: "0.0.7", transport: "sse", port }));
+    }
+  });
+  httpServer.listen(port, () => {
+    console.error(`@hasna/hooks MCP server running on http://localhost:${port}`);
+    console.error(`SSE endpoint: http://localhost:${port}/sse`);
+  });
+}
+async function startStdioServer() {
+  const server = createHooksServer();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+var MCP_PORT = 39427;
+var init_server = __esm(() => {
+  init_registry();
+  init_installer();
+});
+
 // src/cli/index.tsx
 import { render } from "ink";
 
@@ -3519,8 +4249,8 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 
 // src/cli/components/App.tsx
 import { useState as useState7 } from "react";
@@ -3952,179 +4682,7 @@ function Header({ title = "Hooks", subtitle }) {
 
 // src/cli/components/CategorySelect.tsx
 import { Box as Box4, Text as Text4 } from "ink";
-
-// src/lib/registry.ts
-var CATEGORIES = [
-  "Git Safety",
-  "Code Quality",
-  "Security",
-  "Notifications",
-  "Context Management"
-];
-var HOOKS = [
-  {
-    name: "gitguard",
-    displayName: "Git Guard",
-    description: "Blocks destructive git operations like reset --hard, push --force, clean -f",
-    version: "0.1.0",
-    category: "Git Safety",
-    event: "PreToolUse",
-    matcher: "Bash",
-    tags: ["git", "safety", "destructive", "guard"]
-  },
-  {
-    name: "branchprotect",
-    displayName: "Branch Protect",
-    description: "Prevents editing files directly on main/master branch",
-    version: "0.1.0",
-    category: "Git Safety",
-    event: "PreToolUse",
-    matcher: "Write|Edit|NotebookEdit",
-    tags: ["git", "branch", "protection", "main"]
-  },
-  {
-    name: "checkpoint",
-    displayName: "Checkpoint",
-    description: "Creates shadow git snapshots before file modifications for easy rollback",
-    version: "0.1.0",
-    category: "Git Safety",
-    event: "PreToolUse",
-    matcher: "Write|Edit|NotebookEdit",
-    tags: ["git", "snapshot", "rollback", "backup"]
-  },
-  {
-    name: "checktests",
-    displayName: "Check Tests",
-    description: "Checks for missing tests after file edits",
-    version: "0.1.6",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["tests", "coverage", "quality"]
-  },
-  {
-    name: "checklint",
-    displayName: "Check Lint",
-    description: "Runs linting after file edits and creates tasks for errors",
-    version: "0.1.7",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["lint", "style", "quality"]
-  },
-  {
-    name: "checkfiles",
-    displayName: "Check Files",
-    description: "Runs headless agent to review files and create tasks",
-    version: "0.1.4",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["review", "files", "quality"]
-  },
-  {
-    name: "checkbugs",
-    displayName: "Check Bugs",
-    description: "Checks for bugs via Codex headless agent",
-    version: "0.1.6",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["bugs", "analysis", "quality"]
-  },
-  {
-    name: "checkdocs",
-    displayName: "Check Docs",
-    description: "Checks for missing documentation and creates tasks",
-    version: "0.2.1",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["docs", "documentation", "quality"]
-  },
-  {
-    name: "checktasks",
-    displayName: "Check Tasks",
-    description: "Validates task completion and tracks progress",
-    version: "1.0.8",
-    category: "Code Quality",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["tasks", "tracking", "quality"]
-  },
-  {
-    name: "checksecurity",
-    displayName: "Check Security",
-    description: "Runs security checks via Claude and Codex headless agents",
-    version: "0.1.6",
-    category: "Security",
-    event: "PostToolUse",
-    matcher: "Edit|Write|NotebookEdit",
-    tags: ["security", "audit", "vulnerabilities"]
-  },
-  {
-    name: "packageage",
-    displayName: "Package Age",
-    description: "Checks package age before install to prevent typosquatting",
-    version: "0.1.1",
-    category: "Security",
-    event: "PreToolUse",
-    matcher: "Bash",
-    tags: ["npm", "packages", "typosquatting", "supply-chain"]
-  },
-  {
-    name: "phonenotify",
-    displayName: "Phone Notify",
-    description: "Sends push notifications to phone via ntfy.sh",
-    version: "0.1.0",
-    category: "Notifications",
-    event: "Stop",
-    matcher: "",
-    tags: ["notification", "phone", "push", "ntfy"]
-  },
-  {
-    name: "agentmessages",
-    displayName: "Agent Messages",
-    description: "Inter-agent messaging integration for service-message",
-    version: "0.1.0",
-    category: "Notifications",
-    event: "Stop",
-    matcher: "",
-    tags: ["messaging", "agents", "inter-agent"]
-  },
-  {
-    name: "contextrefresh",
-    displayName: "Context Refresh",
-    description: "Re-injects important context every N prompts to prevent drift",
-    version: "0.1.0",
-    category: "Context Management",
-    event: "Notification",
-    matcher: "",
-    tags: ["context", "memory", "prompts", "refresh"]
-  },
-  {
-    name: "precompact",
-    displayName: "Pre-Compact",
-    description: "Saves session state before context compaction",
-    version: "0.1.0",
-    category: "Context Management",
-    event: "Notification",
-    matcher: "",
-    tags: ["context", "compaction", "state", "backup"]
-  }
-];
-function getHooksByCategory(category) {
-  return HOOKS.filter((h) => h.category === category);
-}
-function searchHooks(query) {
-  const q = query.toLowerCase();
-  return HOOKS.filter((h) => h.name.toLowerCase().includes(q) || h.displayName.toLowerCase().includes(q) || h.description.toLowerCase().includes(q) || h.tags.some((t) => t.includes(q)));
-}
-function getHook(name) {
-  return HOOKS.find((h) => h.name === name);
-}
-
-// src/cli/components/CategorySelect.tsx
+init_registry();
 import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
 function CategorySelect({ onSelect, onBack }) {
   const items = CATEGORIES.map((cat) => ({
@@ -4414,6 +4972,7 @@ function TextInput({ value: originalValue, placeholder = "", focus = true, mask,
 var build_default = TextInput;
 
 // src/cli/components/SearchView.tsx
+init_registry();
 import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
 function SearchView({
   selected,
@@ -4520,141 +5079,9 @@ function Spinner({ type = "dots" }) {
 }
 var build_default2 = Spinner;
 
-// src/lib/installer.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var HOOKS_DIR = existsSync(join(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join(__dirname2, "..", "..", "hooks") : join(__dirname2, "..", "hooks");
-function getSettingsPath(scope = "global") {
-  if (scope === "project") {
-    return join(process.cwd(), ".claude", "settings.json");
-  }
-  return join(homedir(), ".claude", "settings.json");
-}
-function getHookPath(name) {
-  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
-  return join(HOOKS_DIR, hookName);
-}
-function hookExists(name) {
-  return existsSync(getHookPath(name));
-}
-function readSettings(scope = "global") {
-  const path = getSettingsPath(scope);
-  try {
-    if (existsSync(path)) {
-      return JSON.parse(readFileSync(path, "utf-8"));
-    }
-  } catch {}
-  return {};
-}
-function writeSettings(settings, scope = "global") {
-  const path = getSettingsPath(scope);
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(path, JSON.stringify(settings, null, 2) + `
-`);
-}
-function installHook(name, options = {}) {
-  const { scope = "global", overwrite = false } = options;
-  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
-  const shortName = hookName.replace("hook-", "");
-  if (!hookExists(shortName)) {
-    return { hook: shortName, success: false, error: `Hook '${shortName}' not found` };
-  }
-  const registered = getRegisteredHooks(scope);
-  if (registered.includes(shortName) && !overwrite) {
-    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope };
-  }
-  try {
-    registerHook(shortName, scope);
-    return { hook: shortName, success: true, scope };
-  } catch (error) {
-    return {
-      hook: shortName,
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-}
-function registerHook(name, scope = "global") {
-  const meta = getHook(name);
-  if (!meta)
-    return;
-  const settings = readSettings(scope);
-  if (!settings.hooks)
-    settings.hooks = {};
-  const eventKey = meta.event;
-  if (!settings.hooks[eventKey])
-    settings.hooks[eventKey] = [];
-  const hookCommand = `hooks run ${name}`;
-  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry2) => !entry2.hooks?.some((h) => h.command === hookCommand));
-  const entry = {
-    hooks: [{ type: "command", command: hookCommand }]
-  };
-  if (meta.matcher) {
-    entry.matcher = meta.matcher;
-  }
-  settings.hooks[eventKey].push(entry);
-  writeSettings(settings, scope);
-}
-function unregisterHook(name, scope = "global") {
-  const meta = getHook(name);
-  if (!meta)
-    return;
-  const settings = readSettings(scope);
-  if (!settings.hooks)
-    return;
-  const eventKey = meta.event;
-  if (!settings.hooks[eventKey])
-    return;
-  const hookCommand = `hooks run ${name}`;
-  settings.hooks[eventKey] = settings.hooks[eventKey].filter((entry) => !entry.hooks?.some((h) => h.command === hookCommand));
-  if (settings.hooks[eventKey].length === 0) {
-    delete settings.hooks[eventKey];
-  }
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
-  }
-  writeSettings(settings, scope);
-}
-function getRegisteredHooks(scope = "global") {
-  const settings = readSettings(scope);
-  if (!settings.hooks)
-    return [];
-  const registered = [];
-  for (const eventKey of Object.keys(settings.hooks)) {
-    for (const entry of settings.hooks[eventKey]) {
-      for (const hook of entry.hooks || []) {
-        const newMatch = hook.command?.match(/^hooks run (\w+)$/);
-        const oldMatch = hook.command?.match(/^hook-(\w+)$/);
-        const match = newMatch || oldMatch;
-        if (match) {
-          registered.push(match[1]);
-        }
-      }
-    }
-  }
-  return [...new Set(registered)];
-}
-function getInstalledHooks(scope = "global") {
-  return getRegisteredHooks(scope);
-}
-function removeHook(name, scope = "global") {
-  const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
-  const shortName = hookName.replace("hook-", "");
-  const registered = getRegisteredHooks(scope);
-  if (!registered.includes(shortName)) {
-    return false;
-  }
-  unregisterHook(shortName, scope);
-  return true;
-}
-
 // src/cli/components/InstallProgress.tsx
+init_installer();
+init_registry();
 import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
 function InstallProgress({
   hooks,
@@ -4782,6 +5209,7 @@ function InstallProgress({
 }
 
 // src/cli/components/App.tsx
+init_registry();
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
 function App({ initialHooks, overwrite = false }) {
   const { exit } = useApp();
@@ -4988,6 +5416,8 @@ function App({ initialHooks, overwrite = false }) {
 }
 
 // src/cli/index.tsx
+init_registry();
+init_installer();
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 var program2 = new Command;
 function resolveScope(options) {
@@ -4995,7 +5425,7 @@ function resolveScope(options) {
     return "project";
   return "global";
 }
-program2.name("hooks").description("Install Claude Code hooks for your project").version("0.0.6");
+program2.name("hooks").description("Install Claude Code hooks for your project").version("0.1.0");
 program2.command("interactive", { isDefault: true }).alias("i").description("Interactive hook browser").action(() => {
   render(/* @__PURE__ */ jsxDEV8(App, {}, undefined, false, undefined, this));
 });
@@ -5006,8 +5436,8 @@ program2.command("run").argument("<hook>", "Hook to run").description("Execute a
     process.exit(1);
   }
   const hookDir = getHookPath(hook);
-  const hookScript = join2(hookDir, "src", "hook.ts");
-  if (!existsSync2(hookScript)) {
+  const hookScript = join3(hookDir, "src", "hook.ts");
+  if (!existsSync3(hookScript)) {
     console.error(JSON.stringify({ error: `Hook script not found: ${hookScript}` }));
     process.exit(1);
   }
@@ -5242,7 +5672,7 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
   const settingsPath = getSettingsPath(scope);
   const issues = [];
   const healthy = [];
-  const settingsExist = existsSync2(settingsPath);
+  const settingsExist = existsSync3(settingsPath);
   if (!settingsExist) {
     issues.push({ hook: "(settings)", issue: `${settingsPath} not found`, severity: "warning" });
   }
@@ -5256,14 +5686,14 @@ program2.command("doctor").option("-g, --global", "Check global settings", false
       continue;
     }
     const hookDir = getHookPath(name);
-    const hookScript = join2(hookDir, "src", "hook.ts");
-    if (!existsSync2(hookScript)) {
+    const hookScript = join3(hookDir, "src", "hook.ts");
+    if (!existsSync3(hookScript)) {
       issues.push({ hook: name, issue: "Missing src/hook.ts in package", severity: "error" });
       hookHealthy = false;
     }
     if (meta && settingsExist) {
       try {
-        const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+        const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
         const eventHooks = settings.hooks?.[meta.event] || [];
         const found = eventHooks.some((entry) => entry.hooks?.some((h) => h.command === `hooks run ${name}`));
         if (!found) {
@@ -5358,10 +5788,10 @@ program2.command("docs").argument("[hook]", "Hook name (shows general docs if om
       return;
     }
     const hookPath = getHookPath(hook);
-    const readmePath = join2(hookPath, "README.md");
+    const readmePath = join3(hookPath, "README.md");
     let readme = "";
-    if (existsSync2(readmePath)) {
-      readme = readFileSync2(readmePath, "utf-8");
+    if (existsSync3(readmePath)) {
+      readme = readFileSync3(readmePath, "utf-8");
     }
     if (options.json) {
       console.log(JSON.stringify({ ...meta, readme }));
@@ -5464,4 +5894,13 @@ ${meta.displayName} v${meta.version}
   console.log(`    hooks docs --json     Machine-readable documentation`);
   console.log();
 });
+program2.command("mcp").option("-s, --stdio", "Use stdio transport (for Claude Code integration)", false).option("-p, --port <port>", "Port for SSE transport", "39427").description("Start MCP server for AI agent integration").action(async (options) => {
+  if (options.stdio) {
+    const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+    await startStdioServer2();
+  } else {
+    const { startSSEServer: startSSEServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+    await startSSEServer2(parseInt(options.port));
+  }
+});
 program2.parse();