Claude Code Hooks: Automating Your Development Pipeline

// claude-hooks.config.js
module.exports = {
  hooks: {
    'pre-commit': {
      enabled: true,
      patterns: ['src/**/*.ts', 'src/**/*.tsx'],
      instruction: 'Review this code for potential bugs, security issues, and adherence to our coding standards. Be specific about issues found.',
      failOn: ['critical', 'security'],
      timeout: 30000
    },
    'post-commit': {
      enabled: true,
      tasks: [
        {
          name: 'run-tests',
          instruction: 'Run our test suite and report results',
          timeout: 120000
        },
        {
          name: 'update-changelog',
          instruction: 'Update CHANGELOG.md based on the commit message',
          timeout: 15000
        }
      ]
    },
    'file-watcher': {
      enabled: true,
      watches: [
        {
          pattern: 'src/**/*.test.ts',
          instruction: 'Analyze this test file and suggest improvements for test coverage'
        },
        {
          pattern: 'README.md',
          instruction: 'Validate that README.md is up-to-date with current project structure'
        }
      ]
    }
  },
  team: {
    enforcementLevel: 'strict', // 'strict', 'moderate', 'lenient'
    notificationChannel: 'slack',
    slackWebhook: process.env.SLACK_WEBHOOK_URL
  }
};

# .env.local
CLAUDE_API_KEY=your_api_key_here
CLAUDE_HOOKS_ENABLED=true
CLAUDE_TIMEOUT=30000
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/...
GITHUB_TOKEN=your_github_token

{
  'pre-commit': {
    enabled: true,
    patterns: ['src/**/*.{ts,tsx}'],
    instruction: `Review this code for:
    1. Potential bugs and edge cases
    2. Security vulnerabilities
    3. Performance issues
    4. Adherence to React best practices
    5. Type safety violations

    Provide specific line numbers and actionable recommendations.`,
    failOn: ['critical', 'security'],
    actions: {
      onFailure: 'block-commit',
      onSuccess: 'allow-commit',
      onWarning: 'prompt-developer'
    }
  }
}

{
  'post-commit': {
    enabled: true,
    tasks: [
      {
        name: 'generate-tests',
        instruction: `For the files changed in this commit:
        1. Analyze what functionality was added or modified
        2. Generate comprehensive unit tests covering:
           - Happy path scenarios
           - Edge cases and error conditions
           - Integration points with other modules
        3. Save tests to the appropriate __tests__ directory
        4. Report test generation summary`,
        timeout: 60000
      }
    ]
  }
}

{
  'file-watcher': {
    enabled: true,
    watches: [
      {
        pattern: 'src/components/**/*.tsx',
        instruction: `When component files change:
        1. Extract JSDoc comments and prop definitions
        2. Update the corresponding documentation file in docs/components/
        3. Generate usage examples based on the component props
        4. Verify all exported components are documented`,
        debounce: 2000
      }
    ]
  }
}

# .github/workflows/claude-hooks.yml
name: Claude Code Hooks

on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  claude-analysis:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm install

      - name: Run Claude Code hooks
        env:
          CLAUDE_API_KEY: ${{ secrets.CLAUDE_API_KEY }}
        run: |
          npx claude-code hooks:run --stage pre-commit
          npx claude-code hooks:run --stage analysis

      - name: Comment on PR
        if: failure()
        uses: actions/github-script@v6
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: 'Claude Code analysis found issues. Please review.'
            })

claude-code-analysis:
  stage: analyze
  script:
    - npx claude-code hooks:run --stage pre-commit
    - npx claude-code hooks:run --stage analysis
  only:
    - merge_requests
  artifacts:
    reports:
      junit: claude-analysis-report.xml

pipeline {
    agent any

    stages {
        stage('Claude Code Analysis') {
            steps {
                script {
                    withEnv(['CLAUDE_API_KEY=credentials(claude-api-key)']) {
                        sh '''
                            npx claude-code hooks:run --stage pre-commit
                            npx claude-code hooks:run --stage analysis
                        '''
                    }
                }
            }
        }
    }
}

Analyze this TypeScript component for:
1. Prop validation completeness
2. Missing TypeScript types
3. Accessibility issues (ARIA attributes, keyboard navigation)
Report specific line numbers and fixes.

Check if this is good code.

{
  'pre-commit': {
    timeout: 30000, // 30 seconds for quick validation
    instruction: 'Quick check for obvious issues'
  },
  'post-commit': {
    timeout: 120000, // 2 minutes for thorough analysis
    instruction: 'Comprehensive analysis and testing'
  }
}

{
  'pre-commit': {
    failOn: ['critical', 'security'],
    warnOn: ['performance', 'style'],
    ignoreOn: ['info', 'suggestion'],
    actions: {
      onCritical: 'block-commit',
      onWarning: 'allow-commit-with-notification',
      onInfo: 'allow-commit-silently'
    }
  }
}

# Claude Code Hooks Standards

## Pre-Commit Requirements
- All code must pass security analysis
- TypeScript files must have no type errors detected by Claude
- Critical issues must be fixed before committing

## Post-Commit Automation
- Tests are automatically run after commits
- Documentation is updated for modified components
- Team is notified of failures via Slack

## Developer Workflow
1. Write code
2. Commit (hooks validate before acceptance)
3. Push (CI/CD pipeline runs comprehensive analysis)
4. Review (team reviews Claude Code suggestions alongside code)

{
  'pre-commit': {
    // Only analyze files that actually changed
    patterns: 'changed-files',

    // Batch multiple file analyzes
    batchSize: 5,

    // Cache results for unchanged files
    cacheResults: true,
    cacheTTL: 3600,

    // Run in parallel where possible
    parallel: true,
    maxParallel: 3
  }
}

# Diagnostic commands
claude-code hooks:validate --config claude-hooks.config.js
claude-code hooks:test --hook pre-commit

// Increased timeout for comprehensive analysis
{
  'pre-commit': {
    timeout: 60000, // Extended to 60 seconds
    instruction: 'Perform thorough analysis'
  }
}

{
  'pre-commit': {
    throttle: {
      enabled: true,
      requestsPerMinute: 30,
      burstSize: 5
    },
    cache: {
      enabled: true,
      ttl: 3600
    }
  }
}

{
  hooks: {
    'pre-commit': {
      rules: [
        {
          branches: ['main'],
          instruction: 'Strict security and performance analysis',
          failOn: ['critical', 'security', 'performance']
        },
        {
          branches: ['develop'],
          instruction: 'Standard code review',
          failOn: ['critical', 'security']
        },
        {
          branches: ['feature/*'],
          instruction: 'Lightweight analysis',
          failOn: ['critical']
        }
      ]
    }
  }
}

{
  'pre-commit': {
    stages: [
      {
        name: 'validation',
        instruction: 'Quick validation of syntax and types',
        timeout: 15000,
        required: true
      },
      {
        name: 'security-scan',
        instruction: 'Security vulnerability scanning',
        timeout: 20000,
        required: true,
        runIf: 'validation-passed'
      },
      {
        name: 'optimization',
        instruction: 'Performance optimization suggestions',
        timeout: 25000,
        required: false,
        runIf: 'security-scan-passed'
      }
    ]
  }
}