EVENTO → ACCIÓN AUTOMÁTICA

Evento: Claude edita un archivo .ts
Acción: Ejecutar prettier automáticamente

Evento: Claude modifica código en /src
Acción: Ejecutar tests relacionados con ese archivo

Evento: Claude ejecuta un comando bash
Acción: Registrar el comando en un archivo de log

Evento: Claude termina de responder
Acción: Enviar notificación de escritorio

> Ejecuta prettier en src/utils.ts

> /format src/utils.ts

Tú: Modifica la función calculate_total en src/utils.py
Claude: [Modifica el archivo]
Tú: Ejecuta black en ese archivo
Claude: [Ejecuta black]
Tú: Ahora ejecuta isort
Claude: [Ejecuta isort]
Tú: Ejecuta los tests relacionados
Claude: [Ejecuta tests]

Tú: Modifica la función calculate_total en src/utils.py
Claude: [Modifica el archivo]
→ Hook 1: Ejecuta black automáticamente
→ Hook 2: Ejecuta isort automáticamente
→ Hook 3: Ejecuta tests automáticamente

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"SESSION_ID=$(date +%s)\" > \"$CLAUDE_ENV_FILE\""
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "SessionEnd": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"Sesión finalizada: $(date)\" >> ~/.claude/session-log.txt"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Setup": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "npm install && git config --local core.hooksPath .claude/git-hooks"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"Contexto adicional: Branch actual = $(git branch --show-current)\""
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
# .claude/hooks/validate-prompt.sh
 
# Lee el prompt del usuario
prompt=$(jq -r '.user_prompt' | tr '[:upper:]' '[:lower:]')
 
# Bloquea si contiene palabras sensibles
if echo "$prompt" | grep -qE '(password|secret|api[_-]?key)'; then
  echo '{"decision": "block", "reason": "El prompt contiene información sensible"}'
  exit 0
fi

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Claude ha terminado de responder'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evalúa si Claude debe continuar trabajando basándote en:\n$ARGUMENTS\n\nResponde JSON: {\"ok\": true} para continuar o {\"ok\": false, \"reason\": \"explicación\"} para detener",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
# .claude/hooks/block-sensitive.sh
 
file_path=$(jq -r '.tool_input.file_path // empty')
 
# Lista de patterns prohibidos
if echo "$file_path" | grep -qE '(\.env|\.git/|node_modules/|\.ssh/)'; then
  # Exit 2 = Bloquear operación
  echo "Acceso denegado a archivo sensible: $file_path" >&2
  exit 2
fi
 
exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Read|Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/block-sensitive.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.command' >> ~/.claude/bash-commands.log"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
# .claude/hooks/auto-format.sh
 
file_path=$(jq -r '.tool_input.file_path')
 
# Solo formatear archivos TypeScript/JavaScript
if echo "$file_path" | grep -qE '\.(ts|tsx|js|jsx)$'; then
  npx prettier --write "$file_path" 2>/dev/null
fi

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/auto-format.sh",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "file=$(jq -r '.tool_input.file_path'); npm test -- --findRelatedTests \"$file\" --passWithNoTests",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUseFailure": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"[$(date)] Comando falló\" >> ~/.claude/errors.log && jq '.' >> ~/.claude/errors.log"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
# Auto-aprobar comandos git read-only
 
command=$(jq -r '.tool_input.command // empty')
 
# Auto-aprobar comandos git de solo lectura
if echo "$command" | grep -qE '^git (status|log|diff|show|branch)'; then
  echo '{"hookSpecificOutput": {"hookEventName": "PermissionRequest", "permissionDecision": "allow"}}'
  exit 0
fi
 
# Para todo lo demás, preguntar al usuario
echo '{"hookSpecificOutput": {"hookEventName": "PermissionRequest", "permissionDecision": "ask"}}'
exit 0

{
  "hooks": {
    "SubagentStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"[$(date)] Subagente iniciado\" >> ~/.claude/subagents.log"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "SubagentStop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Subagente completado' 'El subagente ha terminado su tarea'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"Compactación iniciada: $(date)\" >> ~/.claude/compact-log.txt"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Notification": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.message' | xargs -I {} notify-send 'Claude Code' '{}'"
          }
        ]
      }
    ]
  }
}

{
  "matcher": "PATRÓN"
}

// Solo para archivos Python
{
  "matcher": "Write|Edit",
  "hooks": [/* ... */]
}
 
// Solo comandos bash
{
  "matcher": "Bash",
  "hooks": [/* ... */]
}
 
// Todas las herramientas
{
  "matcher": "*",
  "hooks": [/* ... */]
}

claude (sesión inicia)
  │
  ├─→ SessionStart
  │
  ├─→ UserPromptSubmit ──→ [Usuario envía mensaje]
  │
  ├─→ PreToolUse ──────────→ [Claude va a usar herramienta]
  │
  ├─→ PostToolUse ─────────→ [Herramienta ejecutada con éxito]
  │   o
  ├─→ PostToolUseFailure ──→ [Herramienta falló]
  │
  ├─→ Stop ────────────────→ [Claude terminó de responder]
  │
  ├─→ /compact (manual)
  │   └─→ PreCompact
  │
  └─→ SessionEnd (al cerrar)

1. ~/.claude/settings.json           → Configuración GLOBAL (todos los proyectos)
2. .claude/settings.json             → Configuración del PROYECTO (en git)
3. .claude/settings.local.json       → Configuración LOCAL (no commitida)

{
  "hooks": {
    "TIPO_DE_HOOK": [
      {
        "matcher": "PATRÓN",  // Solo para PreToolUse, PostToolUse, PermissionRequest
        "hooks": [
          {
            "type": "command",
            "command": "comando a ejecutar",
            "timeout": 60
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read f; [[ \"$f\" =~ \\.tsx?$ ]] && npx prettier --write \"$f\"; }",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

.claude/
├── settings.json
└── hooks/
    └── format-typescript.sh

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/format-typescript.sh",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail
 
# Leer el JSON de entrada desde stdin
file_path=$(jq -r '.tool_input.file_path')
 
# Verificar que es un archivo TypeScript/JavaScript
if [[ "$file_path" =~ \.(ts|tsx|js|jsx)$ ]]; then
  echo "Formateando: $file_path" >&2
  npx prettier --write "$file_path" 2>&1
fi
 
exit 0

chmod +x .claude/hooks/format-typescript.sh

#!/usr/bin/env bash
echo "Proyecto: $CLAUDE_PROJECT_DIR"
echo "Es remoto: $CLAUDE_CODE_REMOTE"

{
  "session_id": "abc123def456",
  "transcript_path": "/ruta/al/transcript.jsonl",
  "cwd": "/directorio/actual",
  "permission_mode": "default",
  "hook_event_name": "PostToolUse"
}

{
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/ruta/absoluta/archivo.ts",
    "content": "contenido del archivo..."
  },
  "tool_use_id": "toolu_01ABC123..."
}

{
  "tool_name": "Edit",
  "tool_input": {
    "file_path": "/ruta/absoluta/archivo.ts",
    "old_string": "texto antiguo",
    "new_string": "texto nuevo",
    "replace_all": false
  }
}

{
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test",
    "description": "Ejecutar tests",
    "timeout": 120000,
    "run_in_background": false
  }
}

#!/usr/bin/env bash
 
# Extraer campos específicos
file_path=$(jq -r '.tool_input.file_path')
tool_name=$(jq -r '.tool_name')
command=$(jq -r '.tool_input.command // empty')
 
echo "Herramienta: $tool_name"
echo "Archivo: $file_path"

#!/usr/bin/env bash
 
# Leer todo el stdin
json_input=$(cat)
 
# Extraer con grep/sed (menos robusto)
file_path=$(echo "$json_input" | grep -oP '"file_path":\s*"\K[^"]+')

#!/usr/bin/env bash
# .claude/hooks/block-dangerous.sh
 
command=$(jq -r '.tool_input.command // empty')
 
# Lista de comandos peligrosos
if echo "$command" | grep -qE '(rm -rf|sudo|mkfs|dd if=|:(){ :|:& };:)'; then
  echo "BLOQUEADO: Comando peligroso detectado" >&2
  exit 2  # Bloquea la ejecución
fi
 
# Comando permitido
exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/block-dangerous.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
 
file_path=$(jq -r '.tool_input.file_path')
 
if [[ "$file_path" == *".env"* ]]; then
  # Denegar con JSON
  cat <<EOF
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "No se pueden modificar archivos .env"
  }
}
EOF
  exit 0
fi
 
# Permitir
cat <<EOF
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow"
  }
}
EOF
exit 0

#!/usr/bin/env bash
 
prompt=$(jq -r '.user_prompt' | tr '[:upper:]' '[:lower:]')
 
if echo "$prompt" | grep -qE '(password|secret|token)'; then
  # Bloquear prompt
  cat <<EOF
{
  "decision": "block",
  "reason": "El prompt contiene información sensible",
  "hookSpecificOutput": {
    "hookEventName": "UserPromptSubmit"
  }
}
EOF
  exit 0
fi
 
# Permitir y añadir contexto
cat <<EOF
{
  "hookSpecificOutput": {
    "hookEventName": "UserPromptSubmit",
    "additionalContext": "Branch actual: $(git branch --show-current 2>/dev/null || echo 'no-git')"
  }
}
EOF
exit 0

{
  "type": "command",
  "command": "npm test",
  "timeout": 300
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/format.sh",
            "timeout": 30
          },
          {
            "type": "command",
            "command": ".claude/hooks/lint.sh",
            "timeout": 60
          },
          {
            "type": "command",
            "command": ".claude/hooks/test.sh",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"SESSION_START=$(date +%s)\" > \"$CLAUDE_ENV_FILE\" && echo \"Sesión iniciada: $(date)\"",
            "timeout": 10
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/log-bash.sh",
            "timeout": 10
          },
          {
            "type": "command",
            "command": ".claude/hooks/block-dangerous.sh",
            "timeout": 10
          }
        ]
      },
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/block-sensitive-files.sh",
            "timeout": 10
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/format-and-lint.sh",
            "timeout": 60
          },
          {
            "type": "command",
            "command": ".claude/hooks/run-tests.sh",
            "timeout": 180
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Claude ha terminado'",
            "timeout": 5
          }
        ]
      }
    ],
    "SessionEnd": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"Sesión finalizada: $(date)\" >> ~/.claude/session-history.log",
            "timeout": 10
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail
 
command=$(jq -r '.tool_input.command')
description=$(jq -r '.tool_input.description // "Sin descripción"')
 
echo "[$(date -Iseconds)] $description: $command" >> "$CLAUDE_PROJECT_DIR/.claude/bash-log.txt"
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
command=$(jq -r '.tool_input.command // empty')
 
if echo "$command" | grep -qE '(rm -rf|sudo |mkfs|dd if=)'; then
  echo "ERROR: Comando peligroso bloqueado" >&2
  exit 2
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
if echo "$file_path" | grep -qE '(\.env|\.git/|\.ssh/|credentials|secrets)'; then
  echo "ERROR: Acceso denegado a archivo sensible: $file_path" >&2
  exit 2
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Solo procesar archivos TypeScript/JavaScript
if [[ "$file_path" =~ \.(ts|tsx|js|jsx)$ ]]; then
  echo "Formateando: $file_path" >&2
  npx prettier --write "$file_path" 2>&1
 
  echo "Linting: $file_path" >&2
  npx eslint --fix "$file_path" 2>&1 || true  # No fallar si hay errores de lint
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Solo ejecutar tests para archivos en src/
if [[ "$file_path" =~ ^.*/src/.* ]] && [[ "$file_path" =~ \.(ts|tsx)$ ]]; then
  echo "Ejecutando tests relacionados con: $file_path" >&2
  npm test -- --findRelatedTests "$file_path" --passWithNoTests 2>&1 || true
fi
 
exit 0

{
  "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/script.sh"
}

{
  "command": ".claude/hooks/script.sh"
}

npx prettier --write "$file_path"

npx prettier --write $file_path  # Falla con espacios

#!/usr/bin/env bash
set -euo pipefail  # Salir en errores, variables no definidas, fallos en pipes
 
# Tu código aquí

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path // empty')
 
# Verificar que no está vacío
if [[ -z "$file_path" ]]; then
  echo "ERROR: file_path no disponible" >&2
  exit 1
fi
 
# Verificar path traversal
if [[ "$file_path" == *".."* ]]; then
  echo "ERROR: Path traversal detectado" >&2
  exit 2
fi

#!/usr/bin/env bash
 
# Mensajes informativos a stderr (se muestran en verbose)
echo "Procesando archivo..." >&2
 
# Output JSON o datos a stdout (se usa para decisiones)
echo '{"status": "ok"}'

{
  "hooks": [
    {
      "type": "command",
      "command": "operación-rápida.sh",
      "timeout": 10
    },
    {
      "type": "command",
      "command": "operación-lenta.sh",
      "timeout": 300
    }
  ]
}

# Lint puede encontrar errores pero no debe bloquear
npx eslint --fix "$file_path" 2>&1 || true
 
# Tests pueden fallar pero no debe bloquear la edición
npm test -- --findRelatedTests "$file_path" 2>&1 || true

# Modo verbose: muestra todos los hooks y su output
claude --verbose
 
# O durante la sesión, presiona Ctrl+O

# Agregar logging explícito
echo "Hook ejecutado: $(date)" >> /tmp/claude-hooks.log
jq '.' >> /tmp/claude-hooks-input.log  # Guardar JSON de entrada

# Simular entrada JSON
echo '{"tool_input": {"file_path": "/ruta/test.ts"}}' | .claude/hooks/script.sh

# Los scripts deben ser ejecutables
chmod +x .claude/hooks/*.sh
 
# Verificar
ls -la .claude/hooks/

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/auto-commit.sh",
            "timeout": 60
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
tool_name=$(jq -r '.tool_name')
 
# Verificar que estamos en un repositorio git
if ! git rev-parse --git-dir > /dev/null 2>&1; then
  echo "No es un repositorio git, omitiendo commit" >&2
  exit 0
fi
 
# Verificar que el archivo existe
if [[ ! -f "$file_path" ]]; then
  echo "Archivo no existe: $file_path" >&2
  exit 0
fi
 
# Obtener el nombre del archivo relativo al repo
relative_path=$(git ls-files --full-name "$file_path" 2>/dev/null || basename "$file_path")
 
# Crear mensaje de commit descriptivo
commit_msg="Auto: $tool_name $relative_path
 
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>"
 
# Agregar y hacer commit
git add "$file_path"
git commit -m "$commit_msg" --quiet 2>&1 || {
  echo "Commit falló o no hay cambios" >&2
  exit 0
}
 
echo "✓ Commit automático realizado: $relative_path" >&2
exit 0

commit_sha=$(git rev-parse --short HEAD)
echo "[$(date -Iseconds)] Commit $commit_sha: $relative_path" >> "$CLAUDE_PROJECT_DIR/.claude/commit-log.txt"

# Verificar que hay cambios
if git diff --cached --quiet; then
  echo "No hay cambios para commitear" >&2
  exit 0
fi

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Solo procesar archivos de código fuente
if [[ ! "$file_path" =~ \.(ts|tsx|js|jsx|py|go)$ ]]; then
  exit 0
fi
 
# No ejecutar tests para archivos de test
if [[ "$file_path" =~ \.(test|spec)\. ]]; then
  echo "Archivo de test modificado, omitiendo ejecución" >&2
  exit 0
fi
 
echo "Ejecutando tests relacionados con: $file_path" >&2
 
# Detectar el framework de testing
if [[ -f "package.json" ]] && grep -q '"jest"' package.json; then
  # Jest (JavaScript/TypeScript)
  npm test -- --findRelatedTests "$file_path" --passWithNoTests 2>&1 || {
    echo "⚠ Algunos tests fallaron" >&2
    exit 0  # No bloquear por tests fallidos
  }
elif [[ -f "pytest.ini" ]] || [[ -f "setup.py" ]]; then
  # Pytest (Python)
  pytest "$file_path" --tb=short 2>&1 || {
    echo "⚠ Algunos tests fallaron" >&2
    exit 0
  }
elif [[ "$file_path" =~ \.go$ ]]; then
  # Go testing
  package_dir=$(dirname "$file_path")
  go test "./$package_dir" -v 2>&1 || {
    echo "⚠ Algunos tests fallaron" >&2
    exit 0
  }
else
  echo "Framework de testing no detectado" >&2
  exit 0
fi
 
echo "✓ Tests completados" >&2
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Jest con timeout corto y solo tests unitarios
npm test -- \
  --findRelatedTests "$file_path" \
  --testPathIgnorePatterns="e2e|integration" \
  --maxWorkers=2 \
  --testTimeout=5000 \
  --passWithNoTests \
  2>&1 || exit 0
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
# Detectar sistema operativo
if [[ "$OSTYPE" == "linux-gnu"* ]]; then
  NOTIFY_CMD="notify-send"
elif [[ "$OSTYPE" == "darwin"* ]]; then
  NOTIFY_CMD="osascript -e"
else
  echo "Sistema no soportado para notificaciones" >&2
  exit 0
fi
 
# Función para enviar notificación
send_notification() {
  local title="$1"
  local message="$2"
  local urgency="${3:-normal}"
 
  if [[ "$NOTIFY_CMD" == "notify-send" ]]; then
    notify-send -u "$urgency" "$title" "$message"
  else
    osascript -e "display notification \"$message\" with title \"$title\""
  fi
}
 
# Hook Stop: Claude terminó
if [[ "${HOOK_EVENT:-}" == "Stop" ]]; then
  # Calcular duración desde SessionStart
  if [[ -f "$CLAUDE_PROJECT_DIR/.claude/session-start" ]]; then
    start_time=$(cat "$CLAUDE_PROJECT_DIR/.claude/session-start")
    duration=$(($(date +%s) - start_time))
    send_notification "Claude Code" "Tarea completada en ${duration}s" "normal"
  else
    send_notification "Claude Code" "Claude ha terminado" "normal"
  fi
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
tool_name=$(jq -r '.tool_name')
 
# Obtener estadísticas del archivo
if [[ -f "$file_path" ]]; then
  lines=$(wc -l < "$file_path")
  size=$(du -h "$file_path" | cut -f1)
 
  notify-send "Claude Code: $tool_name" \
    "Archivo: $(basename "$file_path")\nLíneas: $lines\nTamaño: $size" \
    --icon=dialog-information
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
extension="${file_path##*.}"
 
echo "Procesando: $file_path (.$extension)" >&2
 
case "$extension" in
  ts|tsx|js|jsx)
    echo "→ Prettier + ESLint" >&2
    npx prettier --write "$file_path" 2>&1
    npx eslint --fix "$file_path" 2>&1 || true
    ;;
 
  py)
    echo "→ Black + isort + Ruff" >&2
    python -m black "$file_path" 2>&1 || true
    python -m isort "$file_path" 2>&1 || true
    python -m ruff check --fix "$file_path" 2>&1 || true
    ;;
 
  go)
    echo "→ gofmt + goimports" >&2
    gofmt -w "$file_path" 2>&1
    goimports -w "$file_path" 2>&1 || true
    ;;
 
  rs)
    echo "→ rustfmt" >&2
    rustfmt "$file_path" 2>&1 || true
    ;;
 
  java)
    echo "→ google-java-format" >&2
    google-java-format --replace "$file_path" 2>&1 || true
    ;;
 
  md)
    echo "→ Prettier (Markdown)" >&2
    npx prettier --write "$file_path" 2>&1 || true
    ;;
 
  json|yaml|yml)
    echo "→ Prettier (config files)" >&2
    npx prettier --write "$file_path" 2>&1 || true
    ;;
 
  *)
    echo "No hay formateador configurado para .$extension" >&2
    ;;
esac
 
echo "✓ Formateo completado" >&2
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
cache_dir="$CLAUDE_PROJECT_DIR/.claude/cache"
mkdir -p "$cache_dir"
 
# Calcular hash del archivo
file_hash=$(md5sum "$file_path" | cut -d' ' -f1)
cache_file="$cache_dir/$(basename "$file_path").$file_hash"
 
# Si ya formateamos este contenido, skip
if [[ -f "$cache_file" ]]; then
  echo "Cache hit, omitiendo formateo" >&2
  exit 0
fi
 
# Formatear
if [[ "$file_path" =~ \.(ts|tsx|js|jsx)$ ]]; then
  npx prettier --write "$file_path" 2>&1
fi
 
# Marcar como formateado
touch "$cache_file"
 
# Limpiar cache viejo (más de 7 días)
find "$cache_dir" -type f -mtime +7 -delete 2>/dev/null || true
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
# Configurar webhook URL (usar settings.local.json para no commitear)
SLACK_WEBHOOK_URL="${SLACK_WEBHOOK_URL:-}"
 
if [[ -z "$SLACK_WEBHOOK_URL" ]]; then
  echo "SLACK_WEBHOOK_URL no configurado" >&2
  exit 0
fi
 
# Obtener información del contexto
session_id=$(jq -r '.session_id // "unknown"')
project_name=$(basename "$CLAUDE_PROJECT_DIR")
user=$(whoami)
branch=$(git branch --show-current 2>/dev/null || echo "no-git")
 
# Construir mensaje
message="Claude Code completó tarea en *$project_name*
• Usuario: $user
• Branch: $branch
• Session: ${session_id:0:8}"
 
# Enviar a Slack
curl -X POST "$SLACK_WEBHOOK_URL" \
  -H 'Content-Type: application/json' \
  -d "{\"text\":\"$message\"}" \
  --silent --show-error \
  2>&1 || {
    echo "Fallo al enviar a Slack" >&2
    exit 0
  }
 
echo "✓ Notificación enviada a Slack" >&2
exit 0

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "SLACK_WEBHOOK_URL='https://hooks.slack.com/services/YOUR/WEBHOOK/URL' .claude/hooks/notify-slack.sh",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail
 
DISCORD_WEBHOOK_URL="${DISCORD_WEBHOOK_URL:-}"
 
if [[ -z "$DISCORD_WEBHOOK_URL" ]]; then
  exit 0
fi
 
project_name=$(basename "$CLAUDE_PROJECT_DIR")
branch=$(git branch --show-current 2>/dev/null || echo "no-git")
 
# Discord usa formato JSON diferente
payload=$(cat <<EOF
{
  "embeds": [{
    "title": "Claude Code: Tarea completada",
    "description": "Proyecto: **$project_name**\nBranch: \`$branch\`",
    "color": 5814783,
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
  }]
}
EOF
)
 
curl -X POST "$DISCORD_WEBHOOK_URL" \
  -H 'Content-Type: application/json' \
  -d "$payload" \
  --silent 2>&1 || exit 0
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
command=$(jq -r '.tool_input.command // empty')
 
# Solo validar comandos git commit
if [[ ! "$command" =~ ^git[[:space:]]+commit ]]; then
  exit 0
fi
 
echo "Validando código antes de commit..." >&2
 
# 1. Verificar que no hay archivos sensibles staged
sensitive_files=$(git diff --cached --name-only | grep -E '\.(env|pem|key|p12)$' || true)
if [[ -n "$sensitive_files" ]]; then
  echo "ERROR: Archivos sensibles detectados en stage:" >&2
  echo "$sensitive_files" >&2
  exit 2  # Bloquear commit
fi
 
# 2. Ejecutar linters en archivos staged
echo "Ejecutando linters..." >&2
staged_files=$(git diff --cached --name-only --diff-filter=ACM)
 
for file in $staged_files; do
  if [[ -f "$file" ]]; then
    case "$file" in
      *.ts|*.tsx|*.js|*.jsx)
        npx eslint "$file" 2>&1 || {
          echo "ERROR: ESLint falló en $file" >&2
          exit 2
        }
        ;;
      *.py)
        python -m ruff check "$file" 2>&1 || {
          echo "ERROR: Ruff falló en $file" >&2
          exit 2
        }
        ;;
    esac
  fi
done
 
# 3. Ejecutar tests
echo "Ejecutando tests..." >&2
npm test -- --passWithNoTests --bail 2>&1 || {
  echo "ERROR: Tests fallaron" >&2
  exit 2
}
 
echo "✓ Validación completada" >&2
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
coverage_dir="$CLAUDE_PROJECT_DIR/.claude/coverage"
mkdir -p "$coverage_dir"
 
# Solo para archivos de código
if [[ ! "$file_path" =~ \.(ts|tsx|js|jsx)$ ]]; then
  exit 0
fi
 
# Ejecutar tests con coverage
echo "Calculando cobertura..." >&2
npm test -- \
  --coverage \
  --coverageReporters=json-summary \
  --collectCoverageFrom="$file_path" \
  --passWithNoTests \
  > /dev/null 2>&1 || exit 0
 
# Leer cobertura
if [[ -f "coverage/coverage-summary.json" ]]; then
  coverage=$(jq -r '.total.lines.pct' coverage/coverage-summary.json 2>/dev/null || echo "0")
 
  # Guardar historial
  echo "$(date -Iseconds),$file_path,$coverage" >> "$coverage_dir/history.csv"
 
  # Alertar si baja de 80%
  if (( $(echo "$coverage < 80" | bc -l) )); then
    echo "⚠ Cobertura baja: ${coverage}% en $file_path" >&2
    notify-send "Claude Code: Cobertura baja" \
      "Archivo: $(basename "$file_path")\nCobertura: ${coverage}%" \
      --urgency=critical 2>/dev/null || true
  else
    echo "✓ Cobertura: ${coverage}%" >&2
  fi
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Solo documentar archivos en src/
if [[ ! "$file_path" =~ ^.*/src/.* ]]; then
  exit 0
fi
 
# Solo para archivos de código
if [[ ! "$file_path" =~ \.(ts|tsx|js|jsx|py)$ ]]; then
  exit 0
fi
 
# Generar documentación con typedoc o pydoc
if [[ "$file_path" =~ \.(ts|tsx)$ ]] && command -v typedoc > /dev/null; then
  echo "Generando documentación TypeScript..." >&2
  npx typedoc --entryPoints "$file_path" --out docs/api --skipErrorChecking 2>&1 || true
 
elif [[ "$file_path" =~ \.py$ ]] && command -v pydoc > /dev/null; then
  echo "Generando documentación Python..." >&2
  module_name=$(basename "$file_path" .py)
  pydoc -w "$module_name" 2>&1 || true
fi
 
# Actualizar README con TOC
if [[ -f "README.md" ]]; then
  echo "Actualizando tabla de contenidos..." >&2
  npx markdown-toc -i README.md 2>&1 || true
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
echo "Escaneando seguridad: $file_path" >&2
 
# 1. Buscar secretos hardcodeados
if command -v trufflehog > /dev/null; then
  trufflehog filesystem "$file_path" --json 2>&1 | \
    jq -r 'select(.Verified == true) | "⚠ SECRET ENCONTRADO: \(.DetectorName)"' || true
fi
 
# 2. Escanear vulnerabilidades conocidas
case "$file_path" in
  *.py)
    if command -v bandit > /dev/null; then
      bandit -r "$file_path" -f json 2>&1 | \
        jq -r '.results[] | select(.issue_severity == "HIGH" or .issue_severity == "CRITICAL") |
          "⚠ \(.issue_severity): \(.issue_text)"' || true
    fi
    ;;
 
  *.js|*.ts)
    if [[ -f "package.json" ]]; then
      npm audit --json 2>&1 | \
        jq -r '.vulnerabilities | to_entries[] | select(.value.severity == "high" or .value.severity == "critical") |
          "⚠ \(.value.severity): \(.key)"' || true
    fi
    ;;
esac
 
# 3. Verificar que no hay eval() o exec()
if grep -nE '(eval\(|exec\(|system\(|shell_exec)' "$file_path" 2>/dev/null; then
  echo "⚠ Funciones peligrosas detectadas en $file_path" >&2
fi
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
# Este wrapper ejecuta otro hook y mide su tiempo
TARGET_HOOK="${1:-}"
THRESHOLD_SECONDS="${2:-5}"
 
if [[ -z "$TARGET_HOOK" ]]; then
  echo "Uso: performance-wrapper.sh <hook-script> [threshold-seconds]" >&2
  exit 1
fi
 
# Leer JSON de stdin y guardarlo
json_input=$(cat)
 
# Ejecutar hook con timing
start=$(date +%s.%N)
echo "$json_input" | "$TARGET_HOOK"
exit_code=$?
end=$(date +%s.%N)
 
# Calcular duración
duration=$(echo "$end - $start" | bc)
 
# Registrar performance
perf_log="$CLAUDE_PROJECT_DIR/.claude/performance.log"
echo "$(date -Iseconds),$TARGET_HOOK,$duration,$exit_code" >> "$perf_log"
 
# Alertar si excede el threshold
if (( $(echo "$duration > $THRESHOLD_SECONDS" | bc -l) )); then
  echo "⚠ Hook lento detectado: $TARGET_HOOK tomó ${duration}s" >&2
  notify-send "Claude Code: Hook lento" \
    "Hook: $(basename "$TARGET_HOOK")\nDuración: ${duration}s" \
    --urgency=normal 2>/dev/null || true
fi
 
exit $exit_code

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/performance-wrapper.sh .claude/hooks/format.sh 3",
            "timeout": 90
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail
 
state_file="$CLAUDE_PROJECT_DIR/.claude/state.json"
 
# Inicializar estado si no existe
if [[ ! -f "$state_file" ]]; then
  echo '{"files_modified": 0, "files_created": 0, "total_lines": 0}' > "$state_file"
fi
 
# Leer estado actual
files_modified=$(jq -r '.files_modified' "$state_file")
files_created=$(jq -r '.files_created' "$state_file")
total_lines=$(jq -r '.total_lines' "$state_file")
 
# Procesar evento actual
file_path=$(jq -r '.tool_input.file_path')
tool_name=$(jq -r '.tool_name')
 
if [[ "$tool_name" == "Write" ]] && [[ ! -f "$file_path" ]]; then
  files_created=$((files_created + 1))
elif [[ "$tool_name" == "Edit" ]]; then
  files_modified=$((files_modified + 1))
fi
 
# Contar líneas
if [[ -f "$file_path" ]]; then
  lines=$(wc -l < "$file_path")
  total_lines=$((total_lines + lines))
fi
 
# Guardar estado actualizado
jq -n \
  --arg fm "$files_modified" \
  --arg fc "$files_created" \
  --arg tl "$total_lines" \
  '{files_modified: ($fm|tonumber), files_created: ($fc|tonumber), total_lines: ($tl|tonumber)}' \
  > "$state_file"
 
echo "📊 Estadísticas: $files_modified editados, $files_created creados, $total_lines líneas totales" >&2
exit 0

cat .claude/state.json | jq

#!/usr/bin/env bash
set -euo pipefail
 
file_path=$(jq -r '.tool_input.file_path')
 
# Condición 1: Solo ejecutar en branch main/master
current_branch=$(git branch --show-current 2>/dev/null || echo "unknown")
if [[ ! "$current_branch" =~ ^(main|master)$ ]]; then
  echo "No estás en main/master, omitiendo tests exhaustivos" >&2
  exit 0
fi
 
# Condición 2: Solo archivos críticos
if [[ ! "$file_path" =~ (src/core|src/auth|src/payment) ]]; then
  echo "No es código crítico, omitiendo tests exhaustivos" >&2
  exit 0
fi
 
# Condición 3: Solo durante horario laboral
hour=$(date +%H)
if (( hour < 9 || hour > 18 )); then
  echo "Fuera de horario laboral, omitiendo tests lentos" >&2
  exit 0
fi
 
# Ejecutar tests completos
echo "Ejecutando suite completa de tests..." >&2
npm test -- --coverage 2>&1 || exit 0
 
exit 0

#!/usr/bin/env bash
set -euo pipefail
 
# Trap para cleanup
cleanup() {
  local exit_code=$?
  echo "Limpiando recursos..." >&2
  # Cleanup aquí
  exit $exit_code
}
trap cleanup EXIT
 
# Tu código aquí

# Ejecutar comando con timeout interno
timeout 30s npm test || {
  echo "Timeout alcanzado" >&2
  exit 0
}

log() {
  local level="$1"
  shift
  echo "$(date -Iseconds) [$level] $*" >> "$CLAUDE_PROJECT_DIR/.claude/hooks.log"
}
 
log INFO "Iniciando hook"
log ERROR "Algo falló"

# test-hook.sh
#!/usr/bin/env bash
 
# Simular entrada JSON
test_input='{"tool_input": {"file_path": "/tmp/test.ts"}, "tool_name": "Write"}'
 
# Ejecutar hook
echo "$test_input" | .claude/hooks/your-hook.sh
 
# Verificar resultado
if [[ $? -eq 0 ]]; then
  echo "✓ Test pasó"
else
  echo "✗ Test falló"
  exit 1
fi

#!/usr/bin/env bash
set -euo pipefail
 
# =============================================================================
# Hook: [Nombre del hook]
# Descripción: [Qué hace este hook]
# =============================================================================
 
# --- Configuración ---
TIMEOUT=30
LOG_FILE="$CLAUDE_PROJECT_DIR/.claude/hook-name.log"
 
# --- Funciones auxiliares ---
log() {
  echo "$(date -Iseconds) [$1] ${*:2}" | tee -a "$LOG_FILE" >&2
}
 
cleanup() {
  log INFO "Limpiando recursos"
  # Cleanup aquí
}
trap cleanup EXIT
 
# --- Validación de entrada ---
if ! jq -e . >/dev/null 2>&1; then
  log ERROR "JSON de entrada inválido"
  exit 1
fi
 
# --- Extracción de datos ---
file_path=$(jq -r '.tool_input.file_path // empty')
tool_name=$(jq -r '.tool_name // empty')
 
if [[ -z "$file_path" ]]; then
  log WARN "file_path no disponible"
  exit 0
fi
 
# --- Validaciones condicionales ---
if [[ ! -f "$file_path" ]]; then
  log WARN "Archivo no existe: $file_path"
  exit 0
fi
 
# Solo procesar ciertos tipos de archivos
if [[ ! "$file_path" =~ \.(ts|tsx|js|jsx)$ ]]; then
  log INFO "Tipo de archivo no soportado: $file_path"
  exit 0
fi
 
# --- Lógica principal ---
log INFO "Procesando: $file_path"
 
# Tu código aquí
# ...
 
log INFO "Completado exitosamente"
exit 0

# Ver últimos logs
tail -f .claude/hooks.log
 
# Ver solo errores
grep ERROR .claude/hooks.log
 
# Ver estadísticas de performance
sort -t, -k3 -n .claude/performance.log | tail -10

# Crear JSON de prueba
cat > /tmp/test-input.json <<EOF
{
  "tool_input": {
    "file_path": "/ruta/a/archivo.ts",
    "command": "npm test"
  },
  "tool_name": "Write",
  "session_id": "test-session"
}
EOF
 
# Ejecutar hook
cat /tmp/test-input.json | .claude/hooks/your-hook.sh

Hook inicia ejecución
      ↓
Pasan 10 segundos
      ↓
Pasan 30 segundos
      ↓
Pasan 60 segundos (timeout alcanzado)
      ↓
Hook es terminado con SIGTERM
      ↓
Si no responde en 5 segundos → SIGKILL
      ↓
Claude Code continúa

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "./script.sh"
            // timeout: 600 (default implícito)
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "./script.sh",
            "timeout": 30  // 30 segundos
          }
        ]
      }
    ]
  }
}

# Durante sesión, presiona Ctrl+O para modo verbose
# Verás output de hooks en tiempo real

# Ver hooks más lentos
cat .claude/performance.log | sort -t, -k3 -rn | head -10
 
# Ver promedio de duración
awk -F, '{sum+=$3; count++} END {print "Promedio:", sum/count "s"}' .claude/performance.log

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {"type": "command", "command": "npm run format", "timeout": 60},
          {"type": "command", "command": "npm run lint", "timeout": 120},
          {"type": "command", "command": "npm test", "timeout": 300},
          {"type": "command", "command": "npm run build", "timeout": 600}
        ]
      }
    ]
  }
}