@hasna/hooks 0.0.7 → 0.1.1

package/dist/index.js

@@ -5,7 +5,12 @@ var CATEGORIES = [
   "Code Quality",
   "Security",
   "Notifications",
-  "Context Management"
+  "Context Management",
+  "Workflow Automation",
+  "Environment",
+  "Permissions",
+  "Observability",
+  "Agent Teams"
 ];
 var HOOKS = [
   {
@@ -157,6 +162,156 @@ var HOOKS = [
     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"]
   }
 ];
 function getHooksByCategory(category) {
@@ -176,11 +331,31 @@ 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") {
+var EVENT_MAP = {
+  claude: {
+    PreToolUse: "PreToolUse",
+    PostToolUse: "PostToolUse",
+    Stop: "Stop",
+    Notification: "Notification"
+  },
+  gemini: {
+    PreToolUse: "BeforeTool",
+    PostToolUse: "AfterTool",
+    Stop: "AfterAgent",
+    Notification: "Notification"
+  }
+};
+function getTargetSettingsDir(target) {
+  if (target === "gemini")
+    return ".gemini";
+  return ".claude";
+}
+function getSettingsPath(scope = "global", target = "claude") {
+  const dir = getTargetSettingsDir(target);
   if (scope === "project") {
-    return join(process.cwd(), ".claude", "settings.json");
+    return join(process.cwd(), dir, "settings.json");
   }
-  return join(homedir(), ".claude", "settings.json");
+  return join(homedir(), dir, "settings.json");
 }
 function getHookPath(name) {
   const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
@@ -189,8 +364,8 @@ function getHookPath(name) {
 function hookExists(name) {
   return existsSync(getHookPath(name));
 }
-function readSettings(scope = "global") {
-  const path = getSettingsPath(scope);
+function readSettings(scope = "global", target = "claude") {
+  const path = getSettingsPath(scope, target);
   try {
     if (existsSync(path)) {
       return JSON.parse(readFileSync(path, "utf-8"));
@@ -198,8 +373,8 @@ function readSettings(scope = "global") {
   } catch {}
   return {};
 }
-function writeSettings(settings, scope = "global") {
-  const path = getSettingsPath(scope);
+function writeSettings(settings, scope = "global", target = "claude") {
+  const path = getSettingsPath(scope, target);
   const dir = dirname(path);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -207,36 +382,48 @@ function writeSettings(settings, scope = "global") {
   writeFileSync(path, JSON.stringify(settings, null, 2) + `
 `);
 }
-function installHook(name, options = {}) {
-  const { scope = "global", overwrite = false } = options;
+function getTargetEventName(internalEvent, target) {
+  return EVENT_MAP[target]?.[internalEvent] || internalEvent;
+}
+function installForTarget(name, scope, overwrite, target) {
   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` };
+    return { hook: shortName, success: false, error: `Hook '${shortName}' not found`, target };
   }
-  const registered = getRegisteredHooks(scope);
+  const registered = getRegisteredHooksForTarget(scope, target);
   if (registered.includes(shortName) && !overwrite) {
-    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope };
+    return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope, target };
   }
   try {
-    registerHook(shortName, scope);
-    return { hook: shortName, success: true, scope };
+    registerHook(shortName, scope, target);
+    return { hook: shortName, success: true, scope, target };
   } catch (error) {
     return {
       hook: shortName,
       success: false,
-      error: error instanceof Error ? error.message : "Unknown error"
+      error: error instanceof Error ? error.message : "Unknown error",
+      target
     };
   }
 }
-function registerHook(name, scope = "global") {
+function installHook(name, options = {}) {
+  const { scope = "global", overwrite = false, target = "claude" } = options;
+  if (target === "all") {
+    const claudeResult = installForTarget(name, scope, overwrite, "claude");
+    installForTarget(name, scope, overwrite, "gemini");
+    return { ...claudeResult, target: "all" };
+  }
+  return installForTarget(name, scope, overwrite, target);
+}
+function registerHook(name, scope = "global", target = "claude") {
   const meta = getHook(name);
   if (!meta)
     return;
-  const settings = readSettings(scope);
+  const settings = readSettings(scope, target);
   if (!settings.hooks)
     settings.hooks = {};
-  const eventKey = meta.event;
+  const eventKey = getTargetEventName(meta.event, target);
   if (!settings.hooks[eventKey])
     settings.hooks[eventKey] = [];
   const hookCommand = `hooks run ${name}`;
@@ -248,16 +435,16 @@ function registerHook(name, scope = "global") {
     entry.matcher = meta.matcher;
   }
   settings.hooks[eventKey].push(entry);
-  writeSettings(settings, scope);
+  writeSettings(settings, scope, target);
 }
-function unregisterHook(name, scope = "global") {
+function unregisterHook(name, scope = "global", target = "claude") {
   const meta = getHook(name);
   if (!meta)
     return;
-  const settings = readSettings(scope);
+  const settings = readSettings(scope, target);
   if (!settings.hooks)
     return;
-  const eventKey = meta.event;
+  const eventKey = getTargetEventName(meta.event, target);
   if (!settings.hooks[eventKey])
     return;
   const hookCommand = `hooks run ${name}`;
@@ -268,13 +455,13 @@ function unregisterHook(name, scope = "global") {
   if (Object.keys(settings.hooks).length === 0) {
     delete settings.hooks;
   }
-  writeSettings(settings, scope);
+  writeSettings(settings, scope, target);
 }
 function installHooks(names, options = {}) {
   return names.map((name) => installHook(name, options));
 }
-function getRegisteredHooks(scope = "global") {
-  const settings = readSettings(scope);
+function getRegisteredHooksForTarget(scope = "global", target = "claude") {
+  const settings = readSettings(scope, target);
   if (!settings.hooks)
     return [];
   const registered = [];
@@ -292,17 +479,28 @@ function getRegisteredHooks(scope = "global") {
   }
   return [...new Set(registered)];
 }
+function getRegisteredHooks(scope = "global") {
+  return getRegisteredHooksForTarget(scope, "claude");
+}
 function getInstalledHooks(scope = "global") {
   return getRegisteredHooks(scope);
 }
-function removeHook(name, scope = "global") {
+function removeHook(name, scope = "global", target = "claude") {
   const hookName = name.startsWith("hook-") ? name : `hook-${name}`;
   const shortName = hookName.replace("hook-", "");
-  const registered = getRegisteredHooks(scope);
-  if (!registered.includes(shortName)) {
+  if (target === "all") {
+    const claudeRemoved = removeHookForTarget(shortName, scope, "claude");
+    const geminiRemoved = removeHookForTarget(shortName, scope, "gemini");
+    return claudeRemoved || geminiRemoved;
+  }
+  return removeHookForTarget(shortName, scope, target);
+}
+function removeHookForTarget(name, scope, target) {
+  const registered = getRegisteredHooksForTarget(scope, target);
+  if (!registered.includes(name)) {
     return false;
   }
-  unregisterHook(shortName, scope);
+  unregisterHook(name, scope, target);
   return true;
 }
 export {

package/hooks/hook-autoformat/README.md

@@ -0,0 +1,39 @@
+# hook-autoformat
+
+Claude Code hook that automatically runs the project's formatter after file edits.
+
+## Overview
+
+Detects and runs the appropriate formatter whenever Claude edits or writes a file. No configuration needed — it reads your project's existing formatter config.
+
+## Supported Formatters
+
+| Config File | Formatter | File Types |
+|-------------|-----------|------------|
+| `.prettierrc` / `prettier` in package.json | Prettier | JS, TS, CSS, HTML, MD, JSON, YAML, etc. |
+| `biome.json` | Biome | JS, TS, JSON, CSS, GraphQL |
+| `pyproject.toml` with `[tool.ruff]` | Ruff | Python |
+| `pyproject.toml` with `[tool.black]` | Black | Python |
+| `.clang-format` | clang-format | C, C++, Obj-C |
+| (any `.go` file) | gofmt | Go |
+
+## Hook Event
+
+- **PostToolUse** (matcher: `Edit|Write`)
+
+## Behavior
+
+1. Fires after every `Edit` or `Write` tool call
+2. Reads `tool_input.file_path` to get the edited file
+3. Detects the project formatter from config files in the working directory
+4. Runs the formatter as a subprocess
+5. Logs the result to stderr
+6. Always outputs `{ continue: true }`
+
+## Priority
+
+If both Biome and Prettier configs exist, Biome takes priority (it's faster).
+
+## License
+
+MIT

package/hooks/hook-autoformat/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@hasna/hook-autoformat",
+  "version": "0.1.0",
+  "description": "Claude Code hook that auto-runs formatters after file edits",
+  "type": "module",
+  "bin": {
+    "hook-autoformat": "./dist/cli.js"
+  },
+  "main": "./dist/hook.js",
+  "exports": {
+    ".": {
+      "import": "./dist/hook.js",
+      "types": "./dist/hook.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/hook.ts --outdir ./dist --target node",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "hook",
+    "formatter",
+    "autoformat",
+    "prettier",
+    "biome",
+    "ruff",
+    "cli"
+  ],
+  "author": "Hasna",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasna/open-hooks.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "@types/node": "^20",
+    "typescript": "^5.0.0"
+  }
+}

package/hooks/hook-autoformat/src/hook.ts

@@ -0,0 +1,223 @@
+#!/usr/bin/env bun
+
+/**
+ * Claude Code Hook: autoformat
+ *
+ * PostToolUse hook that auto-runs the project's formatter after file edits.
+ * Detects the formatter from project config files:
+ *
+ * - .prettierrc / prettier in package.json → bunx prettier --write <file>
+ * - biome.json → bunx biome format --write <file>
+ * - pyproject.toml with [tool.ruff] or [tool.black] → ruff format / black
+ * - .clang-format → clang-format -i <file>
+ * - Go files (.go) → gofmt -w <file>
+ */
+
+import { readFileSync, existsSync } from "fs";
+import { join, extname } from "path";
+import { execSync } from "child_process";
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+  tool_output?: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+}
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+function hasPrettierConfig(cwd: string): boolean {
+  const configFiles = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs",
+  ];
+
+  for (const file of configFiles) {
+    if (existsSync(join(cwd, file))) return true;
+  }
+
+  // Check package.json for prettier key
+  const packageJsonPath = join(cwd, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      if (pkg.prettier) return true;
+    } catch {
+      // ignore
+    }
+  }
+
+  return false;
+}
+
+function hasBiomeConfig(cwd: string): boolean {
+  return existsSync(join(cwd, "biome.json")) || existsSync(join(cwd, "biome.jsonc"));
+}
+
+function getPythonFormatter(cwd: string): "ruff" | "black" | null {
+  const pyprojectPath = join(cwd, "pyproject.toml");
+  if (!existsSync(pyprojectPath)) return null;
+
+  try {
+    const content = readFileSync(pyprojectPath, "utf-8");
+    if (content.includes("[tool.ruff]")) return "ruff";
+    if (content.includes("[tool.black]")) return "black";
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
+
+function hasClangFormat(cwd: string): boolean {
+  return existsSync(join(cwd, ".clang-format"));
+}
+
+function isGoFile(filePath: string): boolean {
+  return extname(filePath) === ".go";
+}
+
+function isPythonFile(filePath: string): boolean {
+  return extname(filePath) === ".py";
+}
+
+function isFormattableByPrettier(filePath: string): boolean {
+  const ext = extname(filePath).toLowerCase();
+  const prettierExts = [
+    ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+    ".json", ".css", ".scss", ".less", ".html",
+    ".md", ".mdx", ".yaml", ".yml", ".graphql",
+    ".vue", ".svelte",
+  ];
+  return prettierExts.includes(ext);
+}
+
+function isFormattableByBiome(filePath: string): boolean {
+  const ext = extname(filePath).toLowerCase();
+  const biomeExts = [
+    ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+    ".json", ".jsonc", ".css", ".graphql",
+  ];
+  return biomeExts.includes(ext);
+}
+
+function isClangFormattable(filePath: string): boolean {
+  const ext = extname(filePath).toLowerCase();
+  const clangExts = [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx", ".m", ".mm"];
+  return clangExts.includes(ext);
+}
+
+function detectFormatter(cwd: string, filePath: string): { name: string; command: string } | null {
+  // Go files always use gofmt
+  if (isGoFile(filePath)) {
+    return { name: "gofmt", command: `gofmt -w "${filePath}"` };
+  }
+
+  // Python files
+  if (isPythonFile(filePath)) {
+    const pyFormatter = getPythonFormatter(cwd);
+    if (pyFormatter === "ruff") {
+      return { name: "ruff", command: `ruff format "${filePath}"` };
+    }
+    if (pyFormatter === "black") {
+      return { name: "black", command: `black "${filePath}"` };
+    }
+    return null;
+  }
+
+  // C/C++ files with .clang-format
+  if (isClangFormattable(filePath) && hasClangFormat(cwd)) {
+    return { name: "clang-format", command: `clang-format -i "${filePath}"` };
+  }
+
+  // Biome takes priority over Prettier if both exist (it's faster)
+  if (hasBiomeConfig(cwd) && isFormattableByBiome(filePath)) {
+    return { name: "biome", command: `bunx @biomejs/biome format --write "${filePath}"` };
+  }
+
+  // Prettier
+  if (hasPrettierConfig(cwd) && isFormattableByPrettier(filePath)) {
+    return { name: "prettier", command: `bunx prettier --write "${filePath}"` };
+  }
+
+  return null;
+}
+
+function runFormatter(cwd: string, name: string, command: string): void {
+  try {
+    execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 30000, // 30s timeout
+    });
+    console.error(`[hook-autoformat] Formatted with ${name}`);
+  } catch (error: unknown) {
+    const execError = error as { stderr?: string; message?: string };
+    const errorMsg = execError.stderr || execError.message || "unknown error";
+    console.error(`[hook-autoformat] ${name} failed: ${errorMsg}`);
+  }
+}
+
+export function run(): void {
+  const input = readStdinJson();
+
+  if (!input) {
+    respond({ continue: true });
+    return;
+  }
+
+  // Only process Edit and Write tools
+  if (input.tool_name !== "Edit" && input.tool_name !== "Write") {
+    respond({ continue: true });
+    return;
+  }
+
+  const filePath = input.tool_input?.file_path as string;
+  if (!filePath || typeof filePath !== "string") {
+    respond({ continue: true });
+    return;
+  }
+
+  const cwd = input.cwd || process.cwd();
+  const formatter = detectFormatter(cwd, filePath);
+
+  if (!formatter) {
+    respond({ continue: true });
+    return;
+  }
+
+  console.error(`[hook-autoformat] Running ${formatter.name} on ${filePath}`);
+  runFormatter(cwd, formatter.name, formatter.command);
+
+  respond({ continue: true });
+}
+
+if (import.meta.main) {
+  run();
+}