Another Useful Hook! Understanding Claude Code Hook Types and Input Structures

#!/usr/bin/env python3
import json
import sys

data = json.loads(sys.stdin.read())

# Block writes to sensitive paths
blocked_paths = ['/etc', '/System', '/Applications']
if any(data['file_path'].startswith(p) for p in blocked_paths):
    print(f"Blocked: Cannot write to {data['file_path']}", file=sys.stderr)
    sys.exit(1)

sys.exit(0)

#!/usr/bin/env python3
import json
import sys

data = json.loads(sys.stdin.read())

# Validate required outputs exist
required_files = ['article.md']
for required_file in required_files:
    if required_file not in data['files_generated']:
        print(f"ERROR: Sub-agent did not generate {required_file}", file=sys.stderr)
        sys.exit(1)

# Check for errors
if data['errors']:
    print(f"Sub-agent had errors: {data['errors']}", file=sys.stderr)
    sys.exit(1)

# Log successful completion
print(f"✓ Sub-agent {data['subagent_id']} completed successfully", file=sys.stdout)
sys.exit(0)

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

data = json.loads(sys.stdin.read())

# Create checkpoint before compaction
checkpoint = {
    "timestamp": datetime.now().isoformat(),
    "reason": data['reason'],
    "tokens_used": data['current_tokens'],
    "files_modified": data['recent_changes']
}

# Save checkpoint
with open('.claude/checkpoints.jsonl', 'a') as f:
    f.write(json.dumps(checkpoint) + '\n')

print(f"✓ Checkpoint created before compaction", file=sys.stdout)
sys.exit(0)

#!/usr/bin/env python3
import json
import sys
import re

data = json.loads(sys.stdin.read())
prompt = data['prompt_text'].lower()

# Block dangerous instruction injections
dangerous_patterns = [
    r'ignore.*previous.*instruction',
    r'admin.*mode',
    r'system.*prompt',
    r'delete.*production',
    r'rm.*-rf'
]

for pattern in dangerous_patterns:
    if re.search(pattern, prompt):
        print(f"Prompt rejected: Contains potentially dangerous instruction", file=sys.stderr)
        sys.exit(1)

print(f"✓ Prompt validation passed", file=sys.stdout)
sys.exit(0)

#!/usr/bin/env python3
"""
Complete TypeScript validation hook.
- Runs ESLint pre-flight checks
- Validates types with TypeScript
- Logs all validations for debugging
"""

import json
import sys
import subprocess
from pathlib import Path
from datetime import datetime

class TypeScriptValidator:
    def __init__(self, hook_input: dict):
        self.data = hook_input
        self.file_path = self.data['file_path']
        self.errors = []
        self.warnings = []
    
    def validate(self) -> bool:
        """Run all validation steps."""
        self._validate_syntax()
        self._validate_types()
        self._validate_style()
        
        return len(self.errors) == 0
    
    def _validate_syntax(self):
        """Check TypeScript syntax."""
        try:
            result = subprocess.run(
                ['npx', 'tsc', '--noEmit', self.file_path],
                capture_output=True,
                timeout=5
            )
            if result.returncode != 0:
                self.errors.append(f"TypeScript compilation error: {result.stderr.decode()}")
        except Exception as e:
            self.warnings.append(f"Could not run TypeScript check: {str(e)}")
    
    def _validate_types(self):
        """Validate type annotations."""
        with open(self.file_path) as f:
            content = f.read()
        
        if 'function' in content and ': ' not in content:
            self.warnings.append("Functions may be missing type annotations")
    
    def _validate_style(self):
        """Check code style with ESLint."""
        try:
            result = subprocess.run(
                ['npx', 'eslint', self.file_path],
                capture_output=True,
                timeout=5
            )
            if result.returncode != 0:
                self.warnings.append(f"ESLint issues: {result.stdout.decode()}")
        except Exception as e:
            self.warnings.append(f"Could not run ESLint: {str(e)}")
    
    def report(self):
        """Print results and return exit code."""
        if self.errors:
            print(f"❌ TypeScript Validation Failed for {self.file_path}", file=sys.stderr)
            for error in self.errors:
                print(f"  ERROR: {error}", file=sys.stderr)
            return 1
        
        if self.warnings:
            print(f"⚠️  TypeScript Warnings for {self.file_path}", file=sys.stderr)
            for warning in self.warnings:
                print(f"  WARNING: {warning}", file=sys.stderr)
        
        print(f"✓ TypeScript validation passed: {self.file_path}", file=sys.stdout)
        return 0

if __name__ == '__main__':
    try:
        hook_input = json.loads(sys.stdin.read())
        validator = TypeScriptValidator(hook_input)
        
        if not validator.validate():
            exit_code = validator.report()
            sys.exit(exit_code)
        else:
            exit_code = validator.report()
            sys.exit(exit_code)
    except Exception as e:
        print(f"Hook error: {str(e)}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
"""
Stop hook implementing Ralph Wiggum pattern.
Continues autonomous agent loop if completion promise not met.
"""

import json
import sys
from datetime import datetime

class AutonomousLoopManager:
    def __init__(self, hook_input: dict):
        self.data = hook_input
        self.iterations = hook_input['iterations']
        self.max_iterations = hook_input['max_iterations']
        self.completion_promise = hook_input.get('completion_promise', '')
        self.completion_status = hook_input.get('completion_status', 'pending')
    
    def should_continue(self) -> bool:
        """Determine if agent should continue."""
        # Stop if max iterations reached
        if self.iterations >= self.max_iterations:
            return False
        
        # Stop if completion promise met
        if self.completion_status == 'complete':
            return False
        
        # Stop if user explicitly stopped
        if self.data.get('reason') == 'user_stop':
            return False
        
        # Continue if promise not met
        return True
    
    def generate_response(self) -> dict:
        """Generate hook response."""
        if self.should_continue():
            return {
                'action': 'continue',
                'reason': f'Continuing autonomous loop (iteration {self.iterations}/{self.max_iterations})',
                'next_task': 'Run failing tests and fix issues'
            }
        else:
            return {
                'action': 'stop',
                'reason': 'Task complete or max iterations reached',
                'summary': f'Completed in {self.iterations} iterations'
            }

if __name__ == '__main__':
    try:
        hook_input = json.loads(sys.stdin.read())
        manager = AutonomousLoopManager(hook_input)
        response = manager.generate_response()
        
        print(json.dumps(response), file=sys.stdout)
        sys.exit(0)
    except Exception as e:
        print(f"Error in stop hook: {str(e)}", file=sys.stderr)
        sys.exit(0)  # Don't block on hook errors

#!/usr/bin/env python3
"""
Hook that chains multiple validations, maintaining state.
"""

import json
import sys
from pathlib import Path

class StatefulValidator:
    STATE_FILE = '.claude/hook_state.json'
    
    def __init__(self):
        self.state = self.load_state()
    
    def load_state(self) -> dict:
        if Path(self.STATE_FILE).exists():
            with open(self.STATE_FILE) as f:
                return json.load(f)
        return {'validations': 0, 'errors': 0}
    
    def save_state(self):
        Path(self.STATE_FILE).parent.mkdir(exist_ok=True)
        with open(self.STATE_FILE, 'w') as f:
            json.dump(self.state, f)
    
    def validate(self, hook_input: dict) -> bool:
        self.state['validations'] += 1
        
        # Run validation logic
        result = self.check_file(hook_input['file_path'])
        
        if not result:
            self.state['errors'] += 1
        
        self.save_state()
        return result
    
    def check_file(self, file_path: str) -> bool:
        # Validation logic here
        return True

if __name__ == '__main__':
    hook_input = json.loads(sys.stdin.read())
    validator = StatefulValidator()
    
    if validator.validate(hook_input):
        sys.exit(0)
    else:
        sys.exit(1)

#!/usr/bin/env python3
import sys
import json

try:
    hook_input = json.loads(sys.stdin.read())
    result = validate(hook_input)
    
    if not result:
        print("Validation failed", file=sys.stderr)
        sys.exit(1)
    
    sys.exit(0)

except json.JSONDecodeError as e:
    print(f"Invalid JSON input: {e}", file=sys.stderr)
    sys.exit(1)
except Exception as e:
    print(f"Unexpected error: {e}", file=sys.stderr)
    # Don't block agent on hook errors
    sys.exit(0)

# ❌ WRONG - Hook hangs if API is slow
response = requests.get('https://api.example.com/validate')

# ✅ CORRECT - Use timeout or background task
try:
    response = requests.get('https://api.example.com/validate', timeout=2)
except requests.Timeout:
    print("API timeout, skipping validation", file=sys.stderr)
    sys.exit(0)  # Don't block agent

# ❌ WRONG - Assumes valid JSON
data = json.loads(sys.stdin.read())

# ✅ CORRECT - Handle parse errors
try:
    data = json.loads(sys.stdin.read())
except json.JSONDecodeError as e:
    print(f"Invalid JSON input: {e}", file=sys.stderr)
    sys.exit(1)