@hasna/hooks 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,366 @@
+// @bun
+var __require = import.meta.require;
+
+// 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/lib/installer.ts
+import { existsSync, cpSync, 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 = join(__dirname2, "..", "..", "hooks");
+var SETTINGS_PATH = 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() {
+  try {
+    if (existsSync(SETTINGS_PATH)) {
+      return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    }
+  } catch {}
+  return {};
+}
+function writeSettings(settings) {
+  const dir = dirname(SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
+`);
+}
+function installHook(name, options = {}) {
+  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);
+  if (!existsSync(sourcePath)) {
+    return {
+      hook: shortName,
+      success: false,
+      error: `Hook '${shortName}' not found`
+    };
+  }
+  if (existsSync(destPath) && !overwrite) {
+    return {
+      hook: shortName,
+      success: false,
+      error: `Already installed. Use --overwrite to replace.`,
+      path: destPath
+    };
+  }
+  try {
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+    cpSync(sourcePath, destPath, { recursive: true });
+    registerHookInSettings(shortName);
+    updateHooksIndex(destDir);
+    return {
+      hook: shortName,
+      success: true,
+      path: destPath
+    };
+  } catch (error) {
+    return {
+      hook: shortName,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function registerHookInSettings(name) {
+  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] = [];
+  const hookCommand = `hook-${name}`;
+  const existing = settings.hooks[eventKey].find((entry2) => entry2.hooks?.some((h) => h.command?.includes(hookCommand)));
+  if (existing)
+    return;
+  const entry = {
+    hooks: [{ type: "command", command: hookCommand }]
+  };
+  if (meta.matcher) {
+    entry.matcher = meta.matcher;
+  }
+  settings.hooks[eventKey].push(entry);
+  writeSettings(settings);
+}
+function unregisterHookFromSettings(name) {
+  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) => !entry.hooks?.some((h) => h.command?.includes(hookCommand)));
+  if (settings.hooks[eventKey].length === 0) {
+    delete settings.hooks[eventKey];
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings);
+}
+function installHooks(names, options = {}) {
+  return names.map((name) => installHook(name, options));
+}
+function updateHooksIndex(hooksDir) {
+  const indexPath = join(hooksDir, "index.ts");
+  const { readdirSync } = __require("fs");
+  const hooks = readdirSync(hooksDir).filter((f) => f.startsWith("hook-") && !f.includes("."));
+  const exports = hooks.map((h) => {
+    const name = h.replace("hook-", "");
+    return `export * as ${name} from './${h}/src/index.js';`;
+  }).join(`
+`);
+  const content = `/**
+ * Auto-generated index of installed hooks
+ * Do not edit manually - run 'hooks install' to update
+ */
+
+${exports}
+`;
+  writeFileSync(indexPath, content);
+}
+function getInstalledHooks(targetDir = process.cwd()) {
+  const hooksDir = join(targetDir, ".hooks");
+  if (!existsSync(hooksDir)) {
+    return [];
+  }
+  const { readdirSync, statSync } = __require("fs");
+  return readdirSync(hooksDir).filter((f) => {
+    const fullPath = join(hooksDir, f);
+    return f.startsWith("hook-") && statSync(fullPath).isDirectory();
+  }).map((f) => f.replace("hook-", ""));
+}
+function getRegisteredHooks() {
+  const settings = readSettings();
+  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 match = hook.command?.match(/hook-(\w+)/);
+        if (match) {
+          registered.push(match[1]);
+        }
+      }
+    }
+  }
+  return [...new Set(registered)];
+}
+function removeHook(name, targetDir = process.cwd()) {
+  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;
+}
+export {
+  searchHooks,
+  removeHook,
+  installHooks,
+  installHook,
+  hookExists,
+  getRegisteredHooks,
+  getInstalledHooks,
+  getHooksByCategory,
+  getHookPath,
+  getHook,
+  HOOKS,
+  CATEGORIES
+};

package/hooks/hook-agentmessages/bin/cli.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * CLI for hook-agentmessages
+ *
+ * Usage:
+ *   hook-agentmessages install    - Install hooks into Claude Code
+ *   hook-agentmessages uninstall  - Remove hooks from Claude Code
+ *   hook-agentmessages status     - Show hook status
+ */
+
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CLAUDE_SETTINGS_FILE = join(homedir(), '.claude', 'settings.json');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function showStatus() {
+  console.log('hook-agentmessages status\n');
+
+  // Check if hooks are installed
+  try {
+    const file = Bun.file(CLAUDE_SETTINGS_FILE);
+    if (await file.exists()) {
+      const settings = await file.json();
+
+      if (settings.hooks) {
+        let installed = false;
+
+        if (settings.hooks.SessionStart) {
+          const hasHook = settings.hooks.SessionStart.some((h: any) =>
+            h.hooks?.some((hook: any) => hook.command?.includes('hook-agentmessages'))
+          );
+          if (hasHook) {
+            console.log('  SessionStart hook: installed');
+            installed = true;
+          }
+        }
+
+        if (settings.hooks.Stop) {
+          const hasHook = settings.hooks.Stop.some((h: any) =>
+            h.hooks?.some((hook: any) => hook.command?.includes('hook-agentmessages'))
+          );
+          if (hasHook) {
+            console.log('  Stop hook: installed');
+            installed = true;
+          }
+        }
+
+        if (!installed) {
+          console.log('  No hook-agentmessages hooks installed');
+        }
+      } else {
+        console.log('  No hooks configured in Claude Code');
+      }
+    } else {
+      console.log('  Claude Code settings not found');
+    }
+  } catch (err) {
+    console.log('  Error reading settings:', (err as Error).message);
+  }
+
+  // Check service-message status
+  const serviceDir = join(homedir(), '.service', 'service-message');
+  const configFile = Bun.file(join(serviceDir, 'config.json'));
+
+  console.log('\nservice-message integration:');
+  if (await configFile.exists()) {
+    const config = await configFile.json();
+    console.log(`  Agent ID: ${config.agentId || 'not set'}`);
+    console.log(`  Data dir: ${serviceDir}`);
+  } else {
+    console.log('  Not configured');
+  }
+}
+
+function showHelp() {
+  console.log(`
+hook-agentmessages - Claude Code hook for service-message integration
+
+Usage:
+  hook-agentmessages <command>
+
+Commands:
+  install     Install hooks into Claude Code settings
+  uninstall   Remove hooks from Claude Code settings
+  status      Show current hook status
+
+Examples:
+  hook-agentmessages install
+  hook-agentmessages status
+`);
+}
+
+async function main() {
+  if (!command || command === '--help' || command === '-h') {
+    showHelp();
+    return;
+  }
+
+  switch (command) {
+    case 'install':
+      await import('../src/install.ts');
+      break;
+
+    case 'uninstall':
+      await import('../src/uninstall.ts');
+      break;
+
+    case 'status':
+      await showStatus();
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@hasna/hooks",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Open source Claude Code hooks library - Install hooks with a single command",
   "type": "module",
   "bin": {
-    "hooks": "./bin/index.js"
+    "hooks": "bin/index.js"
   },
   "exports": {
     ".": {

package/hooks/hook-agentmessages/src/check-messages.ts

@@ -1,151 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Stop hook for service-message
- *
- * Runs when Claude finishes a response. Checks for unread messages
- * and notifies Claude if there are any pending messages.
- *
- * This is efficient because it only runs after Claude completes a turn,
- * not continuously polling.
- */
-
-import { homedir } from 'os';
-import { join } from 'path';
-import { readdir } from 'fs/promises';
-
-interface HookInput {
-  session_id: string;
-  cwd: string;
-  hook_event_name: string;
-  stop_hook_active?: boolean;
-}
-
-interface Message {
-  id: string;
-  timestamp: number;
-  from: string;
-  to: string;
-  project: string;
-  subject: string;
-  body: string;
-  read?: boolean;
-}
-
-const SERVICE_DIR = join(homedir(), '.service', 'service-message');
-
-/**
- * Sanitize ID to prevent path traversal attacks
- */
-function sanitizeId(id: string): string | null {
-  if (!id || typeof id !== 'string') return null;
-  // Only allow alphanumeric, dash, underscore
-  if (!/^[a-zA-Z0-9_-]+$/.test(id)) return null;
-  // Reject path traversal attempts
-  if (id.includes('..') || id.includes('/') || id.includes('\\')) return null;
-  return id;
-}
-
-async function readJson<T>(path: string): Promise<T | null> {
-  try {
-    const file = Bun.file(path);
-    if (await file.exists()) {
-      return await file.json();
-    }
-  } catch {}
-  return null;
-}
-
-async function getUnreadMessages(agentId: string, projectId?: string): Promise<Message[]> {
-  const messages: Message[] = [];
-  const messagesDir = join(SERVICE_DIR, 'messages');
-
-  try {
-    const rawProjects = projectId ? [projectId] : await readdir(messagesDir);
-    // Sanitize all project names to prevent path traversal
-    const projects = rawProjects.map(p => sanitizeId(p)).filter((p): p is string => p !== null);
-
-    for (const proj of projects) {
-      // Check inbox
-      const inboxDir = join(messagesDir, proj, 'inbox', agentId);
-      try {
-        const files = await readdir(inboxDir);
-        for (const file of files) {
-          if (!file.endsWith('.json')) continue;
-          // Sanitize filename to prevent path traversal
-          const safeFile = sanitizeId(file.replace('.json', ''));
-          if (!safeFile) continue;
-          const msg = await readJson<Message>(join(inboxDir, `${safeFile}.json`));
-          if (msg && !msg.read) {
-            messages.push(msg);
-          }
-        }
-      } catch {}
-
-      // Check broadcast
-      const broadcastDir = join(messagesDir, proj, 'broadcast');
-      try {
-        const files = await readdir(broadcastDir);
-        for (const file of files) {
-          if (!file.endsWith('.json')) continue;
-          // Sanitize filename to prevent path traversal
-          const safeFile = sanitizeId(file.replace('.json', ''));
-          if (!safeFile) continue;
-          const msg = await readJson<Message>(join(broadcastDir, `${safeFile}.json`));
-          if (msg && !msg.read && msg.from !== agentId) {
-            messages.push(msg);
-          }
-        }
-      } catch {}
-    }
-  } catch {}
-
-  return messages.sort((a, b) => b.timestamp - a.timestamp);
-}
-
-async function main() {
-  // Get agent ID from environment (set by session-start hook)
-  const rawAgentId = process.env.SMSG_AGENT_ID;
-  const rawProjectId = process.env.SMSG_PROJECT_ID;
-
-  // Sanitize IDs to prevent path traversal
-  const agentId = rawAgentId ? sanitizeId(rawAgentId) : null;
-  const projectId = rawProjectId ? sanitizeId(rawProjectId) : undefined;
-
-  if (!agentId) {
-    // Agent not configured or invalid, skip silently
-    console.log(JSON.stringify({ continue: true }));
-    return;
-  }
-
-  // Check for unread messages
-  const unreadMessages = await getUnreadMessages(agentId, projectId);
-
-  if (unreadMessages.length === 0) {
-    // No messages, continue normally
-    console.log(JSON.stringify({ continue: true }));
-    return;
-  }
-
-  // Format message summary in a friendly way
-  const msgList = unreadMessages.slice(0, 3).map(msg => {
-    const time = new Date(msg.timestamp).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
-    const preview = msg.body.slice(0, 60).replace(/\n/g, ' ');
-    return `📨 **${msg.subject}** from \`${msg.from}\` (${time})\n   ${preview}${msg.body.length > 60 ? '...' : ''}`;
-  }).join('\n\n');
-
-  const moreNote = unreadMessages.length > 3
-    ? `\n\n_...and ${unreadMessages.length - 3} more message(s)_`
-    : '';
-
-  // Inject message in a friendly, readable format
-  console.log(JSON.stringify({
-    continue: true,
-    stopReason: `📬 **You have ${unreadMessages.length} unread message(s):**\n\n${msgList}${moreNote}\n\n💡 Use \`service-message inbox\` to see all messages or \`service-message read <id>\` to read one.`
-  }));
-}
-
-main().catch(() => {
-  // Don't block on errors
-  console.log(JSON.stringify({ continue: true }));
-  process.exit(0);
-});