ls .git/hooks/

#!/bin/bash
# .git/hooks/pre-commit
 
# Run linter
echo "Running linter..."
npm run lint 2>/dev/null
if [ $? -ne 0 ]; then
    echo "❌ Linting failed. Fix errors before committing."
    exit 1
fi
 
# Check for debug statements
if git diff --cached --name-only | xargs grep -l "console\.log\|debugger\|binding\.pry" 2>/dev/null; then
    echo "❌ Debug statements found in staged files."
    echo "Remove console.log/debugger statements before committing."
    exit 1
fi
 
# Check for large files
MAX_FILE_SIZE=5242880  # 5MB
for file in $(git diff --cached --name-only); do
    if [ -f "$file" ]; then
        file_size=$(wc -c < "$file")
        if [ "$file_size" -gt "$MAX_FILE_SIZE" ]; then
            echo "❌ File $file is too large ($(($file_size / 1024))KB > 5MB)"
            exit 1
        fi
    fi
done
 
echo "✅ Pre-commit checks passed."
exit 0

#!/bin/bash
# .git/hooks/prepare-commit-msg
 
COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2  # "message", "template", "merge", "squash", or ""
SHA1=$3           # Only set when amending
 
# Don't modify merge commits or amend commits
if [ "$COMMIT_SOURCE" = "merge" ] || [ -n "$SHA1" ]; then
    exit 0
fi
 
# Auto-prepend branch name as ticket reference
BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null)
 
# Extract ticket number from branch name (e.g., feature/PROJ-123-add-login → PROJ-123)
TICKET=$(echo "$BRANCH" | grep -oE '[A-Z]+-[0-9]+')
 
if [ -n "$TICKET" ]; then
    # Only prepend if ticket isn't already in the message
    if ! grep -q "$TICKET" "$COMMIT_MSG_FILE"; then
        sed -i.bak "1s/^/[$TICKET] /" "$COMMIT_MSG_FILE"
        rm -f "${COMMIT_MSG_FILE}.bak"
    fi
fi

#!/bin/bash
# .git/hooks/commit-msg
 
COMMIT_MSG_FILE=$1
COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")
 
# Enforce minimum message length
if [ ${#COMMIT_MSG} -lt 10 ]; then
    echo "❌ Commit message too short (minimum 10 characters)."
    exit 1
fi
 
# Enforce conventional commit format
# Pattern: type(optional-scope): description
PATTERN="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .{1,}"
 
if ! echo "$COMMIT_MSG" | head -1 | grep -qE "$PATTERN"; then
    echo "❌ Commit message does not follow Conventional Commits format."
    echo ""
    echo "Expected format: type(scope): description"
    echo ""
    echo "Valid types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert"
    echo ""
    echo "Examples:"
    echo "  feat: add user authentication"
    echo "  fix(auth): resolve login redirect loop"
    echo "  docs: update API reference"
    exit 1
fi
 
# Enforce subject line length (max 72 characters)
SUBJECT_LENGTH=$(echo "$COMMIT_MSG" | head -1 | wc -c)
if [ "$SUBJECT_LENGTH" -gt 73 ]; then
    echo "❌ Subject line too long ($SUBJECT_LENGTH chars). Maximum is 72."
    exit 1
fi
 
exit 0

#!/bin/bash
# .git/hooks/post-commit
 
COMMIT_MSG=$(git log -1 --pretty=%s)
BRANCH=$(git symbolic-ref --short HEAD)
 
echo "📦 Committed to $BRANCH: $COMMIT_MSG"
 
# Optional: send notification
# curl -s -X POST "https://hooks.slack.com/..." \
#   -d "{\"text\":\"New commit on $BRANCH: $COMMIT_MSG\"}" > /dev/null

#!/bin/bash
# .git/hooks/pre-push
 
REMOTE="$1"
URL="$2"
 
# Prevent pushing to main/master directly
CURRENT_BRANCH=$(git symbolic-ref --short HEAD)
 
if [ "$CURRENT_BRANCH" = "main" ] || [ "$CURRENT_BRANCH" = "master" ]; then
    echo "❌ Direct push to $CURRENT_BRANCH is not allowed."
    echo "Create a feature branch and open a pull request."
    exit 1
fi
 
# Run tests before pushing
echo "Running tests before push..."
npm test 2>/dev/null
if [ $? -ne 0 ]; then
    echo "❌ Tests failed. Fix them before pushing."
    exit 1
fi
 
exit 0

#!/bin/bash
# .git/hooks/post-merge
 
# Check if package.json changed
CHANGED_FILES=$(git diff-tree -r --name-only --no-commit-id ORIG_HEAD HEAD)
 
if echo "$CHANGED_FILES" | grep -q "package.json"; then
    echo "📦 package.json changed. Running npm install..."
    npm install
fi
 
if echo "$CHANGED_FILES" | grep -q "requirements.txt"; then
    echo "🐍 requirements.txt changed. Running pip install..."
    pip install -r requirements.txt
fi
 
if echo "$CHANGED_FILES" | grep -q "Gemfile"; then
    echo "💎 Gemfile changed. Running bundle install..."
    bundle install
fi

#!/bin/bash
# .git/hooks/post-checkout
 
PREV_HEAD=$1
NEW_HEAD=$2
BRANCH_CHECKOUT=$3  # 1 = branch switch, 0 = file checkout
 
# Only run on branch switches
if [ "$BRANCH_CHECKOUT" -ne 1 ]; then
    exit 0
fi
 
# Check if package.json differs between branches
if ! git diff --quiet "$PREV_HEAD" "$NEW_HEAD" -- package.json 2>/dev/null; then
    echo "📦 package.json differs on this branch. Running npm install..."
    npm install
fi

#!/bin/bash
# .git/hooks/pre-rebase
 
UPSTREAM=$1
BRANCH=${2:-$(git symbolic-ref --short HEAD)}
 
# Prevent rebasing protected branches
PROTECTED="main master develop"
for protected_branch in $PROTECTED; do
    if [ "$BRANCH" = "$protected_branch" ]; then
        echo "❌ Rebasing $BRANCH is not allowed."
        exit 1
    fi
done
 
exit 0

# Skip pre-commit and commit-msg hooks
git commit --no-verify -m "WIP: experimental changes"
 
# Short form
git commit -n -m "WIP: quick save"
 
# Also works with push
git push --no-verify

# Common WIP alias
alias gwip='git add -A && git commit --no-verify -m "WIP"'

# Create a hooks directory in your repo
mkdir .githooks
 
# Move/create your hooks there
cp .git/hooks/pre-commit .githooks/pre-commit
chmod +x .githooks/pre-commit
 
# Tell Git to use this directory
git config core.hooksPath .githooks
 
# Commit the hooks
git add .githooks/
git commit -m "chore: add shared git hooks"

git config core.hooksPath .githooks

git config --global core.hooksPath .githooks

# Create hooks in a tracked directory
mkdir -p scripts/hooks
# ... create your hook scripts there ...
 
# Each developer runs this setup script:
#!/bin/bash
# scripts/setup-hooks.sh
HOOK_DIR=".git/hooks"
SCRIPT_DIR="scripts/hooks"
 
for hook in "$SCRIPT_DIR"/*; do
    hook_name=$(basename "$hook")
    ln -sf "../../$SCRIPT_DIR/$hook_name" "$HOOK_DIR/$hook_name"
    echo "Linked $hook_name"
done

# Install
npm install --save-dev husky
 
# Initialize (creates .husky/ directory)
npx husky init

{
  "scripts": {
    "prepare": "husky"
  }
}

# Create a pre-commit hook
echo "npm test" > .husky/pre-commit
 
# Create a commit-msg hook
echo 'npx --no -- commitlint --edit "$1"' > .husky/commit-msg

npm install --save-dev lint-staged

{
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "eslint --fix",
      "prettier --write"
    ],
    "*.{css,scss}": [
      "prettier --write"
    ],
    "*.{json,md}": [
      "prettier --write"
    ]
  }
}

{
  "*.js": ["eslint --fix", "prettier --write"],
  "*.py": ["black", "flake8"],
  "*.go": ["gofmt -w", "go vet"]
}

# .husky/pre-commit
npx lint-staged

# Install the tool
pip install pre-commit
 
# Or via Homebrew
brew install pre-commit

repos:
  # General checks
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-json
      - id: check-added-large-files
        args: ['--maxkb=500']
      - id: no-commit-to-branch
        args: ['--branch', 'main', '--branch', 'master']
 
  # JavaScript/TypeScript
  - repo: https://github.com/pre-commit/mirrors-eslint
    rev: v8.56.0
    hooks:
      - id: eslint
        files: \.[jt]sx?$
        additional_dependencies:
          - eslint@8.56.0
 
  # Python
  - repo: https://github.com/psf/black
    rev: 24.1.1
    hooks:
      - id: black
 
  # Commit message validation
  - repo: https://github.com/compilerla/conventional-pre-commit
    rev: v3.1.0
    hooks:
      - id: conventional-pre-commit
        stages: [commit-msg]

# Install the hooks into .git/hooks/
pre-commit install
 
# Also install commit-msg hook
pre-commit install --hook-type commit-msg
 
# Run against all files (first time or CI)
pre-commit run --all-files

# Install
brew install lefthook
# Or: npm install lefthook --save-dev
# Or: curl -fsSL https://get.lefthook.com | sh
 
# Initialize
lefthook install

pre-commit:
  parallel: true
  commands:
    lint:
      glob: "*.{js,ts,jsx,tsx}"
      run: npx eslint {staged_files}
    format:
      glob: "*.{js,ts,jsx,tsx,json,css,md}"
      run: npx prettier --check {staged_files}
    test:
      run: npm test
 
commit-msg:
  commands:
    validate:
      run: 'head -1 {1} | grep -qE "^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .+"'
 
pre-push:
  commands:
    test:
      run: npm test
    no-main:
      run: |
        branch=$(git symbolic-ref --short HEAD)
        if [ "$branch" = "main" ] || [ "$branch" = "master" ]; then
          echo "Direct push to $branch is not allowed"
          exit 1
        fi

npm install --save-dev @commitlint/cli @commitlint/config-conventional

{
  "extends": ["@commitlint/config-conventional"]
}

module.exports = {
  extends: ['@commitlint/config-conventional'],
  rules: {
    'type-enum': [2, 'always', [
      'feat', 'fix', 'docs', 'style', 'refactor',
      'perf', 'test', 'build', 'ci', 'chore', 'revert'
    ]],
    'subject-max-length': [2, 'always', 72],
    'body-max-line-length': [2, 'always', 100],
  }
};

# .husky/commit-msg
npx --no -- commitlint --edit "$1"

# ✅ Valid messages:
git commit -m "feat: add user authentication"
git commit -m "fix(auth): resolve login redirect"
git commit -m "docs: update API reference"
 
# ❌ Invalid messages (commitlint will reject):
git commit -m "Add user authentication"        # Missing type prefix
git commit -m "feat add auth"                   # Missing colon
git commit -m "FEAT: add auth"                  # Wrong case
git commit -m "feat: A"                         # Too short

#!/bin/bash
# .git/hooks/commit-msg
 
# Pipe the commit message file to commitlint
cat "$1" | npx --no -- commitlint

chmod +x .git/hooks/commit-msg

mkdir hooks-lab && cd hooks-lab
git init
 
# Create a simple project
cat > app.js << 'EOF'
function greet(name) {
  return "Hello, " + name;
}
 
function add(a, b) {
  return a + b;
}
 
module.exports = { greet, add };
EOF
 
cat > utils.js << 'EOF'
function formatDate(date) {
  return date.toISOString().split('T')[0];
}
 
module.exports = { formatDate };
EOF
 
git add .
git commit -m "feat: initial project setup"

# Create the hook
cat > .git/hooks/pre-commit << 'HOOK'
#!/bin/bash
 
echo "🔍 Running pre-commit checks..."
 
# Check for console.log statements in staged JS files
STAGED_JS=$(git diff --cached --name-only --diff-filter=ACM | grep '\.js$')
 
if [ -n "$STAGED_JS" ]; then
    if git diff --cached -- $STAGED_JS | grep -q "console\.log"; then
        echo "❌ Found console.log in staged files:"
        git diff --cached -- $STAGED_JS | grep -n "console\.log"
        echo ""
        echo "Remove debug statements before committing."
        exit 1
    fi
fi
 
# Check for trailing whitespace
if git diff --cached --check 2>/dev/null | grep -q "trailing whitespace"; then
    echo "❌ Trailing whitespace detected:"
    git diff --cached --check
    exit 1
fi
 
echo "✅ Pre-commit checks passed!"
exit 0
HOOK
 
chmod +x .git/hooks/pre-commit

# This should PASS (no console.log)
echo "function test() { return true; }" >> app.js
git add app.js
git commit -m "feat: add test function"
# ✅ Should succeed
 
# This should FAIL (has console.log)
echo "console.log('debug');" >> app.js
git add app.js
git commit -m "feat: add logging"
# ❌ Should be blocked by hook
 
# Clean up the debug statement
git checkout -- app.js

cat > .git/hooks/commit-msg << 'HOOK'
#!/bin/bash
 
COMMIT_MSG_FILE=$1
COMMIT_MSG=$(cat "$COMMIT_MSG_FILE")
FIRST_LINE=$(head -1 "$COMMIT_MSG_FILE")
 
# Allow merge commits
if echo "$FIRST_LINE" | grep -qE "^Merge "; then
    exit 0
fi
 
# Enforce conventional commit format
PATTERN="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .{3,}"
 
if ! echo "$FIRST_LINE" | grep -qE "$PATTERN"; then
    echo ""
    echo "❌ Invalid commit message format!"
    echo ""
    echo "Your message:  $FIRST_LINE"
    echo ""
    echo "Expected:      type(scope): description"
    echo ""
    echo "Valid types:   feat, fix, docs, style, refactor,"
    echo "               perf, test, build, ci, chore, revert"
    echo ""
    echo "Examples:"
    echo "  feat: add user authentication"
    echo "  fix(api): handle null response"
    echo "  docs: update installation guide"
    echo ""
    exit 1
fi
 
# Check subject line length
LENGTH=${#FIRST_LINE}
if [ "$LENGTH" -gt 72 ]; then
    echo "❌ Subject line too long ($LENGTH chars, max 72)."
    exit 1
fi
 
exit 0
HOOK
 
chmod +x .git/hooks/commit-msg

# This should FAIL (no conventional prefix)
echo "// update" >> app.js
git add app.js
git commit -m "update the code"
# ❌ Should be blocked
 
# This should PASS
git commit -m "refactor: update the code structure"
# ✅ Should succeed
 
# This should FAIL (too short description)
echo "// fix" >> utils.js
git add utils.js
git commit -m "fix: ab"
# ❌ Should fail (description less than 3 chars)
 
# This should PASS
git commit -m "fix: adjust date formatting"
# ✅ Should succeed

cat > .git/hooks/prepare-commit-msg << 'HOOK'
#!/bin/bash
 
COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2
 
# Only modify manual commits (not merges, amends, etc.)
if [ -n "$COMMIT_SOURCE" ]; then
    exit 0
fi
 
# Get current branch name
BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null)
 
# Extract ticket number (e.g., PROJ-123 from feature/PROJ-123-add-login)
TICKET=$(echo "$BRANCH" | grep -oE '[A-Z]+-[0-9]+')
 
if [ -n "$TICKET" ]; then
    # Prepend ticket number if not already present
    if ! grep -q "$TICKET" "$COMMIT_MSG_FILE"; then
        CURRENT_MSG=$(cat "$COMMIT_MSG_FILE")
        echo "[$TICKET] $CURRENT_MSG" > "$COMMIT_MSG_FILE"
    fi
fi
HOOK
 
chmod +x .git/hooks/prepare-commit-msg

# Create a branch with a ticket number
git checkout -b feature/PROJ-42-add-validation
 
echo "// validation" >> app.js
git add app.js
 
# Commit with -m (prepare-commit-msg still runs but the message already has content)
# For this hook to truly shine, commit without -m and see it pre-fill the editor
git commit -m "feat: add input validation"
 
# Check the commit message
git log -1 --pretty=%s
# Should show: [PROJ-42] feat: add input validation
 
git checkout main

cat > .git/hooks/pre-push << 'HOOK'
#!/bin/bash
 
BRANCH=$(git symbolic-ref --short HEAD)
 
# Block direct pushes to main
if [ "$BRANCH" = "main" ] || [ "$BRANCH" = "master" ]; then
    echo ""
    echo "❌ Direct push to $BRANCH is blocked!"
    echo ""
    echo "Please create a feature branch and open a pull request."
    echo ""
    exit 1
fi
 
echo "✅ Push to $BRANCH allowed."
exit 0
HOOK
 
chmod +x .git/hooks/pre-push

# Test the branch check logic manually
BRANCH=$(git symbolic-ref --short HEAD)
echo "Current branch: $BRANCH"
 
# If on main, the hook would block. If on a feature branch, it would allow.

git checkout main
 
# Create a shared hooks directory
mkdir -p .githooks
 
# Copy hooks to the shared directory
cp .git/hooks/pre-commit .githooks/
cp .git/hooks/commit-msg .githooks/
 
# Point Git to the shared directory
git config core.hooksPath .githooks
 
# Commit the shared hooks
git add .githooks/
git commit -m "chore: add shared git hooks for team"
 
# Verify hooks still work from the new location
echo "// test shared hooks" >> app.js
git add app.js
git commit -m "test without prefix"
# ❌ Should still be caught by commit-msg hook
 
git commit -m "test: verify shared hooks work"
# ✅ Should succeed