claude-git-hooks 1.5.1 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-git-hooks",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Git hooks con Claude CLI para análisis de código y generación automática de mensajes de commit",
   "main": "lib/index.js",
   "bin": {

package/templates/pre-commit

@@ -1,23 +1,23 @@
 #!/bin/bash
 
-# Git Pre-commit Hook para evaluación de código con Claude CLI
+# Git Pre-commit Hook for code evaluation with Claude CLI
 # Archivo: .git/hooks/pre-commit
 
 set -e
 
-# Configuración
+# Configuration
 CLAUDE_CLI="claude"
 TEMP_DIR="/tmp/code-review-$$"
-MAX_FILE_SIZE=100000  # 100KB máximo por archivo
+MAX_FILE_SIZE=100000  # 100KB maximum per file
 
-# Colores para output
+# Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
-# Función para logging
+# Function for logging
 log() {
     echo -e "${GREEN}[PRE-COMMIT]${NC} $1"
 }
@@ -30,10 +30,10 @@ warning() {
     echo -e "${YELLOW}[WARNING]${NC} $1"
 }
 
-# Verificar versión al inicio (antes de cualquier análisis)
-# Intentar encontrar el script check-version.sh
+# Check version at start (before any analysis)
+# Try to find the check-version.sh script
 CHECK_VERSION_SCRIPT=""
-# Buscar en múltiples ubicaciones posibles
+# Search in multiple possible locations
 SCRIPT_PATHS=(
     "$(dirname "$0")/check-version.sh"
     "/usr/local/lib/node_modules/claude-git-hooks/templates/check-version.sh"
@@ -49,37 +49,37 @@ for path in "${SCRIPT_PATHS[@]}"; do
     fi
 done
 
-# Si encontramos el script, ejecutarlo
+# If we find the script, execute it
 if [ -n "$CHECK_VERSION_SCRIPT" ]; then
-    # Source el script para tener acceso a la función
+    # Source the script to have access to the function
     source "$CHECK_VERSION_SCRIPT"
     check_version
 fi
 
-# Función para generar prompt de resolución AI-friendly
+# Function to generate AI-friendly resolution prompt
 generate_resolution_prompt() {
     local RESOLUTION_FILE="./claude_resolution_prompt.md"
     local RESOLUTION_TEMPLATE=".claude/CLAUDE_RESOLUTION_PROMPT.md"
     
     if [ ! -f "$RESOLUTION_TEMPLATE" ]; then
-        warning "No se encontró template de resolución: $RESOLUTION_TEMPLATE"
+        warning "Resolution template not found: $RESOLUTION_TEMPLATE"
         return
     fi
     
-    # Obtener información del contexto
+    # Get context information
     local REPO_NAME=$(basename $(git rev-parse --show-toplevel))
     local BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
     local COMMIT_SHA="pending"
     local FILE_COUNT=$(echo "$JAVA_FILES" | wc -l)
     
-    # Formatear los blocking issues para el prompt de resolución
+    # Format the blocking issues for the resolution prompt
     local ISSUES_FORMATTED=""
     local issue_num=1
     
-    # Usar un archivo temporal para acumular los issues
+    # Use a temporary file to accumulate the issues
     local TEMP_ISSUES=$(mktemp)
     
-    # Parsear cada blocking issue como objeto JSON
+    # Parse each blocking issue as JSON object
     echo "$JSON_RESPONSE" | jq -c '.blockingIssues[]?' 2>/dev/null | while IFS= read -r issue; do
         if [ -n "$issue" ]; then
             local desc=$(echo "$issue" | jq -r '.description')
@@ -97,31 +97,31 @@ generate_resolution_prompt() {
         fi
     done
     
-    # Leer el contenido acumulado
+    # Read the accumulated content
     ISSUES_FORMATTED=$(cat "$TEMP_ISSUES")
     rm -f "$TEMP_ISSUES"
     
-    # Generar el prompt desde el template
+    # Generate the prompt from the template
     cp "$RESOLUTION_TEMPLATE" "$RESOLUTION_FILE"
     
-    # Reemplazar placeholders - usar comillas dobles y escapar caracteres especiales
+    # Replace placeholders - use double quotes and escape special characters
     sed -i "s|{{REPO_NAME}}|${REPO_NAME}|g" "$RESOLUTION_FILE"
     sed -i "s|{{BRANCH_NAME}}|${BRANCH_NAME}|g" "$RESOLUTION_FILE"
     sed -i "s|{{COMMIT_SHA}}|${COMMIT_SHA}|g" "$RESOLUTION_FILE"
     sed -i "s|{{FILE_COUNT}}|${FILE_COUNT}|g" "$RESOLUTION_FILE"
     
-    # Crear archivo temporal para issues formateados
+    # Create temporary file for formatted issues
     local TEMP_ISSUES_FILE=$(mktemp)
     echo "$ISSUES_FORMATTED" > "$TEMP_ISSUES_FILE"
     
-    # Reemplazar {{BLOCKING_ISSUES}} con el contenido
+    # Replace {{BLOCKING_ISSUES}} with content
     if [ -n "$ISSUES_FORMATTED" ]; then
         sed -i "/{{BLOCKING_ISSUES}}/r $TEMP_ISSUES_FILE" "$RESOLUTION_FILE"
     fi
     sed -i "s|{{BLOCKING_ISSUES}}||g" "$RESOLUTION_FILE"
     rm -f "$TEMP_ISSUES_FILE"
     
-    # Agregar contenido de archivos afectados
+    # Add content from affected files
     local TEMP_FILES=$(mktemp)
     echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].file' 2>/dev/null | sort -u | while IFS= read -r file; do
         if [ -f "$file" ]; then
@@ -134,7 +134,7 @@ generate_resolution_prompt() {
         fi
     done
     
-    # Reemplazar {{FILE_CONTENTS}} con el contenido
+    # Replace {{FILE_CONTENTS}} with content
     if [ -s "$TEMP_FILES" ]; then
         sed -i "/{{FILE_CONTENTS}}/r $TEMP_FILES" "$RESOLUTION_FILE"
     fi
@@ -142,62 +142,62 @@ generate_resolution_prompt() {
     rm -f "$TEMP_FILES"
     
     echo
-    echo -e "${YELLOW}=== PROMPT DE RESOLUCIÓN AI GENERADO ===${NC}"
-    echo -e "${GREEN}Se ha generado un prompt AI-friendly en: ${BLUE}$RESOLUTION_FILE${NC}"
-    echo -e "${YELLOW}Copia este archivo a una nueva instancia de Claude para resolver los problemas automáticamente.${NC}"
+    echo -e "${YELLOW}=== AI RESOLUTION PROMPT GENERATED ===${NC}"
+    echo -e "${GREEN}An AI-friendly prompt has been generated at: ${BLUE}$RESOLUTION_FILE${NC}"
+    echo -e "${YELLOW}Copy this file to a new Claude instance to resolve problems automatically.${NC}"
     echo
 }
 
-# Configurar archivos para modo SonarQube
+# Configure files for SonarQube mode
 GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
 PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
 
 
-# Verificar que el template de prompt existe
+# Check that the prompt template exists
 if [ ! -f "$PROMPT_TEMPLATE" ]; then
-    error "No se encontró el template de prompt: $PROMPT_TEMPLATE"
-    error "Los archivos de configuración de Claude parecen estar incompletos."
-    error "Por favor, reinstala claude-git-hooks ejecutando:"
+    error "Prompt template not found: $PROMPT_TEMPLATE"
+    error "Claude configuration files appear to be incomplete."
+    error "Please reinstall claude-git-hooks by running:"
     error "  claude-hooks install --force"
     exit 1
 fi
-# Función para limpiar archivos temporales
+# Function to clean temporary files
 cleanup() {
     rm -rf "$TEMP_DIR"
 }
 
-# Configurar limpieza al salir
+# Configure cleanup on exit
 trap cleanup EXIT
 
-# Crear directorio temporal
+# Create temporary directory
 mkdir -p "$TEMP_DIR"
 
-# Verificar si Claude CLI está instalado (solo para análisis de código)
+# Check if Claude CLI is installed (only for code analysis)
 if ! command -v "$CLAUDE_CLI" &> /dev/null; then
-    error "Claude CLI no está instalado o no se encuentra en el PATH"
-    error "Instala Claude CLI desde: https://github.com/anthropics/claude-cli"
+    error "Claude CLI is not installed or not found in PATH"
+    error "Install Claude CLI from: https://github.com/anthropics/claude-cli"
     exit 1
 fi
 
-# Ahora verificar si hay archivos Java para analizar
+# Now check if there are Java files to analyze
 JAVA_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(java|xml|properties|yml|yaml)$' || true)
 
 if [ -z "$JAVA_FILES" ]; then
-    log "No hay archivos Java/configuración para revisar"
+    log "No Java/configuration files to review"
     exit 0
 fi
 
-# Verificar si existe el archivo de pautas
+# Check if the guidelines file exists
 if [ ! -f "$GUIDELINES_FILE" ]; then
-    error "No se encontró el archivo de pautas: $GUIDELINES_FILE"
-    error "Por favor, reinstala claude-git-hooks ejecutando:"
+    error "Guidelines file not found: $GUIDELINES_FILE"
+    error "Please reinstall claude-git-hooks by running:"
     error "  claude-hooks install --force"
     exit 1
 fi
 
-log "Archivos Java/config a revisar: $(echo "$JAVA_FILES" | wc -l)"
+log "Java/config files to review: $(echo "$JAVA_FILES" | wc -l)"
 
-# Función para filtrar contenido con SKIP-ANALYSIS
+# Function to filter content with SKIP-ANALYSIS
 filter_skip_analysis() {
     local file_content="$1"
     local filtered_content=""
@@ -205,77 +205,77 @@ filter_skip_analysis() {
     local inside_skip_block=false
     
     while IFS= read -r line; do
-        # Detectar SKIP-ANALYSIS para línea única
+        # Detect SKIP-ANALYSIS for single line
         if echo "$line" | grep -q "// SKIP-ANALYSIS"; then
             skip_next_line=true
             continue
         fi
         
-        # Detectar inicio/fin de bloque SKIP_ANALYSIS_BLOCK
+        # Detect start/end of SKIP_ANALYSIS_BLOCK
         if echo "$line" | grep -q "// SKIP_ANALYSIS_BLOCK"; then
             if [ "$inside_skip_block" = true ]; then
-                # Fin del bloque
+                # End of block
                 inside_skip_block=false
             else
-                # Inicio del bloque
+                # Start of block
                 inside_skip_block=true
             fi
             continue
         fi
         
-        # Si estamos dentro de un bloque, saltar la línea
+        # If we're inside a block, skip the line
         if [ "$inside_skip_block" = true ]; then
             continue
         fi
         
-        # Si debemos saltar la siguiente línea (comentario único)
+        # If we should skip the next line (single comment)
         if [ "$skip_next_line" = true ]; then
             skip_next_line=false
             continue
         fi
         
-        # Agregar línea al contenido filtrado
+        # Add line to filtered content
         filtered_content="${filtered_content}${line}"$'\n'
     done <<< "$file_content"
     
     echo "$filtered_content"
 }
 
-# Construir el prompt para análisis de código
+# Build the prompt for code analysis
 PROMPT_FILE="$TEMP_DIR/code_review_prompt.txt"
 
-# Copiar el template de prompt
+# Copy the prompt template
 cat "$PROMPT_TEMPLATE" > "$PROMPT_FILE"
 
-# Agregar las pautas
-echo "=== PAUTAS DE EVALUACIÓN ===" >> "$PROMPT_FILE"
+# Add the guidelines
+echo "=== EVALUATION GUIDELINES ===" >> "$PROMPT_FILE"
 cat "$GUIDELINES_FILE" >> "$PROMPT_FILE"
-echo -e "\n\n=== CAMBIOS A REVISAR ===\n" >> "$PROMPT_FILE"
+echo -e "\n\n=== CHANGES TO REVIEW ===\n" >> "$PROMPT_FILE"
 
-# Procesar cada archivo Java
+# Process each Java file
 FILE_COUNT=0
 for FILE in $JAVA_FILES; do
     if [ -f "$FILE" ]; then
         FILE_SIZE=$(stat -c%s "$FILE" 2>/dev/null || stat -f%z "$FILE" 2>/dev/null || echo "0")
         
         if [ "$FILE_SIZE" -gt "$MAX_FILE_SIZE" ]; then
-            warning "Archivo $FILE demasiado grande ($FILE_SIZE bytes), saltando..."
+            warning "File $FILE too large ($FILE_SIZE bytes), skipping..."
             continue
         fi
         
         echo -e "\n--- Archivo: $FILE ---" >> "$PROMPT_FILE"
         
-        # Obtener el diff y filtrarlo
-        DIFF_CONTENT=$(git diff --cached "$FILE" 2>/dev/null || echo "No se pudo obtener diff")
+        # Get the diff and filter it
+        DIFF_CONTENT=$(git diff --cached "$FILE" 2>/dev/null || echo "Could not get diff")
         FILTERED_DIFF=$(filter_skip_analysis "$DIFF_CONTENT")
         
-        # Mostrar el diff filtrado del archivo
+        # Show the filtered diff of the file
         echo -e "\nDiff:" >> "$PROMPT_FILE"
         echo "$FILTERED_DIFF" >> "$PROMPT_FILE"
         
-        # Si es un archivo nuevo, mostrar contenido completo filtrado
+        # If it's a new file, show complete filtered content
         if git diff --cached --name-status | grep "^A.*$FILE" > /dev/null; then
-            echo -e "\nContenido completo (archivo nuevo):" >> "$PROMPT_FILE"
+            echo -e "\nComplete content (new file):" >> "$PROMPT_FILE"
             FILE_CONTENT=$(git show ":$FILE" 2>/dev/null || cat "$FILE")
             FILTERED_CONTENT=$(filter_skip_analysis "$FILE_CONTENT")
             echo "$FILTERED_CONTENT" >> "$PROMPT_FILE"
@@ -286,45 +286,45 @@ for FILE in $JAVA_FILES; do
 done
 
 if [ "$FILE_COUNT" -eq 0 ]; then
-    log "No se encontraron archivos válidos para revisar"
+    log "No valid files found to review"
     exit 0
 fi
 
 if [ "$FILE_COUNT" -gt 10 ]; then
-    warning "Demasiados archivos para revisar ($FILE_COUNT)"
-    warning "Considera dividir el commit en partes más pequeñas"
+    warning "Too many files to review ($FILE_COUNT)"
+    warning "Consider splitting the commit into smaller parts"
     exit 0
 fi
 
-log "Enviando $FILE_COUNT archivos para revisión con Claude..."
+log "Sending $FILE_COUNT files for review with Claude..."
 
-# Enviar a Claude y capturar respuesta
+# Send to Claude and capture response
 RESPONSE_FILE="$TEMP_DIR/code_review_response.txt"
 
-# Ejecutar Claude CLI y capturar la respuesta
+# Execute Claude CLI and capture the response
 if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
-    # Extraer el JSON de la respuesta
+    # Extract the JSON from the response
     JSON_RESPONSE=$(sed -n '/^{/,/^}/p' "$RESPONSE_FILE" | head -n 1000)
     
     if [ -z "$JSON_RESPONSE" ]; then
-        error "No se recibió una respuesta JSON válida de Claude"
-        error "Respuesta completa:"
+        error "Did not receive a valid JSON response from Claude"
+        error "Complete response:"
         cat "$RESPONSE_FILE"
         exit 1
     fi
     
-    # Guardar JSON para debug si está activado
+    # Save JSON for debug if activated
     if [ -n "$DEBUG" ]; then
         echo "$JSON_RESPONSE" > ./debug-claude-response.json
-        log "Respuesta guardada en debug-claude-response.json"
+        log "Response saved to debug-claude-response.json"
     fi
     
-    # Parsear la respuesta usando jq
+    # Parse the response using jq
     APPROVED=$(echo "$JSON_RESPONSE" | jq -r '.approved // false')
     SCORE=$(echo "$JSON_RESPONSE" | jq -r '.score // 0')
     RECOMMENDATIONS=$(echo "$JSON_RESPONSE" | jq -r '.recommendations[]?' 2>/dev/null | sed '/^$/d')
     
-    # Parsear blockingIssues como objetos y extraer las descripciones
+    # Parse blockingIssues as objects and extract descriptions
     BLOCKING_ISSUES=""
     BLOCKING_COUNT=$(echo "$JSON_RESPONSE" | jq '.blockingIssues | length' 2>/dev/null || echo "0")
     
@@ -335,7 +335,7 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
     QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.QUALITY_GATE // ""' 2>/dev/null)
     
     if [ -n "$QUALITY_GATE" ] && [ "$QUALITY_GATE" != "null" ]; then
-        # Mostrar resultados estilo SonarQube
+        # Show SonarQube style results
         echo
         echo "╔════════════════════════════════════════════════════════════════════╗"
         echo "║                     CODE QUALITY ANALYSIS                           ║"
@@ -410,51 +410,51 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
         echo
         log "✅ Code analysis completed. Quality gate passed."
     else
-        # Mostrar resultados en formato clásico
+        # Show results in classic format
         echo
-        echo "=== RESULTADO DE LA REVISIÓN ==="
+        echo "=== REVIEW RESULTS ==="
         echo "Score: $SCORE/10"
         
         if [ -n "$RECOMMENDATIONS" ] && [ "$RECOMMENDATIONS" != "null" ]; then
             echo
-            echo "=== RECOMENDACIONES ==="
+            echo "=== RECOMMENDATIONS ==="
             echo "$RECOMMENDATIONS" | sed 's/^/- /'
         fi
         
-        # Verificar si el commit debe ser bloqueado
+        # Check if the commit should be blocked
         if [ "$APPROVED" = "false" ]; then
-            error "❌ Commit rechazado por problemas críticos"
+            error "❌ Commit rejected due to critical issues"
             if [ -n "$BLOCKING_ISSUES" ] && [ "$BLOCKING_ISSUES" != "null" ]; then
                 echo
-                echo "=== PROBLEMAS CRÍTICOS ==="
+                echo "=== CRITICAL ISSUES ==="
                 echo "$BLOCKING_ISSUES" | sed 's/^/- /'
                 
-                # Generar prompt de resolución AI-friendly
+                # Generate AI-friendly resolution prompt
                 generate_resolution_prompt
             fi
             exit 1
         fi
 
-        # Mostrar detalles adicionales si existen
+        # Show additional details if they exist
         DETAILS=$(echo "$JSON_RESPONSE" | jq -r '.details // null')
         if [ -n "$DETAILS" ] && [ "$DETAILS" != "null" ]; then
             echo
-            echo "=== DETALLES ADICIONALES ==="
-            # Si details es un string, imprimirlo directamente
+            echo "=== ADDITIONAL DETAILS ==="
+            # If details is a string, print it directly
             if echo "$DETAILS" | jq -e 'type == "string"' >/dev/null 2>&1; then
                 echo "$DETAILS" | jq -r '.'
-            # Si es un objeto o array, formatearlo
+            # If it's an object or array, format it
             else
                 echo "$DETAILS" | jq '.'
             fi
         fi
         
-        log "✅ Revisión completada. Commit aprobado (Score: $SCORE/10)"
+        log "✅ Review completed. Commit approved (Score: $SCORE/10)"
     fi
     
 else
-    error "Error al ejecutar Claude CLI"
-    error "Verifica que Claude CLI esté configurado correctamente"
+    error "Error executing Claude CLI"
+    error "Check that Claude CLI is configured correctly"
     cat "$RESPONSE_FILE"
     exit 1
 fi

package/templates/prepare-commit-msg

@@ -1,23 +1,23 @@
 #!/bin/bash
 
-# Git Prepare-commit-msg Hook para generar mensajes automáticos con Claude
+# Git Prepare-commit-msg Hook to generate automatic messages with Claude
 # Archivo: .git/hooks/prepare-commit-msg
 
 set -e
 
-# Configuración
+# Configuration
 CLAUDE_CLI="claude"
 TEMP_DIR="/tmp/commit-msg-$$"
 MAX_FILE_SIZE=100000
 AUTO_COMMIT_ENABLED=true
 
-# Colores para output
+# Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m'
 
-# Función para logging
+# Function for logging
 log() {
     printf "${GREEN}[PREPARE-MSG]${NC} %s\n" "$1" >&2
 }
@@ -26,35 +26,35 @@ warning() {
     printf "${YELLOW}[WARNING]${NC} %s\n" "$1" >&2
 }
 
-# Función para limpiar archivos temporales
+# Function to clean temporary files
 cleanup() {
     rm -rf "$TEMP_DIR"
 }
 trap cleanup EXIT
 
-# Argumentos del hook
+# Hook arguments
 COMMIT_MSG_FILE="$1"
 COMMIT_SOURCE="$2"
 
-# Solo procesar si es un commit normal
+# Only process if it's a normal commit
 if [ "$COMMIT_SOURCE" != "" ] && [ "$COMMIT_SOURCE" != "message" ]; then
     exit 0
 fi
 
-# Leer el mensaje actual
+# Read the current message
 CURRENT_MSG=$(head -n 1 "$COMMIT_MSG_FILE" 2>/dev/null || echo "")
 
-# Verificar si necesitamos generar mensaje
+# Check if we need to generate a message
 if [ "$CURRENT_MSG" = "auto" ]; then
-    log "Intentando generar mensaje..."
+    log "Trying to generate message..."
 else
     exit 0
 fi
 
-# Verificar si Claude CLI está instalado
+# Check if Claude CLI is installed
 if ! command -v "$CLAUDE_CLI" &> /dev/null; then
-    warning "Claude CLI no está instalado"
-    warning "Commit cancelado. Ejecuta nuevamente sin 'auto' para escribir mensaje manual"
+    warning "Claude CLI is not installed"
+    warning "Commit canceled. Run again without 'auto' to write manual message"
     exit 1
 fi
 
@@ -62,49 +62,49 @@ mkdir -p "$TEMP_DIR"
 PROMPT_FILE="$TEMP_DIR/commit_msg_prompt.txt"
 
 cat > "$PROMPT_FILE" << 'EOF'
-Analiza los siguientes cambios y genera un mensaje de commit siguiendo el formato Conventional Commits.
+Analyze the following changes and generate a commit message following the Conventional Commits format.
 
-Responde SOLO con un JSON válido:
+Respond ONLY with a valid JSON:
 
 {
   "type": "feat|fix|docs|style|refactor|test|chore|ci|perf",
-  "scope": "alcance opcional (ej: api, frontend, db)",
-  "title": "descripción corta en presente (max 50 chars)",
-  "body": "descripción detallada opcional"
+  "scope": "optional scope (e.g.: api, frontend, db)",
+  "title": "short description in present tense (max 50 chars)",
+  "body": "optional detailed description"
 }
 
-CAMBIOS A ANALIZAR:
+CHANGES TO ANALYZE:
 EOF
 
-# Obtener archivos staged
+# Get staged files
 ALL_STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM 2>/dev/null || echo "")
 
 if [ -z "$ALL_STAGED_FILES" ]; then
-    warning "No hay archivos staged"
-    warning "Commit cancelado. Ejecuta nuevamente sin 'auto' para escribir mensaje manual"
+    warning "No staged files"
+    warning "Commit canceled. Run again without 'auto' to write manual message"
     exit 1
 fi
 
-printf "\nArchivos modificados:\n" >> "$PROMPT_FILE"
+printf "\nModified files:\n" >> "$PROMPT_FILE"
 echo "$ALL_STAGED_FILES" >> "$PROMPT_FILE"
 
-printf "\nResumen de cambios:\n" >> "$PROMPT_FILE"
-git diff --cached --stat >> "$PROMPT_FILE" 2>/dev/null || echo "No se pudo obtener estadísticas"
+printf "\nSummary of changes:\n" >> "$PROMPT_FILE"
+git diff --cached --stat >> "$PROMPT_FILE" 2>/dev/null || echo "Could not get statistics"
 
-# Mostrar diffs de archivos pequeños
+# Show diffs of small files
 for FILE in $ALL_STAGED_FILES; do
     if [ -f "$FILE" ]; then
         FILE_SIZE=$(stat -c%s "$FILE" 2>/dev/null || stat -f%z "$FILE" 2>/dev/null || echo "0")
         
         if [ "$FILE_SIZE" -lt "$MAX_FILE_SIZE" ]; then
-            printf "\n--- Diff de %s ---\n" "$FILE" >> "$PROMPT_FILE"
-            git diff --cached "$FILE" >> "$PROMPT_FILE" 2>/dev/null || echo "No se pudo obtener diff"
+            printf "\n--- Diff of %s ---\n" "$FILE" >> "$PROMPT_FILE"
+            git diff --cached "$FILE" >> "$PROMPT_FILE" 2>/dev/null || echo "Could not get diff"
         fi
     fi
 done
 
 RESPONSE_FILE="$TEMP_DIR/commit_msg_response.txt"
-log "Generando mensaje de commit con Claude..."
+log "Generating commit message with Claude..."
 
 if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
     JSON_MSG=$(sed -n '/^{/,/^}/p' "$RESPONSE_FILE" | head -n 1000)
@@ -127,12 +127,12 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
             fi
             
             printf "%s\n" "$FULL_MESSAGE" > "$COMMIT_MSG_FILE"
-            log "📝 Mensaje generado: $(echo "$FULL_MESSAGE" | head -n 1)"
+            log "📝 Message generated: $(echo "$FULL_MESSAGE" | head -n 1)"
             exit 0
         fi
     fi
 fi
 
-warning "No se pudo generar el mensaje automáticamente con Claude"
-warning "Commit cancelado. Ejecuta nuevamente sin 'auto' para escribir mensaje manual"
+warning "Could not generate message automatically with Claude"
+warning "Commit canceled. Run again without 'auto' to write manual message"
 exit 1