Git Hooks & Automation: Your Custom Workflow Engine

# 1. Install Husky
npm install husky --save-dev

# 2. Initialize
npx husky init

# 3. Add hooks to .husky/ directory
npx husky add .husky/pre-commit "npm run lint"
npx husky add .husky/commit-msg 'npx --no-install commitlint --edit "$1"'

# 4. Hooks are automatically installed when teammates run npm install
# package.json includes:
"scripts": {
  "prepare": "husky install"
}

# 1. Create .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.3.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-added-large-files

  - repo: local
    hooks:
      - id: eslint
        name: ESLint
        entry: npm run lint
        language: system
        files: \.(js|ts|jsx|tsx)$

# 2. Teammates install with:
pip install pre-commit
pre-commit install

# 1. Create project hooks directory
mkdir -p .githooks
cp .git/hooks/pre-commit .githooks/

# 2. Create setup script
#!/bin/bash
# setup-hooks.sh
echo "Installing Git hooks..."
cp .githooks/* .git/hooks/
chmod +x .git/hooks/*
echo "✅ Hooks installed"

# 3. Configure Git to use template directory
git config core.hooksPath .githooks

# 4. Add to README
# "After cloning, run: git config core.hooksPath .githooks"

# 1. Create global template directory
mkdir -p ~/.git-templates/hooks

# 2. Add hooks
cat > ~/.git-templates/hooks/pre-commit << 'EOF'
#!/bin/bash
echo "Running global pre-commit hook"
EOF

# 3. Make executable
chmod +x ~/.git-templates/hooks/pre-commit

# 4. Configure Git globally
git config --global init.templatedir ~/.git-templates

# 5. New repositories get these hooks automatically
# Existing repos: git init (re-initializes hooks)

# Bypass pre-commit and commit-msg hooks
git commit --no-verify -m "Emergency fix"

# Bypass pre-push hook
git push --no-verify origin main

# Bypass ALL hooks for a command
git -c core.hooksPath=/dev/null commit -m "No hooks"

# Alternative: Set empty hooks directory
git --git-dir=.git --work-tree=. commit --allow-empty -m "Bypass"

# Design hooks to respect skip flags
#!/bin/bash
# pre-commit hook with skip option

# Check for skip flag
if [ -n "$SKIP_HOOKS" ]; then
  echo "⚠️ Skipping hooks (SKIP_HOOKS is set)"
  exit 0
fi

# Or check for specific hook skip
if [ -n "$SKIP_PRE_COMMIT" ]; then
  echo "⚠️ Skipping pre-commit hook"
  exit 0
fi

# Use:
SKIP_PRE_COMMIT=1 git commit -m "Skip pre-commit"
# OR
SKIP_HOOKS=1 git commit -m "Skip all hooks"

#!/bin/bash
# Smart hook that knows when to skip

# Skip on main branch emergency fixes
BRANCH=$(git symbolic-ref --short HEAD)
COMMIT_MSG=$(git log -1 --pretty=%B)

if [[ "$BRANCH" == "main" ]] && [[ "$COMMIT_MSG" == *"[EMERGENCY]"* ]]; then
  echo "🚨 Emergency commit on main - skipping hooks"
  exit 0
fi

# Skip for WIP commits
if [[ "$COMMIT_MSG" == "WIP"* ]] || [[ "$COMMIT_MSG" == *"wip"* ]]; then
  echo "⏸️ WIP commit - skipping hooks"
  exit 0
fi

# Skip for version tag commits
if [[ "$COMMIT_MSG" == *"chore(release):"* ]]; then
  echo "🏷️ Release commit - skipping hooks"
  exit 0
fi

# Temporarily rename hook file
mv .git/hooks/pre-commit .git/hooks/pre-commit.disabled

# Do your work...
git commit -m "Fix something"

# Re-enable
mv .git/hooks/pre-commit.disabled .git/hooks/pre-commit

# With Husky:
npx husky uninstall # Disable all hooks
npx husky install # Re-enable

# Add to ~/.gitconfig
[alias]
  commit-nv = commit --no-verify
  push-nv = push --no-verify
  wip = !git add -A && git commit -m \"WIP\" --no-verify

# Usage:
git commit-nv -m "Emergency fix"
git push-nv origin main
git wip # Save work in progress

# Bad: Running everything on every commit
#!/bin/bash
echo "Running all tests..."
npm run lint # 3 seconds
npm test # 30 seconds
npm run test:e2e # 2 minutes
npm run build # 1 minute
# Total: ~3.5 minutes per commit! ❌

# 1. Install lint-staged
npm install lint-staged --save-dev

# 2. Configure in package.json
{
  "lint-staged": {
    "*.js": "eslint --fix",
    "*.css": "stylelint --fix",
    "*.{json,md}": "prettier --write"
  }
}

# 3. Update pre-commit hook
#!/bin/bash
npx lint-staged

# Result: Only runs on changed files, not entire codebase
# Performance: 500ms vs 30 seconds

# Split checks by speed and importance
# .husky/pre-commit (FAST: < 3 seconds)
#!/bin/bash
npx lint-staged # Style & formatting
npm run type-check # TypeScript checks
npm run test:unit # Unit tests only

# .husky/pre-push (SLOWER: < 2 minutes)
#!/bin/bash
npm run test:integration # Integration tests
npm run build # Build verification
npm run audit # Security audit

# .husky/post-merge (BACKGROUND: Async)
#!/bin/bash
npm run update:deps & # Async dependency updates
npm run generate:docs & # Async documentation

# Use tools with built-in caching
# ESLint with cache
npx eslint --cache --fix "**/*.js"

# Jest with cache
npx jest --changedSince=origin/main --passWithNoTests

# TypeScript incremental compilation
npx tsc --incremental

# Custom caching example
#!/bin/bash
CACHE_DIR=".hook-cache"
mkdir -p "$CACHE_DIR"

# Generate cache key from staged files
CACHE_KEY=$(git diff --cached --name-only | sort | md5sum | cut -d' ' -f1)
CACHE_FILE="$CACHE_DIR/$CACHE_KEY"

# Use cache if available
if [ -f "$CACHE_FILE" ]; then
  echo "✅ Using cached result"
  exit 0
fi

# Run expensive check
npm run expensive-check

# Save to cache
touch "$CACHE_FILE"

# Run independent checks in parallel
#!/bin/bash
# pre-commit with parallel checks

# Define checks to run in parallel
run_lint() {
  npx eslint --quiet .
  return $?
}

run_tests() {
  npx jest --changedSince=origin/main --passWithNoTests
  return $?
}

run_type_check() {
  npx tsc --noEmit
  return $?
}

# Run all in parallel
run_lint &
LINT_PID=$!
run_tests &
TESTS_PID=$!
run_type_check &
TYPE_PID=$!

# Wait for all and collect results
wait $LINT_PID && LINT_RESULT=$? || LINT_RESULT=$?
wait $TESTS_PID && TEST_RESULT=$? || TEST_RESULT=$?
wait $TYPE_PID && TYPE_RESULT=$? || TYPE_RESULT=$?

# Check results
if [ $LINT_RESULT -ne 0 ] || [ $TEST_RESULT -ne 0 ] || [ $TYPE_RESULT -ne 0 ]; then
  exit 1
fi

# Add timing to hooks
#!/bin/bash
start_time=$(date +%s)

# Your hook logic here...
npx lint-staged

end_time=$(date +%s)
execution_time=$((end_time - start_time))

# Log performance
echo "⏱️ Hook executed in ${execution_time}s"

# Warn if too slow
if [ $execution_time -gt 10 ]; then
  echo "⚠️ Hook is slow (>10s), consider optimizing"
  echo "Consider: lint-staged, caching, or moving to pre-push"
fi

# package.json scripts
{
  "scripts": {
    # Local development hooks
    "precommit": "lint-staged",
    "prepush": "npm run test:integration",

    # CI pipeline scripts (run everything)
    "ci:validate": "npm run lint && npm test && npm run build",
    "ci:security": "npm audit && npm run check:dependencies",

    # Combined CI pipeline
    "ci": "npm run ci:validate && npm run ci:security"
  }
}

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: npm ci
      - run: npm run ci # Runs all CI checks

# Hooks that behave differently in CI
#!/bin/bash
# pre-commit hook

# Check if running in CI
if [ -n "$CI" ]; then
  echo "🔧 CI environment detected"
  echo "Running extended checks..."

  # Run everything (CI has more resources)
  npm run lint
  npm test
  npm run build
  npm audit

  if [ $? -ne 0 ]; then
    exit 1
  fi

  exit 0
fi

# Local development: fast checks only
npx lint-staged
npm run test:unit -- --changedSince=origin/main

exit $?

# Configure CI to skip hooks (they'll run in CI scripts instead)
# GitHub Actions example
name: CI
env:
  HUSKY: 0 # Disable Husky hooks
  SKIP_HOOKS: 1 # Disable custom hooks
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        env:
          HUSKY: 0 # Husky won't install hooks
      - uses: actions/checkout@v3

# GitLab CI example
variables:
  HUSKY: "0"

test:
  script:
    - npm ci
    - npm run ci:validate # Run CI checks directly

# Share hook logic between local and CI
# scripts/validate.sh (used by both)
#!/bin/bash
# Common validation script

echo "🔍 Running validation..."

# Language checks
npx eslint .
npx stylelint "**/*.css"

# Tests
npm test

# Build
npm run build

# Security
npm audit --audit-level=moderate

# pre-commit hook (runs fast version)
#!/bin/bash
./scripts/validate.sh --fast

# CI script (runs full version)
#!/bin/bash
./scripts/validate.sh --full

# Test hooks themselves in CI
# .github/workflows/test-hooks.yml
name: Test Hooks
on:
push:
paths:
- '.husky/**'
- '.pre-commit-config.yaml'
- 'scripts/*'

jobs:
test-hooks:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3

- name: Test pre-commit hook
run: |
# Simulate commit with bad code
echo "console.log('bad')" > test.js
git add test.js

# Should fail
if git commit -m "test: bad commit" 2>/dev/null; then
echo "❌ Hook didn't catch error"
exit 1
fi

echo "✅ Hook correctly rejected bad commit"

- name: Test commit-msg hook
run: |
# Try bad commit message
if git commit --allow-empty -m "bad message" 2>/dev/null; then
echo "❌ commit-msg hook failed"
exit 1
fi

# Try good commit message
if ! git commit --allow-empty -m "feat: good message" 2>/dev/null; then
echo "❌ commit-msg hook failed on valid message"
exit 1
fi

echo "✅ commit-msg hook works correctly"

# post-commit: Generate API documentation
#!/bin/bash
echo "📚 Generating documentation..."

# Check if source files changed
if git diff HEAD~1 HEAD --name-only | grep -q "\.(js|ts|py|rb)$"; then
  echo "Source files changed, updating docs..."

  # Generate TypeScript docs
  npx typedoc --out docs/api src/

  # Generate CHANGELOG
  npx conventional-changelog -p angular -i CHANGELOG.md -s

  # Commit generated docs
  git add docs/ CHANGELOG.md
  git commit --amend --no-edit 2>/dev/null || true

  echo "✅ Documentation updated"
fi

# post-checkout: Update branch-specific dependencies
#!/bin/bash
PREV_HEAD=$1
NEW_HEAD=$2
BRANCH_SWITCH=$3

if [ "$BRANCH_SWITCH" = "1" ]; then
  CURRENT_BRANCH=$(git symbolic-ref --short HEAD)

  echo "🌿 Switched to branch: $CURRENT_BRANCH"

  # Check for branch-specific dependencies
  if [ -f "requirements-$CURRENT_BRANCH.txt" ]; then
    echo "Installing branch-specific dependencies..."
    pip install -r "requirements-$CURRENT_BRANCH.txt"
  fi

  # Set branch-specific environment
  if [ -f ".env.$CURRENT_BRANCH" ]; then
    echo "Loading branch environment..."
    cp ".env.$CURRENT_BRANCH" .env
  fi
fi

# prepare-commit-msg: Add context to commit messages
#!/bin/bash
COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2
SHA1=$3

# Only for non-merge commits
if [ "$COMMIT_SOURCE" != "message" ] && [ "$COMMIT_SOURCE" != "merge" ]; then
  # Get current branch
  BRANCH=$(git symbolic-ref --short HEAD)

  # Extract JIRA ticket from branch name
  if [[ "$BRANCH" =~ ([A-Z]+-[0-9]+) ]]; then
    JIRA_TICKET="${BASH_REMATCH[1]}"
    echo "Found JIRA ticket: $JIRA_TICKET"

    # Prepend to commit message
    COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")
    echo "[$JIRA_TICKET] $COMMIT_MSG" > "$COMMIT_MSG_FILE"
  fi

  # Add co-authors for pair programming
  if [ -f ".pair" ]; then
    echo "" >> "$COMMIT_MSG_FILE"
    echo "Co-authored-by:" >> "$COMMIT_MSG_FILE"
    while IFS= read -r PAIR; do
      echo " $PAIR" >> "$COMMIT_MSG_FILE"
    done < ".pair"
  fi
fi

# post-merge: Smart dependency updates
#!/bin/bash
echo "🔄 Checking for dependency updates..."

# Check if package.json changed
if git diff HEAD~1 HEAD --name-only | grep -q package.json; then
  echo "📦 package.json changed, checking for updates..."

  # Check for outdated dependencies
  OUTDATED=$(npm outdated --json || echo "{}")

  if [ "$OUTDATED" != "{}" ]; then
    echo "📈 Outdated dependencies found:"
    echo "$OUTDATED" | jq -r 'to_entries[] | " \(.key): \(.value.current) -> \(.value.latest)"'

    # Ask to update
    read -p "Update dependencies? (y/n): " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      npm update
      echo "✅ Dependencies updated"
    fi
  fi
fi

# post-commit: Collect code metrics
#!/bin/bash
echo "📊 Collecting code metrics..."

# Get commit hash
COMMIT_HASH=$(git rev-parse HEAD)

# Calculate complexity metrics
COMPLEXITY=$(npx complexity-report --format=json . | jq '.total.cyclomatic')
LINES=$(git diff --stat HEAD~1 HEAD | tail -1 | awk '{print $4}')
FILES_CHANGED=$(git diff --name-only HEAD~1 HEAD | wc -l)

# Store metrics
echo "{\"commit\":\"$COMMIT_HASH\",\"complexity\":$COMPLEXITY,\"lines\":$LINES,\"files\":$FILES_CHANGED}" >> metrics.json

# Check for complexity increase
PREV_COMPLEXITY=$(tail -2 metrics.json | head -1 | jq '.complexity')
if [ "$COMPLEXITY" -gt "$((PREV_COMPLEXITY * 120 / 100))" ]; then
  echo "⚠️ Warning: Complexity increased by >20%"
  echo " Consider refactoring complex code"
fi

echo "✅ Metrics collected"

# post-commit: Notify external systems
#!/bin/bash
echo "🔗 Notifying external systems..."

# Get commit info
COMMIT_HASH=$(git rev-parse HEAD)
COMMIT_MSG=$(git log -1 --pretty=%B)
BRANCH=$(git symbolic-ref --short HEAD)
AUTHOR=$(git log -1 --pretty=%an)

# Send to Slack
curl -X POST -H 'Content-type: application/json' \
--data "{\"text\":\"🚀 New commit on $BRANCH by $AUTHOR: $COMMIT_MSG\"}" \
$SLACK_WEBHOOK_URL

# Update JIRA
if [[ "$COMMIT_MSG" =~ ([A-Z]+-[0-9]+) ]]; then
  JIRA_TICKET="${BASH_REMATCH[1]}"
  echo "Updating JIRA ticket $JIRA_TICKET..."
  # API call to JIRA
fi

# Trigger CI/CD (if not already)
if [[ "$BRANCH" == "main" ]] || [[ "$BRANCH" == "develop" ]]; then
  echo "Triggering deployment..."
  curl -X POST $DEPLOY_WEBHOOK
fi

echo "✅ Notifications sent"

# pre-commit: Educational hints for new developers
#!/bin/bash
# Check if developer is new (first 30 days)
FIRST_COMMIT_DATE=$(git log --reverse --format="%ad" --date=short | head -1)
DAYS_SINCE_FIRST=$(( ($(date +%s) - $(date -d "$FIRST_COMMIT_DATE" +%s)) / 86400 ))

if [ "$DAYS_SINCE_FIRST" -lt 30 ]; then
  echo "👋 Welcome new developer! Here are some tips:"

  # Check for common newbie patterns
  if git diff --cached | grep -q "console\.log"; then
    echo "💡 Tip: Remove console.log before committing"
    echo " Use debugger or logging library instead"
  fi

  if git diff --cached --stat | tail -1 | awk '{print $4}' -gt 200; then
    echo "💡 Tip: Consider smaller commits (< 200 lines)"
    echo " Smaller commits are easier to review"
  fi

  # Suggest helpful resources
  echo "📚 Helpful resources:"
  echo " - CONTRIBUTING.md"
  echo " - docs/code-style.md"
  echo " - Ask in #help channel"
fi

# Continue with normal checks
npx lint-staged