claude-git-hooks 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -5,6 +5,65 @@ 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.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
+- 🐛 Corregido el análisis de SonarQube para mostrar correctamente el formato detallado
+- 📊 Arreglado el parsing de JSON para buscar `QUALITY_GATE` en mayúsculas según las pautas
+- 🔧 Actualizado el mapeo de campos JSON para coincidir con la estructura esperada
+
+### Changed
+- 📈 Añadidas métricas de coverage, duplications y complexity al formato SonarQube
+- 📝 Actualizado el archivo de pautas SonarQube para incluir todas las métricas
+
+## [1.2.3] - 2025-08-22
+
+### Added
+- 🚀 Actualización automática de `.gitignore` durante la instalación
+- 📝 Claude Hooks ahora agrega automáticamente las entradas necesarias a `.gitignore`
+- 🔍 El comando `status` ahora muestra el estado de las entradas en `.gitignore`
+
+### Changed
+- 🎯 Mejorado el proceso de instalación para ser más completo y automatizado
+- 📊 El comando `status` ahora proporciona información más detallada sobre la configuración
+
+## [1.2.2] - 2025-08-22
+
+### Fixed
+- 🐛 Corregido problema donde los archivos markdown de pautas no se instalaban correctamente desde npm
+- 📁 Los archivos de pautas ahora se instalan en el directorio `.claude/` en lugar de la raíz del proyecto
+- 🔧 Actualizado el hook pre-commit para buscar los archivos de pautas en la nueva ubicación `.claude/`
+
+### Changed
+- 📂 Los archivos `CLAUDE_PRE_COMMIT.md` y `CLAUDE_PRE_COMMIT_SONAR.md` ahora se almacenan en `.claude/`
+- 🎯 Mejorada la organización del proyecto manteniendo los archivos de configuración separados del código fuente
+- 📝 Actualizada la documentación para reflejar la nueva estructura de directorios
+
 ## [1.2.1] - 2024-07-24
 
 ### Fixed

package/README.md

@@ -8,8 +8,8 @@ Este directorio contiene un pre-commit hook que utiliza Claude CLI para revisar
 - **`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
 - **`.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
+- **`.claude/CLAUDE_PRE_COMMIT.md`** - Pautas de evaluación formato estándar
+- **`.claude/CLAUDE_PRE_COMMIT_SONAR.md`** - Pautas de evaluación formato SonarQube
 
 ## 🔧 Configuración Previa Importante
 
@@ -69,6 +69,7 @@ El comando `claude-hooks install` ahora incluye:
 - ✅ Configuración de Git (line endings WSL/Windows)
 - ✅ Verificación de autenticación Claude con entretenimiento
 - ✅ Instalación de hooks y archivos de pautas
+- ✅ Actualización automática de .gitignore con archivos de Claude
 
 #### Añadir como Dependencia de Desarrollo
 
@@ -92,13 +93,44 @@ 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
+
+### Archivos creados durante la instalación
+
+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
+   - `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)
+
+### Actualización automática de .gitignore
+
+Durante la instalación, Claude Hooks actualiza automáticamente tu `.gitignore` para incluir:
+
+```gitignore
+# Claude Git Hooks
+.claude/
+.claude-analysis-mode
+debug-claude-response.json
+```
+
+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
+
+Si no existe un `.gitignore`, se creará uno nuevo. Si ya existe, las entradas se agregarán al final solo si no están presentes.
+
 ## 🎯 Funcionamiento
 
 ### Hook pre-commit (Análisis de código)
@@ -112,7 +144,7 @@ Luego añade esto a tu `package.json`:
    - **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`
+   - Lee las pautas desde `.claude/CLAUDE_PRE_COMMIT.md` o `.claude/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**
@@ -140,7 +172,8 @@ Luego añade esto a tu `package.json`:
 
 ### 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
@@ -241,7 +274,18 @@ Claude responde con un JSON que incluye:
 - `recommendations`: Recomendaciones de mejora
 - `blockingIssues`: Problemas que bloquean el commit
 
-## 🔄 Desactivar/Activar
+## 🔄 Actualización y Gestión
+
+### 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
@@ -284,8 +328,8 @@ 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")
+- **`GUIDELINES_FILE`**: Archivo de pautas para modo estándar (default: ".claude/CLAUDE_PRE_COMMIT.md")
+- **`GUIDELINES_FILE_SONAR`**: Archivo de pautas para modo SonarQube (default: ".claude/CLAUDE_PRE_COMMIT_SONAR.md")
 
 En el archivo `prepare-commit-msg`:
 
@@ -351,7 +395,11 @@ Este problema suele ocurrir por conflictos de configuración de line endings:
 
 ## 📝 Personalización
 
-Puedes modificar las pautas de evaluación editando `CLAUDE_PRE_COMMIT.md` para adaptarlas a los estándares de tu equipo.
+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
+
+Estos archivos son específicos de tu proyecto y puedes adaptarlos a los estándares de tu equipo.
 
 ## 🔄 Arquitectura del Sistema
 
@@ -394,6 +442,9 @@ claude-git-hooks/
 │   ├── prepare-commit-msg    # Hook de generación de mensajes
 │   ├── CLAUDE_PRE_COMMIT.md  # Pautas estándar
 │   └── CLAUDE_PRE_COMMIT_SONAR.md # Pautas SonarQube
+├── .claude/                  # Directorio creado en el repo del usuario
+│   ├── CLAUDE_PRE_COMMIT.md  # Pautas copiadas aquí durante la instalación
+│   └── CLAUDE_PRE_COMMIT_SONAR.md
 ├── package.json              # Configuración NPM
 ├── README.md                 # Este archivo
 ├── CHANGELOG.md              # Historial de versiones

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,13 @@ 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');
+  
+  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;
@@ -308,14 +394,32 @@ async function install(args) {
     success(`${hook} instalado`);
   });
 
-  // Copiar archivos de pautas si no existen
+  // 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)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+    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 => {
-    if (!fs.existsSync(guideline)) {
+    const destPath = path.join(claudeDir, guideline);
+    if (!fs.existsSync(destPath)) {
       const sourcePath = path.join(templatesPath, guideline);
       if (fs.existsSync(sourcePath)) {
-        fs.copyFileSync(sourcePath, guideline);
-        success(`${guideline} creado`);
+        fs.copyFileSync(sourcePath, destPath);
+        success(`${guideline} creado en .claude/`);
       }
     }
   });
@@ -323,6 +427,9 @@ async function install(args) {
   // Configurar Git
   configureGit();
 
+  // Actualizar .gitignore
+  updateGitignore();
+
   success('¡Claude Git Hooks instalado exitosamente! 🎉');
   console.log('\nUso:');
   console.log('  git commit -m "auto"     # Genera mensaje automáticamente');
@@ -409,7 +516,7 @@ 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
@@ -503,6 +610,79 @@ async function checkClaudeAuth() {
   }
 }
 
+// Actualizar .gitignore con las entradas de Claude
+function updateGitignore() {
+  info('Actualizando .gitignore...');
+  
+  const gitignorePath = '.gitignore';
+  const claudeEntries = [
+    '# Claude Git Hooks',
+    '.claude/',
+    '.claude-analysis-mode',
+    'debug-claude-response.json'
+  ];
+  
+  let gitignoreContent = '';
+  let fileExists = false;
+  
+  // Leer .gitignore existente si existe
+  if (fs.existsSync(gitignorePath)) {
+    gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+    fileExists = true;
+  }
+  
+  // Verificar qué entradas faltan
+  const missingEntries = [];
+  claudeEntries.forEach(entry => {
+    if (entry.startsWith('#')) {
+      // Para comentarios, verificar si ya existe algún comentario de Claude
+      if (!gitignoreContent.includes('# Claude')) {
+        missingEntries.push(entry);
+      }
+    } else {
+      // Para entradas normales, verificar si ya están presentes
+      const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'm');
+      if (!regex.test(gitignoreContent)) {
+        missingEntries.push(entry);
+      }
+    }
+  });
+  
+  // Si hay entradas faltantes, agregarlas
+  if (missingEntries.length > 0) {
+    // Asegurar que hay una nueva línea al final si el archivo existe y no está vacío
+    if (fileExists && gitignoreContent.length > 0 && !gitignoreContent.endsWith('\n')) {
+      gitignoreContent += '\n';
+    }
+    
+    // Si el archivo no está vacío, agregar una línea en blanco antes
+    if (gitignoreContent.length > 0) {
+      gitignoreContent += '\n';
+    }
+    
+    // Agregar las entradas faltantes
+    gitignoreContent += missingEntries.join('\n') + '\n';
+    
+    // Escribir el archivo actualizado
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+    
+    if (fileExists) {
+      success('.gitignore actualizado con entradas de Claude');
+    } else {
+      success('.gitignore creado con entradas de Claude');
+    }
+    
+    // Mostrar qué se agregó
+    missingEntries.forEach(entry => {
+      if (!entry.startsWith('#')) {
+        info(`  + ${entry}`);
+      }
+    });
+  } else {
+    info('.gitignore ya contiene todas las entradas necesarias');
+  }
+}
+
 // Configurar Git (line endings, etc.)
 function configureGit() {
   info('Configurando Git...');
@@ -631,12 +811,40 @@ function status() {
   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`);
+    const claudePath = path.join('.claude', guideline);
+    if (fs.existsSync(claudePath)) {
+      success(`${guideline}: presente en .claude/`);
+    } else if (fs.existsSync(guideline)) {
+      warning(`${guideline}: presente en raíz (debería estar en .claude/)`);
     } else {
       warning(`${guideline}: faltante`);
     }
   });
+
+  // Verificar entradas en .gitignore
+  console.log('\n.gitignore:');
+  const gitignorePath = '.gitignore';
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+    const claudeIgnores = ['.claude/', '.claude-analysis-mode', 'debug-claude-response.json'];
+    let allPresent = true;
+    
+    claudeIgnores.forEach(entry => {
+      const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'm');
+      if (regex.test(gitignoreContent)) {
+        success(`${entry}: incluido`);
+      } else {
+        warning(`${entry}: faltante`);
+        allPresent = false;
+      }
+    });
+    
+    if (!allPresent) {
+      info('\nEjecuta "claude-hooks install" para actualizar .gitignore');
+    }
+  } else {
+    warning('.gitignore no existe');
+  }
 }
 
 // Comando set-mode
@@ -673,6 +881,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(`
@@ -682,6 +971,7 @@ Uso: claude-hooks <comando> [opciones]
 
 Comandos:
   install              Instala los hooks en el repositorio actual
+  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)
@@ -695,6 +985,7 @@ Hooks disponibles:
 
 Ejemplos:
   claude-hooks install              # Instala todos los hooks
+  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
@@ -714,6 +1005,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.1",
+  "version": "1.3.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_PRE_COMMIT.md

@@ -44,7 +44,8 @@ Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
   ],
   "blockingIssues": [
     "Problema crítico 1 (si existe)"
-  ]
+  ],
+  "details": "Información adicional detallada (opcional)"
 }
 ```
 

package/templates/CLAUDE_PRE_COMMIT_SONAR.md

@@ -23,6 +23,11 @@ Evaluar el código modificado siguiendo métricas similares a SonarQube para ase
 - Duplicación de código
 - Deuda técnica
 
+### Métricas Adicionales
+- **Coverage**: Porcentaje estimado de cobertura de pruebas (0-100)
+- **Duplications**: Porcentaje estimado de código duplicado (0-100)
+- **Complexity**: Complejidad ciclomática promedio del código
+
 ## Clasificación de Issues
 
 ### Severidad
@@ -42,7 +47,10 @@ Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
   "metrics": {
     "reliability": "A/B/C/D/E",
     "security": "A/B/C/D/E",
-    "maintainability": "A/B/C/D/E"
+    "maintainability": "A/B/C/D/E",
+    "coverage": 75,
+    "duplications": 5,
+    "complexity": 15
   },
   "issues": {
     "blocker": 0,
@@ -60,7 +68,9 @@ Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
       "line": 42
     }
   ],
-  "securityHotspots": 0
+  "securityHotspots": 0,
+  "approved": true/false,
+  "blockingIssues": ["Lista de problemas bloqueantes si existen"]
 }
 ```
 

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,32 @@ 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
+
 # Detectar qué archivo de pautas usar
 # Prioridad: variable de entorno > archivo > pregunta interactiva
 if [ -n "$CLAUDE_ANALYSIS_MODE" ]; then
@@ -64,10 +91,10 @@ if [ "$ANALYSIS_MODE" != "standard" ] && [ "$ANALYSIS_MODE" != "sonar" ]; then
     
     if [ "$REPLY" = "2" ]; then
         ANALYSIS_MODE="sonar"
-        GUIDELINES_FILE="CLAUDE_PRE_COMMIT_SONAR.md"
+        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
     else
         ANALYSIS_MODE="standard"
-        GUIDELINES_FILE="CLAUDE_PRE_COMMIT.md"
+        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
     fi
     
     # Guardar preferencia para futuros commits
@@ -78,10 +105,10 @@ if [ "$ANALYSIS_MODE" != "standard" ] && [ "$ANALYSIS_MODE" != "sonar" ]; then
 else
     # Usar modo guardado
     if [ "$ANALYSIS_MODE" = "sonar" ]; then
-        GUIDELINES_FILE="CLAUDE_PRE_COMMIT_SONAR.md"
+        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
         log "Usando modo de análisis: SonarQube"
     else
-        GUIDELINES_FILE="CLAUDE_PRE_COMMIT.md"
+        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
         log "Usando modo de análisis: Estándar"
     fi
 fi
@@ -233,7 +260,7 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
     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)
+    QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.QUALITY_GATE // ""' 2>/dev/null)
     
     if [ "$ANALYSIS_MODE" = "sonar" ] && [ -n "$QUALITY_GATE" ] && [ "$QUALITY_GATE" != "null" ]; then
         # Mostrar resultados estilo SonarQube
@@ -265,15 +292,15 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
         fi
         
         # Issues Summary
-        SUMMARY=$(echo "$JSON_RESPONSE" | jq -r '.summary // {}' 2>/dev/null)
-        if [ "$SUMMARY" != "{}" ] && [ "$SUMMARY" != "null" ]; then
+        ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.issues // {}' 2>/dev/null)
+        if [ "$ISSUES" != "{}" ] && [ "$ISSUES" != "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)
+            BLOCKER=$(echo "$ISSUES" | jq -r '.blocker // 0' 2>/dev/null)
+            CRITICAL=$(echo "$ISSUES" | jq -r '.critical // 0' 2>/dev/null)
+            MAJOR=$(echo "$ISSUES" | jq -r '.major // 0' 2>/dev/null)
+            MINOR=$(echo "$ISSUES" | jq -r '.minor // 0' 2>/dev/null)
+            INFO=$(echo "$ISSUES" | jq -r '.info // 0' 2>/dev/null)
+            TOTAL=$((BLOCKER + CRITICAL + MAJOR + MINOR + INFO))
             
             echo "Total: $TOTAL issues found"
             [ "$BLOCKER" -gt 0 ] && echo -e "  ${RED}🔴 Blocker: $BLOCKER${NC}"
@@ -285,18 +312,19 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
         fi
         
         # Detailed Issues
-        ISSUES_COUNT=$(echo "$JSON_RESPONSE" | jq -r '.issues | length' 2>/dev/null)
-        if [ "$ISSUES_COUNT" -gt 0 ] 2>/dev/null; then
+        DETAILS_COUNT=$(echo "$JSON_RESPONSE" | jq -r '.details | length' 2>/dev/null)
+        if [ "$DETAILS_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
+            echo "$JSON_RESPONSE" | jq -r '.details[]? | 
+                "[\(.severity)] \(.type) in \(.file):\(.line // "?")\n   \(.message)\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
+        HOTSPOTS=$(echo "$JSON_RESPONSE" | jq -r '.securityHotspots // 0' 2>/dev/null)
+        if [ "$HOTSPOTS" -gt 0 ] 2>/dev/null; then
+            echo "🔥 SECURITY HOTSPOTS: $HOTSPOTS found"
+            echo "   Review security-sensitive code carefully"
+
             echo
         fi
         
@@ -332,11 +360,18 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
             exit 1
         fi
 
-        DETAILS=$(echo "$JSON_RESPONSE" | jq -r '.details // {}')
-        if [ -n "$DETAILS" ] && [ "$DETAILS" != "{}" ] && [ "$DETAILS" != "null" ]; then
+        # Mostrar detalles adicionales si existen
+        DETAILS=$(echo "$JSON_RESPONSE" | jq -r '.details // null')
+        if [ -n "$DETAILS" ] && [ "$DETAILS" != "null" ]; then
             echo
-            echo "=== DETALLES POR CATEGORÍA ==="
-            echo "$DETAILS" | jq
+            echo "=== DETALLES ADICIONALES ==="
+            # Si details es un string, imprimirlo directamente
+            if echo "$DETAILS" | jq -e 'type == "string"' >/dev/null 2>&1; then
+                echo "$DETAILS" | jq -r '.'
+            # Si es un objeto o array, formatearlo
+            else
+                echo "$DETAILS" | jq '.'
+            fi
         fi
         
         log "✅ Revisión completada. Commit aprobado (Score: $SCORE/10)"