claude-git-hooks 1.2.4 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,58 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2025-08-29
+
+### Added
+- 🎯 Prompts externalizados en archivos `.md` para facilitar personalización
+- 🤖 Generación automática de prompt AI-friendly para resolución de problemas críticos
+- 📝 Nuevos templates de prompts: `CLAUDE_ANALYSIS_PROMPT.md`, `CLAUDE_ANALYSIS_PROMPT_SONAR.md`, `CLAUDE_RESOLUTION_PROMPT.md`
+- 🔍 Localización precisa en blockingIssues (archivo, línea, método, severidad)
+- 📋 Archivo `claude_resolution_prompt.md` generado automáticamente con issues para resolver
+- 🚀 Flag `--skip-auth` para omitir verificación de autenticación en instalación
+- 📖 Ejemplos detallados de respuestas JSON con blocking issues en README
+
+### Changed
+- 🏗️ Estandarización de `blockingIssues` a formato objeto (nunca strings)
+- 📦 Separación de prompts del código para mayor mantenibilidad
+- 🔧 Hook pre-commit simplificado sin fallbacks complejos
+- 📁 Instalador actualizado para copiar todos los templates de prompts
+
+### Fixed
+- 🐛 Consistencia en el formato de respuesta JSON para ambos modos
+- 🔧 Mejor manejo de errores cuando faltan archivos de configuración
+
+### Technical
+- 🏗️ Función `generate_resolution_prompt()` para crear prompts de resolución
+- 📝 Templates de prompts con placeholders reemplazables
+- 🎯 Estructura JSON estricta para blockingIssues con campos obligatorios
+- 🔄 Instalación en modo force actualiza todos los templates
+
+## [1.3.0] - 2025-08-28
+
+### Added
+- 🚀 Nuevo comando `claude-hooks update` para actualizar a la última versión disponible
+- 🔄 Verificación automática de versión antes de cada commit con prompt interactivo
+- 📜 Script compartido `check-version.sh` para evitar duplicación de código
+- ✨ Prompt interactivo compatible con todas las consolas para aceptar actualizaciones
+- 📊 Mensajes informativos detallados durante el proceso de verificación y actualización
+
+### Changed
+- 🎯 El hook `pre-commit` ahora verifica automáticamente si hay actualizaciones disponibles
+- 📦 La instalación ahora incluye el script `check-version.sh` en `.git/hooks/`
+- 🔧 Mejorada la UX con mensajes claros sobre el estado de la versión
+
+### Fixed
+- 🐛 Corregido el parsing de versión desde NPM API (usaba endpoint incorrecto)
+- 🔧 Mejorada la compatibilidad del prompt interactivo para consolas IntelliJ/WSL
+- 📝 Múltiples métodos de fallback para leer input del usuario
+
+### Technical
+- 🏗️ Función `getLatestVersion()` ahora usa `dist-tags.latest` de NPM API
+- 🔄 Función `checkVersionAndPromptUpdate()` reutilizable para verificación
+- 📁 Script compartido para evitar duplicación de lógica de verificación
+- 🎯 Fallback a `npm view` si la API de NPM falla
+
 ## [1.2.4] - 2025-08-22
 
 ### Fixed

package/README.md

@@ -10,6 +10,9 @@ Este directorio contiene un pre-commit hook que utiliza Claude CLI para revisar
 - **`.gitattributes`** - Configuración para mantener line endings correctos
 - **`.claude/CLAUDE_PRE_COMMIT.md`** - Pautas de evaluación formato estándar
 - **`.claude/CLAUDE_PRE_COMMIT_SONAR.md`** - Pautas de evaluación formato SonarQube
+- **`.claude/CLAUDE_ANALYSIS_PROMPT.md`** - Template de prompt para análisis estándar
+- **`.claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md`** - Template de prompt para análisis SonarQube
+- **`.claude/CLAUDE_RESOLUTION_PROMPT.md`** - Template para generar prompt de resolución AI
 
 ## 🔧 Configuración Previa Importante
 
@@ -64,13 +67,19 @@ claude-hooks install
 ```
 
 El comando `claude-hooks install` ahora incluye:
+
 - ✅ Verificación completa de dependencias del sistema
 - ✅ Instalación automática de paquetes faltantes (jq, curl)
 - ✅ Configuración de Git (line endings WSL/Windows)
-- ✅ Verificación de autenticación Claude con entretenimiento
+- ✅ Verificación de autenticación Claude con entretenimiento (omitible con `--skip-auth`)
 - ✅ Instalación de hooks y archivos de pautas
 - ✅ Actualización automática de .gitignore con archivos de Claude
 
+**Opciones de instalación:**
+
+- `--force`: Reinstala aunque los hooks ya existan
+- `--skip-auth`: Omite la verificación de autenticación de Claude (útil para CI/CD)
+
 #### Añadir como Dependencia de Desarrollo
 
 ```bash
@@ -93,11 +102,11 @@ Luego añade esto a tu `package.json`:
 
 ## 🤖 Características
 
-**✨ Auto-actualización incorporada**: Los hooks se actualizan automáticamente en cada commit.
+**✨ Auto-actualización**: Verifica automáticamente si hay nuevas versiones disponibles antes de cada commit y ofrece actualizar con un simple prompt interactivo.
 
 **Hooks disponibles**:
 
-- `pre-commit`: Análisis de código con Claude (solo archivos Java/config)
+- `pre-commit`: Análisis de código con Claude (solo archivos Java/config) con verificación automática de versión
 - `prepare-commit-msg`: Generación automática de mensajes de commit
 
 ## 📁 Gestión de Archivos
@@ -108,10 +117,14 @@ El comando `claude-hooks install` crea los siguientes archivos y directorios:
 
 1. **`.git/hooks/pre-commit`** - Hook de análisis de código
 2. **`.git/hooks/prepare-commit-msg`** - Hook de generación de mensajes
-3. **`.claude/`** - Directorio para archivos de configuración
+3. **`.git/hooks/check-version.sh`** - Script de verificación de versión
+4. **`.claude/`** - Directorio para archivos de configuración
    - `CLAUDE_PRE_COMMIT.md` - Pautas de evaluación estándar
    - `CLAUDE_PRE_COMMIT_SONAR.md` - Pautas de evaluación SonarQube
-4. **`.claude-analysis-mode`** - Archivo de preferencia de modo (creado al primer uso)
+   - `CLAUDE_ANALYSIS_PROMPT.md` - Template de prompt para análisis estándar
+   - `CLAUDE_ANALYSIS_PROMPT_SONAR.md` - Template de prompt para análisis SonarQube
+   - `CLAUDE_RESOLUTION_PROMPT.md` - Template para prompt de resolución AI
+5. **`.claude-analysis-mode`** - Archivo de preferencia de modo (creado al primer uso)
 
 ### Actualización automática de .gitignore
 
@@ -122,9 +135,11 @@ Durante la instalación, Claude Hooks actualiza automáticamente tu `.gitignore`
 .claude/
 .claude-analysis-mode
 debug-claude-response.json
+claude_resolution_prompt.md
 ```
 
 Esto asegura que:
+
 - Los archivos de configuración de Claude específicos del proyecto no se suban al repositorio
 - Los archivos de debug temporales se ignoren
 - Cada desarrollador pueda tener sus propias preferencias de análisis
@@ -144,17 +159,28 @@ Si no existe un `.gitignore`, se creará uno nuevo. Si ya existe, las entradas s
    - **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/CLAUDE_PRE_COMMIT.md` o `.claude/CLAUDE_PRE_COMMIT_SONAR.md`
+   - Usa template de prompt desde `.claude/CLAUDE_ANALYSIS_PROMPT*.md`
+   - Lee las pautas desde `.claude/CLAUDE_PRE_COMMIT*.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**:
+6. **Procesa respuesta JSON estructurada**:
+   - blockingIssues siempre como objetos con localización precisa
    - 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 hay problemas críticos → genera prompt AI de resolución y bloquea commit
    - Si todo está bien → commit procede
 
+#### 🤖 Generación de Prompt de Resolución AI
+
+Cuando se detectan problemas críticos:
+
+- Se genera automáticamente un archivo `claude_resolution_prompt.md`
+- Contiene información estructurada y AI-friendly de todos los issues
+- Incluye localización precisa (archivo, línea, método)
+- Puede copiarse a otra instancia de Claude para resolución automática
+
 ### Hook prepare-commit-msg (Generación automática de mensajes)
 
 1. **Se activa cuando el mensaje es**:
@@ -172,7 +198,8 @@ Si no existe un `.gitignore`, se creará uno nuevo. Si ya existe, las entradas s
 
 ### Características adicionales
 
-- **Auto-actualización**: Los hooks se sincronizan automáticamente con las versiones en `git-hooks/`
+- **Auto-actualización**: Verificación automática de versiones antes de cada commit con prompt interactivo para actualizar
+- **Comando update**: `claude-hooks update` para actualizar manualmente a la última versión
 - **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
@@ -232,11 +259,13 @@ unset CLAUDE_ANALYSIS_MODE
 #### 📋 Diferencias entre Modos
 
 **Modo Estándar**:
+
 - Análisis con puntuación del 1-10
 - Recomendaciones detalladas por categoría
 - Formato tradicional fácil de leer
 
 **Modo SonarQube**:
+
 - Quality Gate (PASSED/FAILED)
 - Métricas: Reliability, Security, Maintainability
 - Issues clasificados por severidad (Blocker, Critical, Major, Minor, Info)
@@ -265,15 +294,111 @@ DEBUG=1 git commit -m "mensaje"
 
 ## 📊 Formato de Respuesta
 
-Claude responde con un JSON que incluye:
+Claude responde con un JSON estructurado que incluye:
+
+- `approved`: Si el commit es aprobado (boolean)
+- `score`: Puntuación del 1-10 (integer)
+- `blockingIssues`: Array de objetos con problemas críticos:
+  - `description`: Descripción del problema
+  - `file`: Archivo afectado
+  - `line`: Línea del problema
+  - `method`: Método o clase afectada
+  - `severity`: Severidad (critical, high, etc.)
+- `recommendations`: Array de strings con sugerencias no bloqueantes
+- `details`: Objeto con comentarios por categoría (security, performance, etc.)
+
+### Ejemplos de Respuestas con Problemas Críticos
+
+#### Modo Estándar - Commit Bloqueado
+
+```json
+{
+  "approved": false,
+  "score": 3,
+  "blockingIssues": [
+    {
+      "description": "SQL Injection vulnerability: concatenación directa de strings en query",
+      "file": "src/main/java/UserRepository.java",
+      "line": 45,
+      "method": "findUserByName",
+      "severity": "critical"
+    },
+    {
+      "description": "Posible NullPointerException: variable 'user' no validada",
+      "file": "src/main/java/UserService.java",
+      "line": 78,
+      "method": "processUser",
+      "severity": "high"
+    }
+  ],
+  "recommendations": [
+    "Usar PreparedStatement en lugar de concatenación de strings",
+    "Agregar validación de null antes de acceder a propiedades"
+  ]
+}
+```
+
+#### Modo SonarQube - Quality Gate Failed
+
+```json
+{
+  "QUALITY_GATE": "FAILED",
+  "approved": false,
+  "score": 4,
+  "metrics": {
+    "reliability": "D",
+    "security": "E",
+    "maintainability": "C"
+  },
+  "issues": {
+    "blocker": 1,
+    "critical": 2,
+    "major": 3,
+    "minor": 1
+  },
+  "blockingIssues": [
+    {
+      "description": "Security Hotspot: Hardcoded credentials detected",
+      "file": "src/main/resources/application.yml",
+      "line": 23,
+      "method": "datasource.password",
+      "severity": "blocker"
+    },
+    {
+      "description": "Resource leak: Connection not closed in finally block",
+      "file": "src/main/java/DatabaseUtil.java",
+      "line": 112,
+      "method": "executeQuery",
+      "severity": "critical"
+    }
+  ],
+  "details": [
+    {
+      "severity": "BLOCKER",
+      "type": "VULNERABILITY",
+      "file": "src/main/resources/application.yml",
+      "line": 23,
+      "message": "Never store passwords in plain text",
+      "rule": "java:S2068"
+    }
+  ]
+}
+```
+
+Cuando se detectan estos problemas críticos, se genera automáticamente un archivo `claude_resolution_prompt.md` con toda la información necesaria para que otra instancia de Claude pueda resolver los issues de forma eficiente.
 
-- `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
+## 🔄 Actualización y Gestión
 
-## 🔄 Desactivar/Activar
+### Actualizar a la última versión
+
+```bash
+# Actualizar manualmente a la última versión
+claude-hooks update
+```
+
+El comando `update` descarga e instala automáticamente la última versión disponible desde NPM, y luego reinstala los hooks con las nuevas características.
+
+### Desactivar/Activar hooks
 
 ```bash
 # Desactivar todos los hooks
@@ -383,11 +508,24 @@ Este problema suele ocurrir por conflictos de configuración de line endings:
 
 ## 📝 Personalización
 
-Puedes modificar las pautas de evaluación editando los archivos en el directorio `.claude/`:
-- `.claude/CLAUDE_PRE_COMMIT.md` - Para el modo estándar
-- `.claude/CLAUDE_PRE_COMMIT_SONAR.md` - Para el modo SonarQube
+### Archivos de Configuración en `.claude/`
+
+#### Pautas de Evaluación
+
+- **`CLAUDE_PRE_COMMIT.md`** - Criterios de evaluación para modo estándar
+- **`CLAUDE_PRE_COMMIT_SONAR.md`** - Criterios para modo SonarQube
+
+#### Templates de Prompts
 
-Estos archivos son específicos de tu proyecto y puedes adaptarlos a los estándares de tu equipo.
+- **`CLAUDE_ANALYSIS_PROMPT.md`** - Estructura del prompt de análisis estándar
+- **`CLAUDE_ANALYSIS_PROMPT_SONAR.md`** - Estructura del prompt SonarQube
+- **`CLAUDE_RESOLUTION_PROMPT.md`** - Template para generar prompts de resolución
+
+Todos estos archivos son personalizables y específicos de tu proyecto. Puedes:
+
+- Modificar los criterios de evaluación según estándares del equipo
+- Ajustar la estructura de los prompts para obtener respuestas más precisas
+- Personalizar el formato de salida del prompt de resolución
 
 ## 🔄 Arquitectura del Sistema
 
@@ -562,11 +700,3 @@ git commit -m "auto"
 3. **Commit** tus cambios: `git commit -m "feat: nueva funcionalidad"`
 4. **Push** al branch: `git push origin feature/nueva-funcionalidad`
 5. **Abrir Pull Request**
-
-### Roadmap
-
-- [ ] Soporte para más lenguajes (Python, JavaScript, etc.)
-- [ ] Configuración más granular por proyecto
-- [ ] Integration con IDEs populares
-- [ ] Métricas de uso y performance
-- [ ] Tests automatizados

package/bin/claude-hooks

@@ -7,6 +7,86 @@ const os = require('os');
 const readline = require('readline');
 const https = require('https');
 
+// Función para obtener la última versión desde NPM
+function getLatestVersion(packageName) {
+  return new Promise((resolve, reject) => {
+    // Usar la API principal de NPM, no /latest
+    https.get(`https://registry.npmjs.org/${packageName}`, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          // Obtener la versión del tag 'latest'
+          if (json['dist-tags'] && json['dist-tags'].latest) {
+            resolve(json['dist-tags'].latest);
+          } else {
+            reject(new Error('No se pudo obtener la versión'));
+          }
+        } catch (e) {
+          // Si falla, intentar con npm view
+          try {
+            const version = execSync(`npm view ${packageName} version`, { encoding: 'utf8' }).trim();
+            resolve(version);
+          } catch (npmError) {
+            reject(e);
+          }
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+// Función para verificar versión (usada por los hooks)
+async function checkVersionAndPromptUpdate() {
+  try {
+    const currentVersion = require('../package.json').version;
+    const latestVersion = await getLatestVersion('claude-git-hooks');
+    
+    if (currentVersion === latestVersion) {
+      return true; // Ya actualizado
+    }
+    
+    console.log('');
+    warning(`Nueva versión disponible: ${latestVersion} (actual: ${currentVersion})`);
+    
+    // Prompt interactivo compatible con todas las consolas
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    return new Promise((resolve) => {
+      rl.question('¿Deseas actualizar ahora? (s/n): ', (answer) => {
+        rl.close();
+        
+        if (answer.toLowerCase() === 's' || answer.toLowerCase() === 'si' || answer.toLowerCase() === 'sí' || answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y') {
+          info('Actualizando claude-git-hooks...');
+          try {
+            execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
+            success('Actualización completada. Por favor, vuelve a ejecutar tu comando.');
+            process.exit(0); // Salir para que el usuario reinicie el proceso
+          } catch (e) {
+            error('Error al actualizar: ' + e.message);
+            resolve(false);
+          }
+        } else {
+          info('Actualización pospuesta. Puedes actualizar más tarde con: claude-hooks update');
+          resolve(true); // Continuar sin actualizar
+        }
+      });
+    });
+  } catch (e) {
+    // Si hay error verificando la versión, continuar sin bloquear
+    return true;
+  }
+}
+
+// Exportar para uso en hooks
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { checkVersionAndPromptUpdate };
+}
+
 // Colores para output
 const colors = {
   reset: '\x1b[0m',
@@ -258,7 +338,14 @@ async function install(args) {
     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 isForce = args.includes('--force');
+  const skipAuth = args.includes('--skip-auth');
+  
+  if (isForce) {
+    info('Instalando Claude Git Hooks (modo force)...');
+  } else {
+    info('Instalando Claude Git Hooks...');
+  }
 
   // Solicitar contraseña sudo al inicio si es necesario
   let sudoPassword = null;
@@ -278,7 +365,7 @@ async function install(args) {
   }
 
   // Verificar dependencias con instalación automática
-  await checkAndInstallDependencies(sudoPassword);
+  await checkAndInstallDependencies(sudoPassword, skipAuth);
 
   const templatesPath = getTemplatesPath();
   const hooksPath = '.git/hooks';
@@ -308,6 +395,16 @@ async function install(args) {
     success(`${hook} instalado`);
   });
 
+  // Copiar script de verificación de versión
+  const checkVersionSource = path.join(templatesPath, 'check-version.sh');
+  const checkVersionDest = path.join(hooksPath, 'check-version.sh');
+  
+  if (fs.existsSync(checkVersionSource)) {
+    fs.copyFileSync(checkVersionSource, checkVersionDest);
+    fs.chmodSync(checkVersionDest, '755');
+    success('Script de verificación de versión instalado');
+  }
+
   // Crear directorio .claude si no existe
   const claudeDir = '.claude';
   if (!fs.existsSync(claudeDir)) {
@@ -315,15 +412,26 @@ async function install(args) {
     success('.claude directory created');
   }
 
-  // Copiar archivos de pautas a .claude si no existen
-  const guidelines = ['CLAUDE_PRE_COMMIT.md', 'CLAUDE_PRE_COMMIT_SONAR.md'];
-  guidelines.forEach(guideline => {
-    const destPath = path.join(claudeDir, guideline);
-    if (!fs.existsSync(destPath)) {
-      const sourcePath = path.join(templatesPath, guideline);
+  // Copiar archivos de pautas y prompts a .claude
+  const claudeFiles = [
+    'CLAUDE_PRE_COMMIT.md', 
+    'CLAUDE_PRE_COMMIT_SONAR.md',
+    'CLAUDE_ANALYSIS_PROMPT.md',
+    'CLAUDE_ANALYSIS_PROMPT_SONAR.md',
+    'CLAUDE_RESOLUTION_PROMPT.md'
+  ];
+  
+  claudeFiles.forEach(file => {
+    const destPath = path.join(claudeDir, file);
+    const sourcePath = path.join(templatesPath, file);
+    
+    // En modo force o si no existe, copiar el archivo
+    if (isForce || !fs.existsSync(destPath)) {
       if (fs.existsSync(sourcePath)) {
         fs.copyFileSync(sourcePath, destPath);
-        success(`${guideline} creado en .claude/`);
+        success(`${file} instalado en .claude/`);
+      } else {
+        warning(`Archivo de template no encontrado: ${file}`);
       }
     }
   });
@@ -342,7 +450,7 @@ async function install(args) {
 }
 
 // Verificar dependencias completas (como setup-wsl.sh)
-async function checkAndInstallDependencies(sudoPassword = null) {
+async function checkAndInstallDependencies(sudoPassword = null, skipAuth = false) {
   info('Verificando dependencias del sistema...');
   
   // Verificar Node.js
@@ -420,14 +528,18 @@ async function checkAndInstallDependencies(sudoPassword = null) {
   if (missingTools.length === 0) {
     success('Herramientas Unix estándar verificadas');
   } else {
-    error(`Faltan herramientas Unix estándar: ${missingTools.join(', ')}`);
+    error(`Faltan herramientas Unix estándar: ${missingTools.join(', ')}. Reintenta instalación en una consola Ubuntu`);
   }
   
   // Verificar e instalar Claude CLI
   await checkAndInstallClaude();
   
-  // Verificar autenticación de Claude
-  await checkClaudeAuth();
+  // Verificar autenticación de Claude (si no se salta)
+  if (!skipAuth) {
+    await checkClaudeAuth();
+  } else {
+    warning('Saltando verificación de autenticación de Claude (--skip-auth)');
+  }
   
   // Limpiar contraseña de memoria
   sudoPassword = null;
@@ -523,7 +635,8 @@ function updateGitignore() {
     '# Claude Git Hooks',
     '.claude/',
     '.claude-analysis-mode',
-    'debug-claude-response.json'
+    'debug-claude-response.json',
+    'claude_resolution_prompt.md'
   ];
   
   let gitignoreContent = '';
@@ -785,6 +898,87 @@ function setMode(mode) {
   }
 }
 
+// Función para comparar versiones usando el script compartido
+function compareVersions(v1, v2) {
+  try {
+    // Usar el script compartido para mantener consistencia
+    const result = execSync(`bash -c 'source "${getTemplatesPath()}/check-version.sh" && compare_versions "${v1}" "${v2}"; echo $?'`, { encoding: 'utf8' }).trim();
+    const exitCode = parseInt(result);
+    
+    // Convertir los códigos de retorno del script bash a valores JS
+    if (exitCode === 0) return 0;      // iguales
+    if (exitCode === 1) return 1;      // v1 > v2  
+    if (exitCode === 2) return -1;     // v1 < v2
+    
+    // Fallback: comparación simple si el script falla
+    if (v1 === v2) return 0;
+    const sorted = [v1, v2].sort((a, b) => {
+      const aParts = a.split('.').map(Number);
+      const bParts = b.split('.').map(Number);
+      for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aPart = aParts[i] || 0;
+        const bPart = bParts[i] || 0;
+        if (aPart !== bPart) return aPart - bPart;
+      }
+      return 0;
+    });
+    return v1 === sorted[1] ? 1 : -1;
+  } catch (e) {
+    // Si falla todo, usar comparación simple
+    if (v1 === v2) return 0;
+    return v1 > v2 ? 1 : -1;
+  }
+}
+
+// Comando update - actualizar a la última versión
+async function update() {
+  info('Verificando última versión disponible...');
+  
+  try {
+    const currentVersion = require('../package.json').version;
+    const latestVersion = await getLatestVersion('claude-git-hooks');
+    
+    const comparison = compareVersions(currentVersion, latestVersion);
+    
+    if (comparison === 0) {
+      success(`Ya tienes la última versión instalada (${currentVersion})`);
+      return;
+    } else if (comparison > 0) {
+      info(`Estás usando una versión de desarrollo (${currentVersion})`);
+      info(`Última versión publicada: ${latestVersion}`);
+      success(`Ya tienes la última versión instalada (${currentVersion})`);
+      return;
+    }
+    
+    info(`Versión actual: ${currentVersion}`);
+    info(`Versión disponible: ${latestVersion}`);
+    
+    // Actualizar el paquete
+    info('Actualizando claude-git-hooks...');
+    try {
+      execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
+      success(`Actualizado exitosamente a la versión ${latestVersion}`);
+      
+      // Reinstalar hooks con la nueva versión
+      info('Reinstalando hooks con la nueva versión...');
+      await install(['--force']);
+      
+    } catch (updateError) {
+      error('Error al actualizar. Intenta ejecutar: npm install -g claude-git-hooks@latest');
+    }
+  } catch (e) {
+    warning('No se pudo verificar la última versión disponible');
+    warning('Intentando actualizar de todas formas...');
+    try {
+      execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
+      success('Actualización completada');
+      await install(['--force']);
+    } catch (updateError) {
+      error('Error al actualizar: ' + updateError.message);
+    }
+  }
+}
+
 // Comando help
 function showHelp() {
   console.log(`
@@ -793,7 +987,10 @@ 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
+  install [opciones]   Instala los hooks en el repositorio actual
+    --force           Reinstala aunque ya existan
+    --skip-auth       Salta la verificación de autenticación de Claude
+  update               Actualiza a la última versión disponible
   uninstall            Desinstala los hooks del repositorio
   enable [hook]        Habilita hooks (todos o uno específico)
   disable [hook]       Deshabilita hooks (todos o uno específico)
@@ -807,6 +1004,8 @@ Hooks disponibles:
 
 Ejemplos:
   claude-hooks install              # Instala todos los hooks
+  claude-hooks install --skip-auth  # Instala sin verificar autenticación
+  claude-hooks update               # Actualiza a la última versión
   claude-hooks set-mode sonar       # Cambiar a modo SonarQube
   claude-hooks set-mode standard    # Cambiar a modo estándar
   claude-hooks disable pre-commit   # Deshabilita solo pre-commit
@@ -826,6 +1025,9 @@ async function main() {
     case 'install':
       await install(args.slice(1));
       break;
+    case 'update':
+      await update();
+      break;
     case 'uninstall':
       uninstall();
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-git-hooks",
-  "version": "1.2.4",
+  "version": "1.4.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": {

package/templates/CLAUDE_ANALYSIS_PROMPT.md

@@ -0,0 +1,44 @@
+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:
+
+```json
+{
+  "approved": true,                // true si el commit puede aceptarse, false si debe bloquearse
+  "score": 1-10,                   // calificación de calidad (entero)
+  "blockingIssues": [             // SIEMPRE array de objetos, nunca strings
+    {
+      "description": "texto descriptivo del problema",
+      "file": "path/to/file.java",
+      "line": 123,                // línea donde se detectó el problema
+      "method": "methodName",      // método o clase afectada
+      "severity": "critical"       // critical, high, medium, low
+    }
+  ],
+  "recommendations": [            // sugerencias no bloqueantes (array de strings)
+    "mejora 1",
+    "mejora 2"
+  ],
+  "details": {
+    "security": [                 // comentarios específicos por área
+      "observación sobre seguridad"
+    ],
+    "architecture": [ "..." ],
+    "performance": [ "..." ],
+    "maintainability": [ "..." ]
+  }
+}
+```
+
+✅ Importante:
+- blockingIssues SIEMPRE debe ser un array de objetos, NUNCA un array de strings
+- Cada blockingIssue DEBE incluir: description, file, line, method, severity
+- Usa listas vacías si no hay issues (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
+- Los problemas críticos deben incluir contexto suficiente para que otra IA pueda resolverlos
+
+A continuación se detallan las pautas y los cambios:

package/templates/CLAUDE_ANALYSIS_PROMPT_SONAR.md

@@ -0,0 +1,61 @@
+Eres un revisor de código senior con experiencia en proyectos Spring Boot empresariales y métricas SonarQube.
+
+Tu tarea es analizar los siguientes cambios de código desde una perspectiva de calidad similar a SonarQube 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 de SonarQube:
+
+```json
+{
+  "QUALITY_GATE": "PASSED",          // PASSED o FAILED
+  "approved": true,                  // compatibilidad con modo estándar
+  "score": 1-10,                      // calificación general
+  "metrics": {
+    "reliability": "A",              // A, B, C, D, E
+    "security": "A",                 // A, B, C, D, E  
+    "maintainability": "A",          // A, B, C, D, E
+    "coverage": 85,                  // porcentaje de cobertura estimado
+    "duplications": 2,               // porcentaje de duplicación estimado
+    "complexity": 15                 // complejidad ciclomática estimada
+  },
+  "issues": {
+    "blocker": 0,                    // cantidad de issues bloqueantes
+    "critical": 0,                   // cantidad de issues críticos
+    "major": 0,                      // cantidad de issues mayores
+    "minor": 0,                      // cantidad de issues menores
+    "info": 0                        // cantidad de issues informativos
+  },
+  "details": [                       // detalle de cada issue encontrado con localización
+    {
+      "severity": "CRITICAL",        // BLOCKER, CRITICAL, MAJOR, MINOR, INFO
+      "type": "BUG",                 // BUG, VULNERABILITY, CODE_SMELL
+      "file": "src/main/java/Example.java",
+      "line": 42,
+      "method": "processData",      // método o clase afectada
+      "message": "Null pointer dereference possible",
+      "rule": "java:S2259"          // regla de SonarQube (opcional)
+    }
+  ],
+  "blockingIssues": [               // SIEMPRE array de objetos con issues BLOCKER y CRITICAL
+    {
+      "description": "texto descriptivo del problema",
+      "file": "path/to/file.java",
+      "line": 123,
+      "method": "methodName",
+      "severity": "critical"         // solo "blocker" o "critical" aquí
+    }
+  ],
+  "securityHotspots": 0             // cantidad de security hotspots
+}
+```
+
+✅ Importante:
+- blockingIssues SIEMPRE debe ser un array de objetos, NUNCA un array de strings
+- blockingIssues debe contener TODOS los issues BLOCKER y CRITICAL del array details
+- Cada blockingIssue DEBE incluir: description, file, line, method, severity
+- El QUALITY_GATE debe ser FAILED si hay issues BLOCKER o CRITICAL
+- Los ratings (A-E) deben reflejar la calidad real del código
+- Para cada issue en details, SIEMPRE incluye file, line y method para localización precisa
+- No uses texto fuera del JSON
+- Sé preciso con las localizaciones para facilitar la resolución automatizada
+
+A continuación se detallan las pautas y los cambios:

package/templates/CLAUDE_RESOLUTION_PROMPT.md

@@ -0,0 +1,46 @@
+# AI Resolution Assistant Prompt
+
+You are an expert code reviewer tasked with resolving critical issues identified in a code review. Your goal is to provide precise, minimal, and efficient fixes.
+
+## Context
+Repository: {{REPO_NAME}}
+Branch: {{BRANCH_NAME}}
+Commit: {{COMMIT_SHA}}
+Files analyzed: {{FILE_COUNT}}
+Analysis mode: {{ANALYSIS_MODE}}
+
+## Critical Issues to Resolve
+
+{{BLOCKING_ISSUES}}
+
+## Affected Files Content
+
+{{FILE_CONTENTS}}
+
+## Instructions
+
+1. For each critical issue:
+   - Navigate to the exact file and line number specified
+   - Understand the context and the problem
+   - Apply the minimal fix required
+   - Ensure the fix doesn't introduce new issues
+
+2. Fix requirements:
+   - Make the smallest possible change to resolve the issue
+   - Maintain existing code style and conventions
+   - Don't refactor unrelated code
+   - Preserve all existing functionality
+
+3. Output format:
+   - Provide exact code changes using diff format
+   - Include file path, line numbers, and context
+   - Explain each fix briefly (one line max)
+
+## Fix Priority
+1. Security vulnerabilities (highest)
+2. Null pointer / runtime errors
+3. Logic errors
+4. Performance issues
+5. Code quality issues (lowest)
+
+Begin fixing the issues in order of severity.

package/templates/check-version.sh

@@ -0,0 +1,266 @@
+#!/bin/bash
+
+# Script compartido para verificar versión de claude-git-hooks
+# Este script puede ser invocado desde cualquier hook
+
+# Colores para 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
+log() {
+    echo -e "${GREEN}[VERSION-CHECK]${NC} $1"
+}
+
+error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+# Función compartida para comparar versiones semánticas
+# Retorna: 1 si v1 > v2, 2 si v1 < v2, 0 si son iguales
+compare_versions() {
+    local v1="$1"
+    local v2="$2"
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] compare_versions: comparando '$v1' con '$v2'"
+    fi
+    
+    # Si son exactamente iguales
+    if [ "$v1" = "$v2" ]; then
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] compare_versions: versiones iguales, retornando 0"
+        fi
+        return 0
+    fi
+    
+    # Usar sort -V que entiende versiones semánticas correctamente
+    local sorted=$(printf "%s\n%s" "$v1" "$v2" | sort -V)
+    local smaller=$(echo "$sorted" | head -1)
+    local larger=$(echo "$sorted" | tail -1)
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] compare_versions: sorted='$sorted', smaller='$smaller', larger='$larger'"
+    fi
+    
+    if [ "$v1" = "$larger" ]; then
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] compare_versions: v1 es mayor, retornando 1"
+        fi
+        return 1  # v1 es mayor que v2
+    else
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] compare_versions: v1 es menor, retornando 2"
+        fi
+        return 2  # v1 es menor que v2 (cambié de 255 a 2 para evitar problemas con set -e)
+    fi
+}
+
+# Función principal de verificación
+check_version() {
+    # Debug mode si está activado
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Iniciando verificación de versión..."
+    fi
+    
+    info "Verificando versión instalada..."
+    
+    # Intentar obtener versión actual desde package.json global
+    CURRENT_VERSION=""
+    NPM_PREFIX=$(npm prefix -g 2>/dev/null || echo "/usr/local")
+    PACKAGE_JSON_PATHS=(
+        "$NPM_PREFIX/lib/node_modules/claude-git-hooks/package.json"
+        "/usr/lib/node_modules/claude-git-hooks/package.json"
+        "/usr/local/lib/node_modules/claude-git-hooks/package.json"
+        "$HOME/.npm-global/lib/node_modules/claude-git-hooks/package.json"
+    )
+    
+    for path in "${PACKAGE_JSON_PATHS[@]}"; do
+        if [ -f "$path" ]; then
+            CURRENT_VERSION=$(grep '"version"' "$path" 2>/dev/null | sed 's/.*"version".*"\(.*\)".*/\1/')
+            break
+        fi
+    done
+    
+    if [ -z "$CURRENT_VERSION" ]; then
+        warning "No se pudo determinar la versión actual"
+        return 0  # Continuar sin bloquear
+    fi
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Versión actual encontrada: $CURRENT_VERSION"
+    fi
+    
+    # Obtener última versión desde NPM (usando npm view que es más confiable)
+    info "Verificando última versión disponible..."
+    
+    # Método principal: usar npm view que es más confiable
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Ejecutando: npm view claude-git-hooks version"
+    fi
+    
+    LATEST_VERSION=$(npm view claude-git-hooks version 2>/dev/null || echo "")
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] npm view retornó: '$LATEST_VERSION'"
+        echo "[DEBUG] Longitud de LATEST_VERSION: ${#LATEST_VERSION}"
+    fi
+    
+    # Si npm view falla, intentar con la API de NPM
+    if [ -z "$LATEST_VERSION" ]; then
+        # Obtener el JSON completo y extraer dist-tags.latest con jq si está disponible
+        if command -v jq &> /dev/null; then
+            LATEST_VERSION=$(curl -s https://registry.npmjs.org/claude-git-hooks 2>/dev/null | jq -r '."dist-tags".latest' 2>/dev/null || echo "")
+            if [ -n "$DEBUG_VERSION" ]; then
+                echo "[DEBUG] jq parsing retornó: '$LATEST_VERSION'"
+            fi
+        else
+            # Sin jq, usar método más robusto con sed
+            LATEST_VERSION=$(curl -s https://registry.npmjs.org/claude-git-hooks 2>/dev/null | sed -n 's/.*"dist-tags":{[^}]*"latest":"\([^"]*\)".*/\1/p' | head -1)
+            if [ -n "$DEBUG_VERSION" ]; then
+                echo "[DEBUG] sed parsing retornó: '$LATEST_VERSION'"
+            fi
+        fi
+    fi
+    
+    # Validar que lo obtenido parece una versión (formato X.Y.Z)
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Validando versión: '$LATEST_VERSION'"
+    fi
+    
+    if ! echo "$LATEST_VERSION" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+' ; then
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] Versión obtenida no es válida: '$LATEST_VERSION'"
+        fi
+        warning "No se pudo obtener una versión válida del registro NPM"
+        return 0
+    fi
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Versión válida confirmada: '$LATEST_VERSION'"
+    fi
+    
+    if [ -z "$LATEST_VERSION" ]; then
+        # Si no se puede obtener la versión, continuar sin bloquear
+        return 0
+    fi
+    
+    if [ "$CURRENT_VERSION" = "$LATEST_VERSION" ]; then
+        log "Versión actual ($CURRENT_VERSION) está actualizada ✓"
+        return 0
+    fi
+    
+    # Comparar versiones usando la función compartida
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Comparando versiones: '$CURRENT_VERSION' vs '$LATEST_VERSION'"
+    fi
+    
+    # Deshabilitar set -e temporalmente para capturar el código de retorno
+    set +e
+    compare_versions "$CURRENT_VERSION" "$LATEST_VERSION"
+    comparison_result=$?
+    set -e
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] Resultado de comparación: $comparison_result"
+    fi
+    
+    if [ $comparison_result -eq 0 ]; then
+        # Las versiones son iguales
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] Las versiones son iguales"
+        fi
+        log "Versión actual ($CURRENT_VERSION) está actualizada ✓"
+        return 0
+    elif [ $comparison_result -eq 1 ]; then
+        # La versión actual es mayor que la publicada (desarrollo local)
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] Versión local ($CURRENT_VERSION) es más nueva que la publicada ($LATEST_VERSION)"
+        fi
+        log "Versión de desarrollo ($CURRENT_VERSION) > versión publicada ($LATEST_VERSION) ✓"
+        return 0
+    elif [ $comparison_result -eq 2 ]; then
+        # La versión publicada es mayor, continuar con prompt de actualización
+        if [ -n "$DEBUG_VERSION" ]; then
+            echo "[DEBUG] La versión publicada ($LATEST_VERSION) es más nueva que la local ($CURRENT_VERSION)"
+        fi
+        # Continuar con el prompt de actualización (no return aquí)
+    fi
+    
+    if [ -n "$DEBUG_VERSION" ]; then
+        echo "[DEBUG] La versión publicada es más nueva, procediendo con prompt de actualización"
+    fi
+    
+    # Solo mostrar actualización si la versión publicada es realmente más nueva
+    echo
+    warning "Nueva versión disponible: $LATEST_VERSION (actual: $CURRENT_VERSION)"
+    echo -e "${YELLOW}╭─────────────────────────────────────────────╮${NC}"
+    echo -e "${YELLOW}│${NC} Una nueva versión de claude-git-hooks está ${YELLOW}│${NC}"
+    echo -e "${YELLOW}│${NC} disponible con mejoras y correcciones      ${YELLOW}│${NC}"
+    echo -e "${YELLOW}╰─────────────────────────────────────────────╯${NC}"
+    echo
+    
+    # Leer respuesta del usuario de forma compatible con todas las consolas
+    echo -n "¿Deseas actualizar ahora? (s/n): "
+    
+    # Intentar varios métodos de lectura para máxima compatibilidad
+    REPLY=""
+    
+    # Método 1: Leer desde /dev/tty si existe
+    if [ -c /dev/tty ]; then
+        read -r REPLY </dev/tty 2>/dev/null || REPLY=""
+    fi
+    
+    # Método 2: Si falla, intentar leer desde stdin estándar
+    if [ -z "$REPLY" ]; then
+        read -r REPLY 2>/dev/null || REPLY=""
+    fi
+    
+    # Método 3: Si aún no tenemos respuesta, usar bash -c
+    if [ -z "$REPLY" ]; then
+        REPLY=$(bash -c 'read -r reply && echo "$reply"' 2>/dev/null || echo "")
+    fi
+    
+    # Si ningún método funcionó, informar y continuar
+    if [ -z "$REPLY" ]; then
+        echo
+        info "No se pudo leer la respuesta. Continuando sin actualizar."
+        info "Para actualizar manualmente, ejecuta: claude-hooks update"
+        return 0
+    fi
+    
+    if [ "$REPLY" = "s" ] || [ "$REPLY" = "S" ] || [ "$REPLY" = "si" ] || [ "$REPLY" = "SI" ] || [ "$REPLY" = "sí" ] || [ "$REPLY" = "SÍ" ] || [ "$REPLY" = "y" ] || [ "$REPLY" = "Y" ] || [ "$REPLY" = "yes" ] || [ "$REPLY" = "YES" ]; then
+        echo
+        info "Actualizando claude-git-hooks..."
+        
+        if npm install -g claude-git-hooks@latest; then
+            echo
+            log "✅ Actualización completada exitosamente"
+            info "Por favor, vuelve a ejecutar tu comando git commit"
+            exit 0  # Salir para que el usuario reinicie con la nueva versión
+        else
+            error "Error al actualizar. Intenta manualmente con: npm install -g claude-git-hooks@latest"
+            return 1
+        fi
+    else
+        info "Actualización pospuesta. Puedes actualizar más tarde con: claude-hooks update"
+        echo
+        return 0
+    fi
+}
+
+# Si se ejecuta directamente (no como source), ejecutar la verificación
+if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
+    check_version
+fi

package/templates/pre-commit

@@ -14,6 +14,7 @@ MAX_FILE_SIZE=100000  # 100KB máximo por archivo
 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
@@ -29,6 +30,103 @@ 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_SCRIPT=""
+# Buscar en múltiples ubicaciones posibles
+SCRIPT_PATHS=(
+    "$(dirname "$0")/check-version.sh"
+    "/usr/local/lib/node_modules/claude-git-hooks/templates/check-version.sh"
+    "/usr/lib/node_modules/claude-git-hooks/templates/check-version.sh"
+    "$HOME/.npm-global/lib/node_modules/claude-git-hooks/templates/check-version.sh"
+    "$(npm prefix -g 2>/dev/null)/lib/node_modules/claude-git-hooks/templates/check-version.sh"
+)
+
+for path in "${SCRIPT_PATHS[@]}"; do
+    if [ -f "$path" ]; then
+        CHECK_VERSION_SCRIPT="$path"
+        break
+    fi
+done
+
+# Si encontramos el script, ejecutarlo
+if [ -n "$CHECK_VERSION_SCRIPT" ]; then
+    # Source el script para tener acceso a la función
+    source "$CHECK_VERSION_SCRIPT"
+    check_version
+fi
+
+# Función para generar prompt de resolución AI-friendly
+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"
+        return
+    fi
+    
+    # Obtener información del contexto
+    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
+    local ISSUES_FORMATTED=""
+    local issue_num=1
+    
+    # Parsear cada blocking issue como objeto JSON
+    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')
+            local file=$(echo "$issue" | jq -r '.file')
+            local line=$(echo "$issue" | jq -r '.line')
+            local method=$(echo "$issue" | jq -r '.method')
+            local severity=$(echo "$issue" | jq -r '.severity')
+            
+            ISSUES_FORMATTED="${ISSUES_FORMATTED}### Issue #${issue_num} [${severity^^}]\n"
+            ISSUES_FORMATTED="${ISSUES_FORMATTED}**Description:** ${desc}\n"
+            ISSUES_FORMATTED="${ISSUES_FORMATTED}**Location:** ${file}:${line}\n"
+            ISSUES_FORMATTED="${ISSUES_FORMATTED}**Method/Class:** ${method}\n\n"
+            issue_num=$((issue_num + 1))
+        fi
+    done
+    
+    # Generar el prompt desde el template
+    cp "$RESOLUTION_TEMPLATE" "$RESOLUTION_FILE"
+    
+    # Reemplazar placeholders
+    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"
+    sed -i "s|{{ANALYSIS_MODE}}|$ANALYSIS_MODE|g" "$RESOLUTION_FILE"
+    
+    # Agregar los issues formateados
+    sed -i "/{{BLOCKING_ISSUES}}/r /dev/stdin" "$RESOLUTION_FILE" <<< "$ISSUES_FORMATTED"
+    sed -i "s|{{BLOCKING_ISSUES}}||g" "$RESOLUTION_FILE"
+    
+    # Agregar contenido de archivos afectados
+    local FILES_CONTENT=""
+    echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].file' 2>/dev/null | sort -u | while IFS= read -r file; do
+        if [ -f "$file" ]; then
+            FILES_CONTENT="${FILES_CONTENT}### File: $file\n\n\`\`\`\n"
+            FILES_CONTENT="${FILES_CONTENT}$(cat "$file")\n"
+            FILES_CONTENT="${FILES_CONTENT}\`\`\`\n\n"
+        fi
+    done
+    
+    sed -i "/{{FILE_CONTENTS}}/r /dev/stdin" "$RESOLUTION_FILE" <<< "$FILES_CONTENT"
+    sed -i "s|{{FILE_CONTENTS}}||g" "$RESOLUTION_FILE"
+    
+    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
+}
+
 # Detectar qué archivo de pautas usar
 # Prioridad: variable de entorno > archivo > pregunta interactiva
 if [ -n "$CLAUDE_ANALYSIS_MODE" ]; then
@@ -65,9 +163,11 @@ if [ "$ANALYSIS_MODE" != "standard" ] && [ "$ANALYSIS_MODE" != "sonar" ]; then
     if [ "$REPLY" = "2" ]; then
         ANALYSIS_MODE="sonar"
         GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
+        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
     else
         ANALYSIS_MODE="standard"
         GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
+        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT.md"
     fi
     
     # Guardar preferencia para futuros commits
@@ -79,12 +179,23 @@ else
     # Usar modo guardado
     if [ "$ANALYSIS_MODE" = "sonar" ]; then
         GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
+        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
         log "Usando modo de análisis: SonarQube"
     else
         GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
+        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT.md"
         log "Usando modo de análisis: Estándar"
     fi
 fi
+
+# Verificar que el template de prompt existe
+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 "  claude-hooks install --force"
+    exit 1
+fi
 # Función para limpiar archivos temporales
 cleanup() {
     rm -rf "$TEMP_DIR"
@@ -113,9 +224,10 @@ 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
+    error "No se encontró el archivo de pautas: $GUIDELINES_FILE"
+    error "Por favor, reinstala claude-git-hooks ejecutando:"
+    error "  claude-hooks install --force"
+    exit 1
 fi
 
 log "Archivos Java/config a revisar: $(echo "$JAVA_FILES" | wc -l)"
@@ -123,42 +235,8 @@ 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
+# Copiar el template de prompt
+cat "$PROMPT_TEMPLATE" > "$PROMPT_FILE"
 
 # Agregar las pautas
 echo "=== PAUTAS DE EVALUACIÓN ===" >> "$PROMPT_FILE"
@@ -230,7 +308,14 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
     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')
+    
+    # Parsear blockingIssues como objetos y extraer las descripciones
+    BLOCKING_ISSUES=""
+    BLOCKING_COUNT=$(echo "$JSON_RESPONSE" | jq '.blockingIssues | length' 2>/dev/null || echo "0")
+    
+    if [ "$BLOCKING_COUNT" -gt 0 ]; then
+        BLOCKING_ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].description' 2>/dev/null | sed '/^$/d')
+    fi
     
     # Verificar si estamos en modo SonarQube
     QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.QUALITY_GATE // ""' 2>/dev/null)
@@ -329,6 +414,9 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
                 echo
                 echo "=== PROBLEMAS CRÍTICOS ==="
                 echo "$BLOCKING_ISSUES" | sed 's/^/- /'
+                
+                # Generar prompt de resolución AI-friendly
+                generate_resolution_prompt
             fi
             exit 1
         fi