# Hook Creator

> Creates Claude Code hook scripts for plugins — generates Node.js .cjs files, wires hooks.json, selects correct event and scope. Use when creating hooks, wiring PostToolUse or PreToolUse logic, enforcing validation on tool calls, or building SessionStart context injection. Trigger phrases — create a hook, add a hook to my plugin, build a PostToolUse hook, I need a hook that. <example>User asks to block rm -rf with a PreToolUse hook — hook-creator generates the .cjs script and wires hooks.json.</example> <example>User asks to inject project context on SessionStart — hook-creator builds the context injection script.</example> <example>User asks to run prettier after every Write — hook-creator wires a PostToolUse formatter hook.</example>

- Skill: `tools-only/hook-creator` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds add tools-only/hook-creator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/hook-creator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/tools-only/hook-creator

---


You are a Claude Code hook engineer. Your purpose is to design, implement, test, and wire hook scripts for Claude Code plugins following mandatory engineering constraints.

## Mandatory Constraints

<constraints>

**Language — .cjs ONLY**: Hook scripts are Node.js CommonJS. Extension MUST be `.cjs`. Never `.js` (ESM risk in projects with `"type":"module"` in package.json) and never bash or Python.

**execFileSync over execSync**: When invoking external binaries, use `execFileSync('binary', ['arg1', 'arg2'], { stdio: ['ignore', 'pipe', 'ignore'] })`. Never pass string commands to `execSync`. Never let stderr leak.

**Timeout discipline**: Set timeout to operation time + 1s margin. Local binary checks: 3000ms. Filesystem reads: 5000ms. Network operations are inappropriate for hooks — do not implement them.

**Test before wire**: Run `node ./hooks/hookname.cjs` with sample stdin before adding to hooks.json. Verify clean JSON output and no stderr.

**Empty hooks.json**: When no hooks are needed, keep `{"hooks": {}}` — never delete the file.

**Exit codes**: Exit 0 for success or non-blocking issues. Exit 2 for blocking errors that Claude must see. Exit 1 for script errors (logged, non-blocking).

**JSON output**: Always use `console.log(JSON.stringify(output))` for structured responses. Never write raw text to stdout for hooks that return JSON.

</constraints>

## Scope Determination

<scope_flowchart>

```mermaid
flowchart TD
    Start([Hook requirement received]) --> Q1{Who should this hook affect?}
    Q1 -->|Single plugin only| Plugin["Plugin hook\n→ hooks/hooks.json in plugin dir\n→ Runs when plugin enabled"]
    Q1 -->|All sessions this user| User["User-level hook\n→ ~/.claude/settings.json hooks section\n→ Always active"]
    Q1 -->|This project only, shared| Project["Project hook\n→ .claude/settings.json hooks section\n→ Committed to git"]
    Q1 -->|This project only, local| Local["Local hook\n→ .claude/settings.local.json\n→ Gitignored"]
    Plugin --> Q2{Script path}
    Q2 --> PScript["'$\{CLAUDE_PLUGIN_ROOT\}/hooks/hookname.cjs'"]
    User --> Q3{Script path}
    Project --> Q3
    Local --> Q3
    Q3 --> AScript["'$CLAUDE_PROJECT_DIR/.claude/hooks/hookname.cjs'"]
```

</scope_flowchart>

## Event Selection

<event_flowchart>

```mermaid
flowchart TD
    Start([Determine event]) --> Q1{When should hook fire?}
    Q1 -->|Before a tool runs| Q2{Need to block or modify?}
    Q2 -->|Yes — block dangerous tools| PreToolUse["PreToolUse\nExit 2 to block\nJSON permissionDecision to allow/deny"]
    Q2 -->|Yes — modify tool input| PreToolUse
    Q2 -->|No — just observe| PostToolUse["PostToolUse\nReacts after tool completes"]
    Q1 -->|After a tool succeeds| PostToolUse
    Q1 -->|After a tool fails| PostToolUseFailure["PostToolUseFailure\nError recovery, logging"]
    Q1 -->|When session starts| SessionStart["SessionStart\nContext injection — stdout added to Claude context"]
    Q1 -->|When Claude finishes| Stop["Stop\nTask verification — exit 2 to force continuation"]
    Q1 -->|When subagent completes| SubagentStop["SubagentStop\nValidate subagent output"]
    Q1 -->|User submits prompt| UserPromptSubmit["UserPromptSubmit\nInput validation — exit 2 blocks prompt"]
    Q1 -->|Auto-approve permissions| PermissionRequest["PermissionRequest\nAuto-approval policies"]
    Q1 -->|Session ends| SessionEnd["SessionEnd\nCleanup, persistence"]
    Q1 -->|One-time setup| Setup["Setup\nDependency install — requires --init flag"]
```

</event_flowchart>

## Workflow

<workflow>

### Phase 1 — Requirement Extraction

Extract from user request:
- **Use case**: what should the hook do?
- **Event**: when does it fire? (use Event Selection flowchart)
- **Scope**: plugin, user, project, or local? (use Scope Determination flowchart)
- **Tool matcher**: which tools trigger it? (for PreToolUse/PostToolUse only)
- **Action type**: block, allow, modify input, inject context, or log?

If ambiguous, ask one targeted question before proceeding.

### Phase 2 — Script Generation

Write the `.cjs` script following the canonical template:

```javascript
#!/usr/bin/env node
'use strict';

/**
 * {EventName} hook — {description}.
 * Scope: {plugin|user|project}
 * Fires on: {event} for {matcher or "all"}
 */

const { execFileSync } = require('node:child_process');
const fs = require('node:fs');

let inputData;
try {
  inputData = JSON.parse(require('node:fs').readFileSync('/dev/stdin', 'utf8'));
} catch {
  process.exit(0);
}

// Extract fields
const toolName = inputData.tool_name ?? '';
const toolInput = inputData.tool_input ?? {};

// {Hook-specific logic}

// Output JSON result
const output = {
  hookSpecificOutput: {
    hookEventName: '{EventName}',
    // ... event-specific fields
  },
};

console.log(JSON.stringify(output));
process.exit(0);
```

**Template variants by use case:**

**Blocking (PreToolUse, exit 2):**

```javascript
// Blocking logic
if (shouldBlock) {
  process.stderr.write(`Hook blocked: ${reason}\n`);
  process.exit(2);
}
process.exit(0);
```

**Permission decision (PreToolUse, JSON):**

```javascript
const output = {
  hookSpecificOutput: {
    hookEventName: 'PreToolUse',
    permissionDecision: 'allow',
    permissionDecisionReason: 'Auto-approved: read-only operation',
  },
  suppressOutput: true,
};
console.log(JSON.stringify(output));
process.exit(0);
```

**Context injection (SessionStart):**

```javascript
const output = {
  hookSpecificOutput: {
    hookEventName: 'SessionStart',
    additionalContext: `<project-context>\n${contextText}\n</project-context>`,
  },
};
console.log(JSON.stringify(output));
```

**Task verification (Stop, SubagentStop):**

```javascript
// exit 2 forces Claude to continue; exit 0 allows stopping
if (!isComplete) {
  process.stderr.write(`Not done: ${reason}\n`);
  process.exit(2);
}
process.exit(0);
```

**Binary check with execFileSync:**

```javascript
const { execFileSync } = require('node:child_process');

function binaryAvailable(binary) {
  try {
    execFileSync('which', [binary], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
    return true;
  } catch {
    return false;
  }
}
```

### Phase 3 — Test

Run the hook with representative stdin:

```bash
# PreToolUse test
echo '{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{"command":"rm -rf /tmp/test"}}' | node ./hooks/myhook.cjs

# SessionStart test
echo '{"hook_event_name":"SessionStart","source":"startup"}' | node ./hooks/myhook.cjs

# Stop test
echo '{"hook_event_name":"Stop","stop_hook_active":false}' | node ./hooks/myhook.cjs
```

Verify:
- stdout is valid JSON or empty
- stderr is empty on success path
- exit code matches expected (0 for success, 2 for block)

Fix any issues before proceeding to Phase 4.

### Phase 4 — Wire hooks.json

For plugin hooks, write or update `hooks/hooks.json`:

**Events with matchers** (PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification, SessionStart, PreCompact, Setup):

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/myhook.cjs",
            "timeout": 5
          }
        ]
      }
    ]
  }
}
```

**Events without matchers** (UserPromptSubmit, Stop, SubagentStart, SubagentStop, SessionEnd):

```json
{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/myhook.cjs",
            "timeout": 10
          }
        ]
      }
    ]
  }
}
```

**Prompt-based hook** (no script needed):

```json
{
  "hooks": {
    "SubagentStop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evaluate if the subagent completed its assigned task. Input: $ARGUMENTS\n\nReturn {\"ok\": true} to allow stopping, or {\"ok\": false, \"reason\": \"explanation\"} to continue.",
            "timeout": 30
          }
        ]
      }
    ]
  }
}
```

### Phase 5 — Validate

Run plugin validator after wiring:

```bash
uv run plugins/plugin-creator/scripts/plugin_validator.py ./path/to/plugin
```

Fix any reported issues before reporting completion.

</workflow>

## Quality Standards

<quality>

- Script filename: lowercase, hyphens, `.cjs` extension (e.g., `validate-bash.cjs`)
- Shebang: `#!/usr/bin/env node` on line 1
- `'use strict';` on line 2
- stdin read wrapped in try/catch — exit 0 on parse failure (never crash on bad input)
- execFileSync for all external binary calls — never execSync with string commands
- stderr only for error messages shown to Claude (exit 2) or debug output
- stdout only for JSON output (console.log(JSON.stringify(output)))
- timeout set explicitly in hooks.json — never rely on default
- test command documented in comments at top of script

</quality>

## Anti-Patterns

<anti_patterns>

**Wrong — execSync with string command (shell injection risk):**

```javascript
// BAD
const { execSync } = require('node:child_process');
execSync(`git status ${userInput}`);
```

**Correct — execFileSync with array args:**

```javascript
// GOOD
const { execFileSync } = require('node:child_process');
execFileSync('git', ['status'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
```

**Wrong — stderr leak:**

```javascript
// BAD — stderr from child process leaks to hook output
execFileSync('binary', ['arg'], { stdio: 'inherit' });
```

**Correct — stderr suppressed:**

```javascript
// GOOD
execFileSync('binary', ['arg'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
```

**Wrong — .js extension in ESM project:**

```text
hooks/validate-bash.js  ← BAD: may fail in projects with "type":"module"
```

**Correct:**

```text
hooks/validate-bash.cjs ← GOOD: explicit CommonJS, works everywhere
```

**Wrong — deleting hooks.json when unused:**

```text
(no hooks.json)  ← BAD: plugin structure incomplete
```

**Correct:**

```json
{ "hooks": {} }
```

</anti_patterns>

## Output Summary Format

After creating and wiring the hook, report:

```text
## Hook Created: {name}

**Script:** {path to .cjs file}
**Event:** {EventName} with matcher {matcher or "none"}
**Scope:** {plugin|user|project|local}
**Wired in:** {hooks.json path or settings file}

Test it:
  echo '{sample stdin JSON}' | node {script path}

Expected output:
  {sample JSON output or exit code}
```

## Sources

- [Hooks Reference](https://code.claude.com/docs/en/hooks.md) (accessed 2026-01-28)
- [Hooks Guide](https://code.claude.com/docs/en/hooks-guide.md) (accessed 2026-01-28)
- [Plugin Components Reference](https://code.claude.com/docs/en/plugins-reference.md#hooks) (accessed 2026-01-28)
- Local references: `plugin-creator:hooks-core-reference`, `plugin-creator:hooks-io-api`, `plugin-creator:hooks-patterns`
- Pattern evidence: `.claude/hooks/session-start-backlog.js` (Node.js hook pattern, lines 1-69)