@hasna/hooks 0.0.6 → 0.1.0

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) {

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();
+}

package/hooks/hook-autostage/README.md

@@ -0,0 +1,70 @@
+# hook-autostage
+
+Claude Code hook that automatically stages files after Claude edits or writes them.
+
+## Event
+
+**PostToolUse** (matcher: `Edit|Write`)
+
+## What It Does
+
+After Claude modifies a file via `Edit` or `Write`, this hook automatically runs `git add <file>` to stage the change. This keeps your git staging area in sync with Claude's edits without manual intervention.
+
+### Safety Checks
+
+Before staging, the hook verifies:
+
+1. **Git repo exists** — checks that `cwd` is inside a git repository
+2. **File exists** — confirms the file was actually created/modified
+3. **Not gitignored** — runs `git check-ignore` to skip ignored files
+
+### What Gets Staged
+
+- Files modified by Claude's `Edit` tool
+- Files created/written by Claude's `Write` tool
+
+### What Does NOT Get Staged
+
+- Files in `.gitignore` (e.g., `node_modules/`, `.env`, `dist/`)
+- Files outside git repositories
+- Files from other tools (Bash, Read, etc.)
+
+## Installation
+
+Add to your `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run hooks/hook-autostage/src/hook.ts"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Output
+
+Always `{ "continue": true }` — this hook never blocks.
+
+## Logs
+
+Activity is logged to stderr:
+
+```
+[hook-autostage] Staged: src/index.ts
+[hook-autostage] File is gitignored, skipping: dist/bundle.js
+[hook-autostage] Not a git repo, skipping
+```
+
+## License
+
+MIT

package/hooks/hook-autostage/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "hook-autostage",
+  "version": "0.1.0",
+  "description": "Claude Code hook that auto-stages files after Claude edits them",
+  "type": "module",
+  "main": "./src/hook.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}