claude-git-hooks 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pablo Rovito
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,355 @@
+# Pre-commit Hook con Claude CLI
+
+Este directorio contiene un pre-commit hook que utiliza Claude CLI para revisar automáticamente el código antes de cada commit.
+
+## 📁 Archivos en este Directorio
+
+- **`README.md`** - Esta documentación
+- **`pre-commit`** - Hook principal para análisis de código (con auto-actualización)
+- **`prepare-commit-msg`** - Hook para generar mensajes de commit automáticos
+- **`setup-wsl.sh`** - Script de instalación inicial para WSL
+- **`.gitattributes`** - Configuración para mantener line endings correctos
+- **`CLAUDE_PRE_COMMIT.md`** - Pautas de evaluación formato estándar
+- **`CLAUDE_PRE_COMMIT_SONAR.md`** - Pautas de evaluación formato SonarQube
+
+## 🔧 Configuración Previa Importante
+
+### 1. Armonización de Line Endings (EOL)
+
+Debido a que Claude CLI corre en WSL y el desarrollo puede hacerse en Windows, es crucial configurar correctamente los line endings para evitar que los archivos de hooks se corrompan:
+
+```bash
+# IMPORTANTE: Usar la misma configuración en WSL y Windows
+# Recomendación: usar 'input' en ambos entornos
+
+# En WSL
+git config core.autocrlf input
+
+# En PowerShell/Windows
+git config core.autocrlf input
+
+# Verificar configuración actual
+git config --local core.autocrlf
+git config --global core.autocrlf
+```
+
+**⚠️ ADVERTENCIA**: Si tienes `core.autocrlf = true` en local e `input` en global, esto puede causar que los archivos de los hooks se vacíen. Asegúrate de que ambas configuraciones sean consistentes.
+
+### 2. Credenciales Git en WSL
+
+Debes configurar tus credenciales de git nuevamente en WSL:
+
+```bash
+# En WSL
+git config --global user.name "Tu Nombre"
+git config --global user.email "tu.email@ejemplo.com"
+
+# Si usas AWS CodeCommit o similar, reconfigura las credenciales
+git config --global credential.helper store
+# O configura tu credential helper específico
+```
+
+## 🚀 Instalación Rápida (WSL)
+
+**IMPORTANTE**: Claude CLI corre en WSL, por lo que toda la instalación y uso de git debe hacerse desde la terminal WSL.
+
+```bash
+# Desde WSL - Instalación completa
+./git-hooks/setup-wsl.sh
+
+# Ver opciones disponibles
+./git-hooks/setup-wsl.sh --help
+
+# Solo sincronizar hooks (útil después de modificar archivos fuente)
+./git-hooks/setup-wsl.sh --sync
+
+# Habilitar/deshabilitar hooks
+./git-hooks/setup-wsl.sh --enable-hooks          # Habilita todos los hooks
+./git-hooks/setup-wsl.sh --disable-hooks         # Deshabilita todos los hooks
+./git-hooks/setup-wsl.sh --enable-hooks pre-commit   # Habilita solo pre-commit
+./git-hooks/setup-wsl.sh --disable-hooks prepare-commit-msg  # Deshabilita solo prepare-commit-msg
+```
+
+**✨ Auto-actualización incorporada**: Los hooks se actualizan automáticamente en cada commit.
+
+**🤖 Hooks instalados**:
+
+- `pre-commit`: Análisis de código con Claude (solo archivos Java/config)
+- `prepare-commit-msg`: Generación automática de mensajes de commit
+
+
+## 🎯 Funcionamiento
+
+### Hook pre-commit (Análisis de código)
+
+1. **Intercepta cada intento de commit** (en WSL)
+2. **Extrae y filtra archivos modificados**:
+   - Solo analiza: Java, XML, properties, yml, yaml
+   - Omite archivos mayores a 100KB
+   - Límite de 10 archivos por commit
+3. **Modos de análisis disponibles**:
+   - **Estándar**: Formato clásico con score y recomendaciones detalladas
+   - **SonarQube**: Simula salida de SonarQube con Quality Gate, métricas y clasificación de issues
+4. **Construye prompt inteligente**:
+   - Lee las pautas desde `CLAUDE_PRE_COMMIT.md` o `CLAUDE_PRE_COMMIT_SONAR.md`
+   - Incluye el diff completo para archivos nuevos
+   - Muestra solo cambios para archivos existentes
+5. **Envía a Claude CLI para revisión**
+6. **Procesa respuesta JSON**:
+   - En modo estándar: evalúa `approved`, `score`, `recommendations`
+   - En modo SonarQube: verifica `QUALITY_GATE`, muestra métricas y issues por severidad
+7. **Decisión final**:
+   - Si hay problemas críticos o quality gate falla → commit bloqueado
+   - Si todo está bien → commit procede
+
+### Hook prepare-commit-msg (Generación automática de mensajes)
+
+1. **Se activa cuando el mensaje es**:
+   - Vacío (`""`)
+   - `"auto"`
+   - `"--"`
+   - `"tmp"`
+2. **Analiza los cambios del staging area**:
+   - Lista archivos modificados con estadísticas
+   - Incluye diffs completos para archivos < 100KB
+3. **Genera mensaje en formato Conventional Commits**:
+   - Determina tipo: feat, fix, docs, style, refactor, test, chore
+   - Crea título conciso y descriptivo
+   - Añade body con detalles si es necesario
+4. **Manejo de errores**:
+   - Si falla la generación → cancela el commit completamente
+   - No usa mensajes genéricos de fallback
+
+### Características adicionales
+
+- **Auto-actualización**: Los hooks se sincronizan automáticamente con las versiones en `git-hooks/`
+- **Modo debug**: `DEBUG=1 git commit` guarda respuestas en `debug-claude-response.json`
+- **Configuración persistente**: Guarda preferencias en `.claude-analysis-mode`
+- **Validación de dependencias**: Verifica que Claude CLI esté autenticado antes de ejecutar
+
+## 🛠️ Uso
+
+**IMPORTANTE**: Todos los comandos git deben ejecutarse desde WSL.
+
+### Commit normal
+
+```bash
+# Desde WSL
+git add .
+git commit -m "feat: nueva funcionalidad"
+```
+
+### Commit con mensaje automático 🤖
+
+```bash
+# Desde WSL
+git add .
+git commit -m "auto"  # Claude generará el mensaje automáticamente
+```
+
+Claude analizará los cambios y generará un mensaje de commit siguiendo las convenciones (feat, fix, docs, etc.).
+
+**⚠️ Si la generación automática falla**: El commit se cancelará completamente. Simplemente ejecuta `git commit -m "tu mensaje"` manualmente.
+
+### Selección de formato de análisis 📊
+
+**Opción 1: Con variable de entorno (recomendado)**
+
+```bash
+# Para formato estándar
+export CLAUDE_ANALYSIS_MODE=standard
+git commit -m "mensaje"
+
+# Para formato SonarQube
+export CLAUDE_ANALYSIS_MODE=sonar
+git commit -m "mensaje"
+```
+
+**Opción 2: Configuración interactiva**
+
+```bash
+git commit -m "mensaje"
+# En la primera ejecución te preguntará:
+# 1) Estándar - Formato clásico con recomendaciones
+# 2) SonarQube - Formato similar a SonarQube con métricas
+```
+
+**⚠️ Nota sobre compatibilidad**: La selección interactiva requiere una terminal con soporte TTY (terminal interactiva). En WSL generalmente funciona correctamente. Sin embargo, en algunos entornos como:
+
+- Scripts automatizados
+- CI/CD pipelines
+- Algunos emuladores de terminal
+- Cuando no hay TTY disponible
+
+El sistema automáticamente usará el modo **estándar** como fallback sin preguntar.
+
+**Opción 3: Cambiar configuración guardada**
+
+```bash
+.git/hooks/pre-commit --change-mode
+```
+
+**Formato Estándar**: Análisis tradicional con score, recomendaciones y detalles por categoría.
+
+**Formato SonarQube**: Análisis con Quality Gate, métricas (Reliability, Security, Maintainability), clasificación de issues por severidad (Blocker, Critical, Major, Minor, Info), y security hotspots.
+
+### Saltar la revisión (usar con precaución)
+
+```bash
+# Desde WSL
+git commit --no-verify -m "fix: corrección urgente"
+```
+
+### Modo debug
+
+```bash
+# Desde WSL
+DEBUG=1 git commit -m "mensaje"
+```
+
+## 📊 Formato de Respuesta
+
+Claude responde con un JSON que incluye:
+
+- `approved`: Si el commit es aprobado
+- `score`: Puntuación del 1-10
+- `commitMessage`: Mensaje de commit generado (type, title, body)
+- `recommendations`: Recomendaciones de mejora
+- `blockingIssues`: Problemas que bloquean el commit
+
+## 🔄 Desactivar/Activar
+
+```bash
+# Desactivar todos los hooks
+./git-hooks/setup-wsl.sh --disable-hooks
+
+# Desactivar un hook específico
+./git-hooks/setup-wsl.sh --disable-hooks pre-commit
+./git-hooks/setup-wsl.sh --disable-hooks prepare-commit-msg
+
+# Habilitar todos los hooks
+./git-hooks/setup-wsl.sh --enable-hooks
+
+# Habilitar un hook específico
+./git-hooks/setup-wsl.sh --enable-hooks pre-commit
+./git-hooks/setup-wsl.sh --enable-hooks prepare-commit-msg
+```
+
+## ⚙️ Configuración
+
+### Variables de entorno disponibles
+
+- **`CLAUDE_ANALYSIS_MODE`**: Selecciona el modo de análisis
+
+  - Valores: `"standard"` o `"sonar"`
+  - Ejemplo: `CLAUDE_ANALYSIS_MODE=sonar git commit -m "mensaje"`
+  - Sobrescribe la preferencia guardada en `.claude-analysis-mode`
+
+- **`DEBUG`**: Activa el modo debug
+  - Valores: `1` para activar
+  - Ejemplo: `DEBUG=1 git commit -m "mensaje"`
+  - Guarda las respuestas de Claude en `debug-claude-response.json`
+
+### Variables modificables en los archivos de hooks
+
+En el archivo `pre-commit`:
+
+- **`MAX_FILE_SIZE`**: Tamaño máximo de archivo a analizar (default: 100KB)
+- **`MAX_FILES`**: Número máximo de archivos por commit (default: 10)
+- **`CLAUDE_CLI`**: Comando de Claude CLI (default: "claude")
+- **`GUIDELINES_FILE`**: Archivo de pautas para modo estándar (default: "CLAUDE_PRE_COMMIT.md")
+- **`GUIDELINES_FILE_SONAR`**: Archivo de pautas para modo SonarQube (default: "CLAUDE_PRE_COMMIT_SONAR.md")
+
+En el archivo `prepare-commit-msg`:
+
+- **`MAX_FILE_SIZE`**: Tamaño máximo para incluir diff completo (default: 100KB)
+- **`CLAUDE_CLI`**: Comando de Claude CLI (default: "claude")
+
+## 🐛 Troubleshooting
+
+### "Claude CLI no está instalado"
+
+```bash
+# Desde WSL
+npm install -g @anthropic-ai/claude-cli
+claude auth login
+```
+
+### "No se recibió respuesta JSON válida"
+
+- Verifica que Claude CLI esté autenticado en WSL
+- Ejecuta en modo DEBUG para ver la respuesta completa
+- Revisa que el archivo de pautas esté bien formateado
+
+### El hook no se ejecuta
+
+- Verifica que estés ejecutando git desde WSL
+- Verifica permisos: `ls -la .git/hooks/pre-commit`
+- Debe mostrar permisos de ejecución (-rwxr-xr-x)
+
+### Problemas con line endings
+
+- Si ves errores de "^M" o caracteres extraños:
+  ```bash
+  # En WSL
+  git config core.autocrlf input
+  ```
+
+### Los hooks se vacían o corrompen
+
+Este problema suele ocurrir por conflictos de configuración de line endings:
+
+1. **Verifica configuraciones**:
+
+   ```bash
+   git config --local core.autocrlf  # Debe ser 'input'
+   git config --global core.autocrlf # Debe ser 'input'
+   ```
+
+2. **Si están diferentes, corrige**:
+
+   ```bash
+   git config --local core.autocrlf input
+   ```
+
+3. **Restaura los hooks**:
+   ```bash
+   ./git-hooks/setup-wsl.sh --sync
+   ```
+
+### Credenciales no funcionan en WSL
+
+- Las credenciales de Windows no se comparten automáticamente con WSL
+- Reconfigura tus credenciales git en WSL
+
+## 📝 Personalización
+
+Puedes modificar las pautas de evaluación editando `CLAUDE_PRE_COMMIT.md` para adaptarlas a los estándares de tu equipo.
+
+## 🔄 Arquitectura del Sistema
+
+```
+WSL Terminal
+     │
+     ├─→ git add/commit
+     │
+     └─→ .git/hooks/pre-commit
+              │
+              ├─→ Lee archivos modificados
+              ├─→ Lee CLAUDE_PRE_COMMIT.md
+              ├─→ Construye prompt
+              │
+              └─→ Claude CLI
+                       │
+                       └─→ Respuesta JSON
+                              │
+                              ├─→ ✅ Approved → Commit procede
+                              └─→ ❌ Rejected → Commit bloqueado
+```
+
+## 📌 Notas Importantes
+
+1. **Todo en WSL**: Claude CLI solo funciona en WSL, por lo que todos los comandos git deben ejecutarse desde ahí
+2. **Line Endings**: La configuración de `core.autocrlf` es crítica para evitar problemas entre Windows y Linux
+3. **Credenciales**: Necesitarás reconfigurar tus credenciales git en WSL
+4. **Performance**: La revisión puede tardar unos segundos dependiendo del tamaño de los cambios

package/bin/claude-hooks

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colores para output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function error(message) {
+  console.error(`${colors.red}❌ ${message}${colors.reset}`);
+  process.exit(1);
+}
+
+function success(message) {
+  log(`✅ ${message}`, 'green');
+}
+
+function info(message) {
+  log(`ℹ️  ${message}`, 'blue');
+}
+
+function warning(message) {
+  log(`⚠️  ${message}`, 'yellow');
+}
+
+// Verificar si estamos en un repositorio git
+function checkGitRepo() {
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Obtener la ruta de los templates
+function getTemplatesPath() {
+  return path.join(__dirname, '..', 'templates');
+}
+
+// Comando install
+function install(args) {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git. Por favor, ejecuta este comando desde la raíz de un repositorio.');
+  }
+
+  info('Instalando Claude Git Hooks...');
+
+  const templatesPath = getTemplatesPath();
+  const hooksPath = '.git/hooks';
+
+  // Crear directorio hooks si no existe
+  if (!fs.existsSync(hooksPath)) {
+    fs.mkdirSync(hooksPath, { recursive: true });
+  }
+
+  // Hooks a instalar
+  const hooks = ['pre-commit', 'prepare-commit-msg'];
+  
+  hooks.forEach(hook => {
+    const sourcePath = path.join(templatesPath, hook);
+    const destPath = path.join(hooksPath, hook);
+    
+    // Hacer backup si existe
+    if (fs.existsSync(destPath)) {
+      const backupPath = `${destPath}.backup.${Date.now()}`;
+      fs.copyFileSync(destPath, backupPath);
+      info(`Backup creado: ${backupPath}`);
+    }
+    
+    // Copiar hook
+    fs.copyFileSync(sourcePath, destPath);
+    fs.chmodSync(destPath, '755');
+    success(`${hook} instalado`);
+  });
+
+  // Copiar archivos de pautas si no existen
+  const guidelines = ['CLAUDE_PRE_COMMIT.md', 'CLAUDE_PRE_COMMIT_SONAR.md'];
+  guidelines.forEach(guideline => {
+    if (!fs.existsSync(guideline)) {
+      const sourcePath = path.join(templatesPath, guideline);
+      fs.copyFileSync(sourcePath, guideline);
+      success(`${guideline} creado`);
+    }
+  });
+
+  // Verificar dependencias
+  checkDependencies();
+
+  success('¡Claude Git Hooks instalado exitosamente! 🎉');
+  console.log('\nUso:');
+  console.log('  git commit -m "auto"     # Genera mensaje automáticamente');
+  console.log('  git commit -m "mensaje"  # Analiza código antes del commit');
+  console.log('\nPara más opciones: claude-hooks --help');
+}
+
+// Verificar dependencias
+function checkDependencies() {
+  info('\nVerificando dependencias...');
+  
+  // Verificar Claude CLI
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    success('Claude CLI encontrado');
+  } catch (e) {
+    warning('Claude CLI no está instalado');
+    console.log('Instálalo con: npm install -g @anthropic-ai/claude-cli');
+    console.log('Luego ejecuta: claude auth login');
+  }
+  
+  // Verificar jq
+  try {
+    execSync('jq --version', { stdio: 'ignore' });
+    success('jq encontrado');
+  } catch (e) {
+    warning('jq no está instalado');
+    if (os.platform() === 'linux') {
+      console.log('Instálalo con: sudo apt install jq');
+    } else if (os.platform() === 'darwin') {
+      console.log('Instálalo con: brew install jq');
+    }
+  }
+}
+
+// Comando uninstall
+function uninstall() {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git.');
+  }
+
+  info('Desinstalando Claude Git Hooks...');
+
+  const hooksPath = '.git/hooks';
+  const hooks = ['pre-commit', 'prepare-commit-msg'];
+  
+  hooks.forEach(hook => {
+    const hookPath = path.join(hooksPath, hook);
+    if (fs.existsSync(hookPath)) {
+      fs.unlinkSync(hookPath);
+      success(`${hook} eliminado`);
+    }
+  });
+
+  success('Claude Git Hooks desinstalado');
+}
+
+// Comando enable
+function enable(hookName) {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git.');
+  }
+
+  const hooks = hookName ? [hookName] : ['pre-commit', 'prepare-commit-msg'];
+  
+  hooks.forEach(hook => {
+    const disabledPath = `.git/hooks/${hook}.disabled`;
+    const enabledPath = `.git/hooks/${hook}`;
+    
+    if (fs.existsSync(disabledPath)) {
+      fs.renameSync(disabledPath, enabledPath);
+      success(`${hook} habilitado`);
+    } else if (fs.existsSync(enabledPath)) {
+      info(`${hook} ya está habilitado`);
+    } else {
+      warning(`${hook} no encontrado`);
+    }
+  });
+}
+
+// Comando disable
+function disable(hookName) {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git.');
+  }
+
+  const hooks = hookName ? [hookName] : ['pre-commit', 'prepare-commit-msg'];
+  
+  hooks.forEach(hook => {
+    const enabledPath = `.git/hooks/${hook}`;
+    const disabledPath = `.git/hooks/${hook}.disabled`;
+    
+    if (fs.existsSync(enabledPath)) {
+      fs.renameSync(enabledPath, disabledPath);
+      success(`${hook} deshabilitado`);
+    } else if (fs.existsSync(disabledPath)) {
+      info(`${hook} ya está deshabilitado`);
+    } else {
+      warning(`${hook} no encontrado`);
+    }
+  });
+}
+
+// Comando status
+function status() {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git.');
+  }
+
+  info('Estado de Claude Git Hooks:\n');
+
+  const hooks = ['pre-commit', 'prepare-commit-msg'];
+  hooks.forEach(hook => {
+    const enabledPath = `.git/hooks/${hook}`;
+    const disabledPath = `.git/hooks/${hook}.disabled`;
+    
+    if (fs.existsSync(enabledPath)) {
+      success(`${hook}: habilitado`);
+    } else if (fs.existsSync(disabledPath)) {
+      warning(`${hook}: deshabilitado`);
+    } else {
+      error(`${hook}: no instalado`);
+    }
+  });
+
+  // Verificar archivos de pautas
+  console.log('\nArchivos de pautas:');
+  const guidelines = ['CLAUDE_PRE_COMMIT.md', 'CLAUDE_PRE_COMMIT_SONAR.md'];
+  guidelines.forEach(guideline => {
+    if (fs.existsSync(guideline)) {
+      success(`${guideline}: presente`);
+    } else {
+      warning(`${guideline}: faltante`);
+    }
+  });
+}
+
+// Comando help
+function showHelp() {
+  console.log(`
+Claude Git Hooks - Análisis de código y mensajes automáticos con Claude CLI
+
+Uso: claude-hooks <comando> [opciones]
+
+Comandos:
+  install              Instala los hooks en el repositorio actual
+  uninstall            Desinstala los hooks del repositorio
+  enable [hook]        Habilita hooks (todos o uno específico)
+  disable [hook]       Deshabilita hooks (todos o uno específico)
+  status               Muestra el estado de los hooks
+  help                 Muestra esta ayuda
+
+Hooks disponibles:
+  pre-commit           Análisis de código antes del commit
+  prepare-commit-msg   Generación automática de mensajes
+
+Ejemplos:
+  claude-hooks install              # Instala todos los hooks
+  claude-hooks disable pre-commit   # Deshabilita solo pre-commit
+  claude-hooks enable               # Habilita todos los hooks
+  claude-hooks status               # Ver estado actual
+
+Más información: https://github.com/tresmares/claude-git-hooks
+`);
+}
+
+// Main
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case 'install':
+    install(args.slice(1));
+    break;
+  case 'uninstall':
+    uninstall();
+    break;
+  case 'enable':
+    enable(args[1]);
+    break;
+  case 'disable':
+    disable(args[1]);
+    break;
+  case 'status':
+    status();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+  default:
+    error(`Comando desconocido: ${command}`);
+    showHelp();
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "claude-git-hooks",
+  "version": "1.0.0",
+  "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": {
+    "claude-hooks": "./bin/claude-hooks"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "git",
+    "hooks",
+    "claude",
+    "ai",
+    "code-review",
+    "commit-messages",
+    "pre-commit",
+    "automation"
+  ],
+  "author": "Pablo Rovito",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pablorovito/claude-git-hooks.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {},
+  "preferGlobal": true,
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/templates/CLAUDE_PRE_COMMIT.md

@@ -0,0 +1,62 @@
+# Pautas de Evaluación de Código - Claude Pre-commit Hook
+
+## Objetivo
+Evaluar el código modificado antes del commit para asegurar calidad, mantenibilidad y adherencia a buenas prácticas.
+
+## Criterios de Evaluación
+
+### 1. Calidad del Código (40%)
+- **Claridad y legibilidad**: El código es fácil de entender
+- **Nombres descriptivos**: Variables, métodos y clases tienen nombres significativos
+- **Estructura lógica**: El código está bien organizado
+- **Principio DRY**: No hay duplicación innecesaria
+- **Complejidad**: Funciones y métodos no son excesivamente complejos
+
+### 2. Buenas Prácticas (30%)
+- **SOLID principles**: Adherencia cuando aplique
+- **Patrones de diseño**: Uso apropiado cuando sea necesario
+- **Manejo de errores**: Excepciones manejadas correctamente
+- **Validación de inputs**: Datos de entrada validados
+- **Separación de concerns**: Responsabilidades bien definidas
+
+### 3. Seguridad (20%)
+- **No hay credenciales hardcodeadas**
+- **Validación de datos de usuario**
+- **No hay vulnerabilidades obvias** (SQL injection, XSS, etc.)
+- **Manejo seguro de datos sensibles**
+
+### 4. Performance (10%)
+- **No hay operaciones obviamente ineficientes**
+- **Uso apropiado de estructuras de datos**
+- **Queries optimizadas** (cuando aplique)
+
+## Formato de Respuesta Esperado
+
+Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
+
+```json
+{
+  "approved": true/false,
+  "score": 8,
+  "recommendations": [
+    "Sugerencia 1",
+    "Sugerencia 2"
+  ],
+  "blockingIssues": [
+    "Problema crítico 1 (si existe)"
+  ]
+}
+```
+
+## Reglas de Aprobación
+
+- **approved = true** si score >= 7 Y no hay blockingIssues
+- **approved = false** si score < 7 O hay blockingIssues
+
+## Problemas que SIEMPRE son Blocking Issues
+
+1. Credenciales o tokens hardcodeados
+2. Vulnerabilidades de seguridad evidentes
+3. Código que podría causar pérdida de datos
+4. Errores de sintaxis o código que no compilaría
+5. Eliminación de tests sin justificación

package/templates/CLAUDE_PRE_COMMIT_SONAR.md

@@ -0,0 +1,86 @@
+# Pautas de Evaluación de Código - Formato SonarQube
+
+## Objetivo
+Evaluar el código modificado siguiendo métricas similares a SonarQube para asegurar calidad, confiabilidad y mantenibilidad.
+
+## Métricas de Evaluación
+
+### Reliability (Confiabilidad)
+- Bugs potenciales
+- Código que podría fallar en runtime
+- Manejo inadecuado de excepciones
+- Condiciones de carrera
+
+### Security (Seguridad)
+- Vulnerabilidades de seguridad
+- Credenciales expuestas
+- Validación de inputs
+- Inyección de código
+
+### Maintainability (Mantenibilidad)
+- Code smells
+- Complejidad ciclomática
+- Duplicación de código
+- Deuda técnica
+
+## Clasificación de Issues
+
+### Severidad
+- **BLOCKER**: Debe corregirse inmediatamente
+- **CRITICAL**: Debe corregirse antes del release
+- **MAJOR**: Debe corregirse pronto
+- **MINOR**: Debería corregirse eventualmente
+- **INFO**: Sugerencia o mejora opcional
+
+## Formato de Respuesta Esperado
+
+Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
+
+```json
+{
+  "QUALITY_GATE": "PASSED/FAILED",
+  "metrics": {
+    "reliability": "A/B/C/D/E",
+    "security": "A/B/C/D/E",
+    "maintainability": "A/B/C/D/E"
+  },
+  "issues": {
+    "blocker": 0,
+    "critical": 0,
+    "major": 0,
+    "minor": 0,
+    "info": 0
+  },
+  "details": [
+    {
+      "severity": "CRITICAL",
+      "type": "BUG/VULNERABILITY/CODE_SMELL",
+      "message": "Descripción del problema",
+      "file": "archivo.java",
+      "line": 42
+    }
+  ],
+  "securityHotspots": 0
+}
+```
+
+## Reglas para Quality Gate
+
+- **PASSED** si:
+  - No hay issues BLOCKER
+  - Issues CRITICAL <= 1
+  - Todas las métricas son A o B
+
+- **FAILED** si:
+  - Hay al menos 1 issue BLOCKER
+  - Issues CRITICAL > 1
+  - Alguna métrica es D o E
+  - Security hotspots > 0
+
+## Rating de Métricas
+
+- **A**: Excelente (0 issues)
+- **B**: Bueno (1-2 issues minor)
+- **C**: Aceptable (1 issue major o 3-5 minor)
+- **D**: Pobre (2+ major o 1 critical)
+- **E**: Muy pobre (1+ blocker o 2+ critical)

package/templates/pre-commit

@@ -0,0 +1,352 @@
+#!/bin/bash
+
+# Git Pre-commit Hook para evaluación de código con Claude CLI
+# Archivo: .git/hooks/pre-commit
+
+set -e
+
+# Configuración
+CLAUDE_CLI="claude"
+TEMP_DIR="/tmp/code-review-$$"
+MAX_FILE_SIZE=100000  # 100KB máximo por archivo
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Función para logging
+log() {
+    echo -e "${GREEN}[PRE-COMMIT]${NC} $1"
+}
+
+error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Detectar qué archivo de pautas usar
+# Prioridad: variable de entorno > archivo > pregunta interactiva
+if [ -n "$CLAUDE_ANALYSIS_MODE" ]; then
+    ANALYSIS_MODE="$CLAUDE_ANALYSIS_MODE"
+elif [ -f ".claude-analysis-mode" ]; then
+    ANALYSIS_MODE=$(cat .claude-analysis-mode)
+else
+    ANALYSIS_MODE=""
+fi
+
+# Verificar si el usuario quiere cambiar el modo (con --change-mode)
+if [ "$1" = "--change-mode" ]; then
+    ANALYSIS_MODE=""
+fi
+
+# Si no hay modo guardado o es inválido, preguntar
+if [ "$ANALYSIS_MODE" != "standard" ] && [ "$ANALYSIS_MODE" != "sonar" ]; then
+    echo
+    echo "🔍 Selecciona el formato de análisis de código:"
+    echo "1) Estándar - Formato clásico con recomendaciones"
+    echo "2) SonarQube - Formato similar a SonarQube con métricas"
+    echo
+    
+    # Intentar leer desde terminal
+    if [ -t 0 ] && [ -c /dev/tty ]; then
+        read -p "Opción (1 o 2): " -n 1 -r </dev/tty
+        echo
+    else
+        # Si no hay terminal interactiva, usar modo estándar por defecto
+        echo "No se puede leer input interactivo, usando modo estándar por defecto"
+        REPLY="1"
+    fi
+    
+    if [ "$REPLY" = "2" ]; then
+        ANALYSIS_MODE="sonar"
+        GUIDELINES_FILE="CLAUDE_PRE_COMMIT_SONAR.md"
+    else
+        ANALYSIS_MODE="standard"
+        GUIDELINES_FILE="CLAUDE_PRE_COMMIT.md"
+    fi
+    
+    # Guardar preferencia para futuros commits
+    echo "$ANALYSIS_MODE" > .claude-analysis-mode
+    echo -e "${GREEN}✓ Modo $ANALYSIS_MODE guardado para futuros commits${NC}"
+    echo -e "${YELLOW}Tip: Para cambiar el modo, ejecuta: .git/hooks/pre-commit --change-mode${NC}"
+    echo
+else
+    # Usar modo guardado
+    if [ "$ANALYSIS_MODE" = "sonar" ]; then
+        GUIDELINES_FILE="CLAUDE_PRE_COMMIT_SONAR.md"
+        log "Usando modo de análisis: SonarQube"
+    else
+        GUIDELINES_FILE="CLAUDE_PRE_COMMIT.md"
+        log "Usando modo de análisis: Estándar"
+    fi
+fi
+# Función para limpiar archivos temporales
+cleanup() {
+    rm -rf "$TEMP_DIR"
+}
+
+# Configurar limpieza al salir
+trap cleanup EXIT
+
+# Crear directorio temporal
+mkdir -p "$TEMP_DIR"
+
+# Verificar si Claude CLI está instalado (solo para análisis de código)
+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"
+    exit 1
+fi
+
+# Ahora verificar si hay archivos Java para analizar
+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"
+    exit 0
+fi
+
+# Verificar si existe el archivo de pautas
+if [ ! -f "$GUIDELINES_FILE" ]; then
+    warning "No se encontró el archivo de pautas: $GUIDELINES_FILE"
+    warning "Saltando análisis de código"
+    exit 0
+fi
+
+log "Archivos Java/config a revisar: $(echo "$JAVA_FILES" | wc -l)"
+
+# Construir el prompt para análisis de código
+PROMPT_FILE="$TEMP_DIR/code_review_prompt.txt"
+
+cat > "$PROMPT_FILE" << 'EOF'
+Eres un revisor de código senior con experiencia en proyectos Spring Boot empresariales.
+
+Tu tarea es analizar los siguientes cambios de código y responder exclusivamente con un JSON válido, **sin ningún texto fuera del JSON**, sin introducciones ni explicaciones adicionales.
+
+⚠️ La respuesta debe ser un objeto JSON con esta estructura exacta:
+
+{
+  "approved": true,                // true si el commit puede aceptarse, false si debe bloquearse
+  "score": 1-10,                   // calificación de calidad (entero)
+  "blockingIssues": [             // lista de errores críticos (vacía si no hay)
+    "texto descriptivo 1",
+    "texto descriptivo 2"
+  ],
+  "recommendations": [            // sugerencias no bloqueantes
+    "mejora 1",
+    "mejora 2"
+  ],
+  "details": {
+    "security": [                 // comentarios específicos por área
+      "observación sobre seguridad"
+    ],
+    "architecture": [ "..." ],
+    "performance": [ "..." ],
+    "maintainability": [ "..." ]
+  }
+}
+
+✅ Importante:
+- Usa listas aunque estén vacías (por ejemplo `"blockingIssues": []`)
+- No uses texto introductorio o explicaciones fuera del JSON
+- No omitas claves aunque estén vacías
+- Sé directo, claro y profesional en tus observaciones
+
+A continuación se detallan las pautas y los cambios:
+EOF
+
+# Agregar las pautas
+echo "=== PAUTAS DE EVALUACIÓN ===" >> "$PROMPT_FILE"
+cat "$GUIDELINES_FILE" >> "$PROMPT_FILE"
+echo -e "\n\n=== CAMBIOS A REVISAR ===\n" >> "$PROMPT_FILE"
+
+# Procesar cada archivo Java
+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..."
+            continue
+        fi
+        
+        echo -e "\n--- Archivo: $FILE ---" >> "$PROMPT_FILE"
+        
+        # Mostrar el diff del archivo
+        echo -e "\nDiff:" >> "$PROMPT_FILE"
+        git diff --cached "$FILE" >> "$PROMPT_FILE" 2>/dev/null || echo "No se pudo obtener diff"
+        
+        # Si es un archivo nuevo, mostrar contenido completo
+        if git diff --cached --name-status | grep "^A.*$FILE" > /dev/null; then
+            echo -e "\nContenido completo (archivo nuevo):" >> "$PROMPT_FILE"
+            git show ":$FILE" >> "$PROMPT_FILE" 2>/dev/null || cat "$FILE" >> "$PROMPT_FILE"
+        fi
+        
+        FILE_COUNT=$((FILE_COUNT + 1))
+    fi
+done
+
+if [ "$FILE_COUNT" -eq 0 ]; then
+    log "No se encontraron archivos válidos para revisar"
+    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"
+    exit 0
+fi
+
+log "Enviando $FILE_COUNT archivos para revisión con Claude..."
+
+# Enviar a Claude y capturar respuesta
+RESPONSE_FILE="$TEMP_DIR/code_review_response.txt"
+
+# Ejecutar Claude CLI y capturar la respuesta
+if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
+    # Extraer el JSON de la respuesta
+    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:"
+        cat "$RESPONSE_FILE"
+        exit 1
+    fi
+    
+    # Guardar JSON para debug si está activado
+    if [ -n "$DEBUG" ]; then
+        echo "$JSON_RESPONSE" > ./debug-claude-response.json
+        log "Respuesta guardada en debug-claude-response.json"
+    fi
+    
+    # Parsear la respuesta usando 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')
+    BLOCKING_ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.blockingIssues[]?' 2>/dev/null | sed '/^$/d')
+    
+    # Verificar si estamos en modo SonarQube
+    QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.qualityGate // ""' 2>/dev/null)
+    
+    if [ "$ANALYSIS_MODE" = "sonar" ] && [ -n "$QUALITY_GATE" ] && [ "$QUALITY_GATE" != "null" ]; then
+        # Mostrar resultados estilo SonarQube
+        echo
+        echo "╔════════════════════════════════════════════════════════════════════╗"
+        echo "║                     CODE QUALITY ANALYSIS                           ║"
+        echo "╚════════════════════════════════════════════════════════════════════╝"
+        echo
+        
+        # Quality Gate Status
+        if [ "$QUALITY_GATE" = "PASSED" ]; then
+            echo -e "${GREEN}✓ Quality Gate: PASSED${NC}"
+        else
+            echo -e "${RED}✗ Quality Gate: FAILED${NC}"
+        fi
+        echo
+        
+        # Metrics
+        METRICS=$(echo "$JSON_RESPONSE" | jq -r '.metrics // {}' 2>/dev/null)
+        if [ "$METRICS" != "{}" ] && [ "$METRICS" != "null" ]; then
+            echo "📊 METRICS"
+            echo "├─ Reliability: $(echo "$METRICS" | jq -r '.reliability // "?"' 2>/dev/null)"
+            echo "├─ Security: $(echo "$METRICS" | jq -r '.security // "?"' 2>/dev/null)"
+            echo "├─ Maintainability: $(echo "$METRICS" | jq -r '.maintainability // "?"' 2>/dev/null)"
+            echo "├─ Coverage: $(echo "$METRICS" | jq -r '.coverage // "?"' 2>/dev/null)%"
+            echo "├─ Duplications: $(echo "$METRICS" | jq -r '.duplications // "?"' 2>/dev/null)%"
+            echo "└─ Complexity: $(echo "$METRICS" | jq -r '.complexity // "?"' 2>/dev/null)"
+            echo
+        fi
+        
+        # Issues Summary
+        SUMMARY=$(echo "$JSON_RESPONSE" | jq -r '.summary // {}' 2>/dev/null)
+        if [ "$SUMMARY" != "{}" ] && [ "$SUMMARY" != "null" ]; then
+            echo "📋 ISSUES SUMMARY"
+            TOTAL=$(echo "$SUMMARY" | jq -r '.total // 0' 2>/dev/null)
+            BLOCKER=$(echo "$SUMMARY" | jq -r '.blocker // 0' 2>/dev/null)
+            CRITICAL=$(echo "$SUMMARY" | jq -r '.critical // 0' 2>/dev/null)
+            MAJOR=$(echo "$SUMMARY" | jq -r '.major // 0' 2>/dev/null)
+            MINOR=$(echo "$SUMMARY" | jq -r '.minor // 0' 2>/dev/null)
+            INFO=$(echo "$SUMMARY" | jq -r '.info // 0' 2>/dev/null)
+            
+            echo "Total: $TOTAL issues found"
+            [ "$BLOCKER" -gt 0 ] && echo -e "  ${RED}🔴 Blocker: $BLOCKER${NC}"
+            [ "$CRITICAL" -gt 0 ] && echo -e "  ${RED}🟠 Critical: $CRITICAL${NC}"
+            [ "$MAJOR" -gt 0 ] && echo -e "  ${YELLOW}🟡 Major: $MAJOR${NC}"
+            [ "$MINOR" -gt 0 ] && echo "  🔵 Minor: $MINOR"
+            [ "$INFO" -gt 0 ] && echo "  ⚪ Info: $INFO"
+            echo
+        fi
+        
+        # Detailed Issues
+        ISSUES_COUNT=$(echo "$JSON_RESPONSE" | jq -r '.issues | length' 2>/dev/null)
+        if [ "$ISSUES_COUNT" -gt 0 ] 2>/dev/null; then
+            echo "🔍 DETAILED ISSUES"
+            echo "$JSON_RESPONSE" | jq -r '.issues[]? | 
+                "[\(.severity)] \(.type) in \(.file):\(.line // "?")\n   \(.message)\n   Rule: \(.rule // "N/A") | Effort: \(.effort // "?")\n"' 2>/dev/null
+        fi
+        
+        # Security Hotspots
+        HOTSPOTS_COUNT=$(echo "$JSON_RESPONSE" | jq -r '.hotspots | length' 2>/dev/null)
+        if [ "$HOTSPOTS_COUNT" -gt 0 ] 2>/dev/null; then
+            echo "🔥 SECURITY HOTSPOTS"
+            echo "$JSON_RESPONSE" | jq -r '.hotspots[]? | "  • \(.file): \(.message)"' 2>/dev/null
+            echo
+        fi
+        
+        # Check if commit should be blocked
+        if [ "$QUALITY_GATE" = "FAILED" ] || [ "$APPROVED" = "false" ]; then
+            echo
+            error "❌ Commit blocked due to quality gate failure"
+            exit 1
+        fi
+        
+        echo
+        log "✅ Code analysis completed. Quality gate passed."
+    else
+        # Mostrar resultados en formato clásico
+        echo
+        echo "=== RESULTADO DE LA REVISIÓN ==="
+        echo "Score: $SCORE/10"
+        
+        if [ -n "$RECOMMENDATIONS" ] && [ "$RECOMMENDATIONS" != "null" ]; then
+            echo
+            echo "=== RECOMENDACIONES ==="
+            echo "$RECOMMENDATIONS" | sed 's/^/- /'
+        fi
+        
+        # Verificar si el commit debe ser bloqueado
+        if [ "$APPROVED" = "false" ]; then
+            error "❌ Commit rechazado por problemas críticos"
+            if [ -n "$BLOCKING_ISSUES" ] && [ "$BLOCKING_ISSUES" != "null" ]; then
+                echo
+                echo "=== PROBLEMAS CRÍTICOS ==="
+                echo "$BLOCKING_ISSUES" | sed 's/^/- /'
+            fi
+            exit 1
+        fi
+
+        DETAILS=$(echo "$JSON_RESPONSE" | jq -r '.details // {}')
+        if [ -n "$DETAILS" ] && [ "$DETAILS" != "{}" ] && [ "$DETAILS" != "null" ]; then
+            echo
+            echo "=== DETALLES POR CATEGORÍA ==="
+            echo "$DETAILS" | jq
+        fi
+        
+        log "✅ Revisión completada. Commit aprobado (Score: $SCORE/10)"
+    fi
+    
+else
+    error "Error al ejecutar Claude CLI"
+    error "Verifica que Claude CLI esté configurado correctamente"
+    cat "$RESPONSE_FILE"
+    exit 1
+fi
+
+exit 0

package/templates/prepare-commit-msg

@@ -0,0 +1,138 @@
+#!/bin/bash
+
+# Git Prepare-commit-msg Hook para generar mensajes automáticos con Claude
+# Archivo: .git/hooks/prepare-commit-msg
+
+set -e
+
+# Configuración
+CLAUDE_CLI="claude"
+TEMP_DIR="/tmp/commit-msg-$$"
+MAX_FILE_SIZE=100000
+AUTO_COMMIT_ENABLED=true
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Función para logging
+log() {
+    printf "${GREEN}[PREPARE-MSG]${NC} %s\n" "$1" >&2
+}
+
+warning() {
+    printf "${YELLOW}[WARNING]${NC} %s\n" "$1" >&2
+}
+
+# Función para limpiar archivos temporales
+cleanup() {
+    rm -rf "$TEMP_DIR"
+}
+trap cleanup EXIT
+
+# Argumentos del hook
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Solo procesar si es un commit normal
+if [ "$COMMIT_SOURCE" != "" ] && [ "$COMMIT_SOURCE" != "message" ]; then
+    exit 0
+fi
+
+# Leer el mensaje actual
+CURRENT_MSG=$(head -n 1 "$COMMIT_MSG_FILE" 2>/dev/null || echo "")
+
+# Verificar si necesitamos generar mensaje
+if [ "$CURRENT_MSG" = "auto" ]; then
+    log "Intentando generar mensaje..."
+else
+    exit 0
+fi
+
+# Verificar si Claude CLI está instalado
+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"
+    exit 1
+fi
+
+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.
+
+Responde SOLO con un JSON válido:
+
+{
+  "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"
+}
+
+CAMBIOS A ANALIZAR:
+EOF
+
+# Obtener archivos staged
+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"
+    exit 1
+fi
+
+printf "\nArchivos modificados:\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"
+
+# Mostrar diffs de archivos pequeños
+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"
+        fi
+    fi
+done
+
+RESPONSE_FILE="$TEMP_DIR/commit_msg_response.txt"
+log "Generando mensaje de commit con Claude..."
+
+if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
+    JSON_MSG=$(sed -n '/^{/,/^}/p' "$RESPONSE_FILE" | head -n 1000)
+    
+    if [ -n "$JSON_MSG" ]; then
+        MSG_TYPE=$(echo "$JSON_MSG" | jq -r '.type // "feat"' 2>/dev/null || echo "feat")
+        MSG_SCOPE=$(echo "$JSON_MSG" | jq -r '.scope // ""' 2>/dev/null || echo "")
+        MSG_TITLE=$(echo "$JSON_MSG" | jq -r '.title // ""' 2>/dev/null || echo "")
+        MSG_BODY=$(echo "$JSON_MSG" | jq -r '.body // ""' 2>/dev/null || echo "")
+        
+        if [ -n "$MSG_TITLE" ]; then
+            FULL_MESSAGE="$MSG_TYPE"
+            if [ -n "$MSG_SCOPE" ] && [ "$MSG_SCOPE" != "null" ]; then
+                FULL_MESSAGE="${FULL_MESSAGE}(${MSG_SCOPE})"
+            fi
+            FULL_MESSAGE="${FULL_MESSAGE}: ${MSG_TITLE}"
+            
+            if [ -n "$MSG_BODY" ] && [ "$MSG_BODY" != "null" ]; then
+                FULL_MESSAGE="${FULL_MESSAGE}\n\n${MSG_BODY}"
+            fi
+            
+            printf "%s\n" "$FULL_MESSAGE" > "$COMMIT_MSG_FILE"
+            log "📝 Mensaje generado: $(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"
+exit 1