claude-git-hooks 1.1.0 → 1.2.4

package/CHANGELOG.md

@@ -0,0 +1,131 @@
+# Changelog
+
+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.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
+- 🐛 Corregido problema de bloqueo del spinner durante verificación de autenticación Claude
+- 🎨 Arreglado sistema de entretenimiento para mostrar correctamente spinner, chistes y countdown
+- 🔧 Solucionado problema de líneas duplicadas en consola después del segundo chiste
+- 🧹 Mejorada limpieza de pantalla para evitar superposición de texto al finalizar spinner
+- ⏱️ Aumentado timeout de verificación de autenticación a 2 minutos
+
+### Changed
+- 🔄 Reemplazado `execSync` por `spawn` en verificación de autenticación para evitar bloqueos
+- 📍 Mejorado sistema de posicionamiento del cursor para renderizado consistente
+- 🎯 Optimizada lógica de actualización del spinner para evitar race conditions
+
+### Technical
+- 🏗️ Uso de `spawn` con `stdio: 'ignore'` para mantener compatibilidad con comportamiento original
+- 🎮 Sistema de reserva de espacio (3 líneas) para evitar problemas de renderizado
+- 🧮 Contador de chistes cada 10 segundos real (sin drift de tiempo)
+- 🔍 Limpieza precisa línea por línea al finalizar para evitar artefactos visuales
+
+## [1.2.0] - 2024-07-24
+
+### Added
+- ✨ Sistema de entretenimiento con spinner animado y chistes durante operaciones largas
+- 🔐 Lectura segura y no-persistente de contraseña sudo para instalación automática
+- 🛠️ Verificación completa de dependencias del sistema (jq, curl, herramientas Unix)
+- 🚀 Instalación automática de dependencias faltantes con contraseña sudo
+- ⚙️ Configuración automática de Git (line endings para WSL/Windows)
+- 🎭 Chistes rotativos cada 10 segundos durante verificación de autenticación Claude
+
+### Enhanced
+- 📦 Función `install` ahora incluye verificación e instalación completa de dependencias
+- 🔍 Verificación de autenticación Claude con entretenimiento visual
+- 💻 Detección inteligente de plataforma (Linux/macOS) para instalación de paquetes
+
+### Removed
+- 🗑️ Eliminados archivos `setup-wsl.sh` y `setup-wsl.js` (redundantes)
+- 🧹 Simplificación de la arquitectura eliminando duplicación de código
+
+### Technical
+- 🔧 Añadido módulo `https` para obtener chistes de API externa
+- 🎨 Clase `Entertainment` para manejo de spinner y chistes
+- 🔐 Funciones `readPassword()` y `testSudoPassword()` para manejo seguro de credenciales
+- ⚡ Conversión a funciones async/await para mejor manejo de procesos asíncronos
+
+## [1.1.0] - 2024-07-24
+
+### Added
+- 🎯 Comando `set-mode` para cambiar entre análisis estándar y SonarQube
+- 📊 Modo SonarQube con métricas detalladas y quality gate
+- 📈 Visualización del modo de análisis actual en comando `status`
+- 🔧 Configuración persistente del modo de análisis en archivo `.claude-analysis-mode`
+
+### Enhanced  
+- 📋 Comando `status` ahora muestra modo de análisis y archivos de pautas
+- 📚 Documentación mejorada con ejemplos de ambos modos
+- 🎨 Mejor formateo de salida en comandos informativos
+
+### Technical
+- 📁 Detección automática de archivos de pautas (CLAUDE_PRE_COMMIT.md, CLAUDE_PRE_COMMIT_SONAR.md)
+- 🏗️ Estructura preparada para múltiples modos de análisis
+
+## [1.0.0] - 2024-07-24
+
+### Added
+- 🎉 Primera versión estable del paquete npm `claude-git-hooks`
+- 📦 CLI global `claude-hooks` para gestión de hooks de Git
+- 🪝 Instalación automática de hooks `pre-commit` y `prepare-commit-msg`
+- 🔍 Verificación de dependencias (Claude CLI, jq)
+- 📋 Comandos principales: `install`, `uninstall`, `enable`, `disable`, `status`
+- 📖 Sistema de ayuda completo con ejemplos
+- 🎛️ Gestión individual de hooks (habilitar/deshabilitar por separado)
+- 📂 Creación automática de archivos de pautas si no existen
+- 🔄 Sistema de backup automático de hooks existentes
+
+### Technical
+- 🏗️ Arquitectura modular con funciones especializadas
+- 🎨 Sistema de colores para output legible
+- 🛡️ Validaciones de entorno (repositorio Git, dependencias)
+- 📝 Documentación completa en README
+
+---
+
+## Tipos de cambios
+- `Added` - para nuevas funcionalidades
+- `Changed` - para cambios en funcionalidades existentes  
+- `Deprecated` - para funcionalidades que serán removidas
+- `Removed` - para funcionalidades removidas
+- `Fixed` - para corrección de bugs
+- `Security` - para vulnerabilidades corregidas

package/README.md

@@ -7,10 +7,9 @@ Este directorio contiene un pre-commit hook que utiliza Claude CLI para revisar
 - **`README.md`** - Esta documentación
 - **`pre-commit`** - Hook principal para análisis de código (con auto-actualización)
 - **`prepare-commit-msg`** - Hook para generar mensajes de commit automáticos
-- **`setup-wsl.sh`** - Script de instalación inicial para WSL
 - **`.gitattributes`** - Configuración para mantener line endings correctos
-- **`CLAUDE_PRE_COMMIT.md`** - Pautas de evaluación formato estándar
-- **`CLAUDE_PRE_COMMIT_SONAR.md`** - Pautas de evaluación formato SonarQube
+- **`.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
 
@@ -51,28 +50,32 @@ git config --global credential.helper store
 
 ## 🚀 Instalación
 
-### Opción 1: Paquete NPM Global (Recomendado)
+### Paquete NPM Global (Recomendado)
 
 **IMPORTANTE**: Claude CLI corre en WSL, por lo que toda la instalación y uso de git debe hacerse desde la terminal WSL.
 
-#### Instalación Global
-
 ```bash
 # Instalar el paquete globalmente
-sudo npm install -g claude-git-hooks
+npm install -g claude-git-hooks
 
 # En cualquier repositorio, instalar los hooks
 cd tu-proyecto
 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
+- ✅ Instalación de hooks y archivos de pautas
+- ✅ Actualización automática de .gitignore con archivos de Claude
+
 #### Añadir como Dependencia de Desarrollo
 
 ```bash
 # Instalar como devDependency
 npm install --save-dev claude-git-hooks
-
-# Añadir script al package.json
 ```
 
 Luego añade esto a tu `package.json`:
@@ -83,30 +86,11 @@ Luego añade esto a tu `package.json`:
     "postinstall": "claude-hooks install"
   },
   "devDependencies": {
-    "claude-git-hooks": "^1.0.0"
+    "claude-git-hooks": "^1.2.0"
   }
 }
 ```
 
-### Opción 2: Instalación Local con Scripts
-
-```bash
-# Desde WSL - Instalación completa
-./git-hooks/setup-wsl.sh
-
-# Ver opciones disponibles
-./git-hooks/setup-wsl.sh --help
-
-# Solo sincronizar hooks (útil después de modificar archivos fuente)
-./git-hooks/setup-wsl.sh --sync
-
-# Habilitar/deshabilitar hooks
-./git-hooks/setup-wsl.sh --enable-hooks          # Habilita todos los hooks
-./git-hooks/setup-wsl.sh --disable-hooks         # Deshabilita todos los hooks
-./git-hooks/setup-wsl.sh --enable-hooks pre-commit   # Habilita solo pre-commit
-./git-hooks/setup-wsl.sh --disable-hooks prepare-commit-msg  # Deshabilita solo prepare-commit-msg
-```
-
 ## 🤖 Características
 
 **✨ Auto-actualización incorporada**: Los hooks se actualizan automáticamente en cada commit.
@@ -116,6 +100,37 @@ Luego añade esto a tu `package.json`:
 - `pre-commit`: Análisis de código con Claude (solo archivos Java/config)
 - `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)
@@ -129,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**
@@ -301,8 +316,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`:
 
@@ -368,7 +383,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
 
@@ -405,16 +424,18 @@ WSL Terminal
 ```
 claude-git-hooks/
 ├── bin/
-│   └── claude-hooks           # CLI principal
+│   └── claude-hooks          # CLI principal con verificación completa
 ├── templates/
 │   ├── pre-commit            # Hook de análisis de código
 │   ├── prepare-commit-msg    # Hook de generación de mensajes
 │   ├── CLAUDE_PRE_COMMIT.md  # Pautas estándar
 │   └── CLAUDE_PRE_COMMIT_SONAR.md # Pautas SonarQube
-├── setup-wsl.sh              # Script de instalación local (legacy)
+├── .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
-├── README-NPM.md             # Documentación para NPM
+├── CHANGELOG.md              # Historial de versiones
 └── PUBLISH.md                # Guía de publicación
 ```
 

package/bin/claude-hooks

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
-const { execSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const readline = require('readline');
+const https = require('https');
 
 // Colores para output
 const colors = {
@@ -35,6 +37,206 @@ function warning(message) {
   log(`⚠️  ${message}`, 'yellow');
 }
 
+// Función para leer contraseña de forma segura
+function readPassword(prompt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    // Deshabilitar echo
+    rl.stdoutMuted = true;
+    rl._writeToOutput = function _writeToOutput(stringToWrite) {
+      if (rl.stdoutMuted)
+        rl.output.write("*");
+      else
+        rl.output.write(stringToWrite);
+    };
+    
+    rl.question(prompt, (password) => {
+      rl.close();
+      console.log(); // Nueva línea
+      resolve(password);
+    });
+  });
+}
+
+// Verificar si la contraseña sudo es correcta
+function testSudoPassword(password) {
+  try {
+    execSync('echo "' + password + '" | sudo -S true', { 
+      stdio: 'ignore',
+      timeout: 5000
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Instalar paquete con sudo automático
+function installPackage(packageName, sudoPassword = null) {
+  try {
+    if (sudoPassword) {
+      if (os.platform() === 'linux') {
+        execSync(`echo "${sudoPassword}" | sudo -S apt-get update && echo "${sudoPassword}" | sudo -S apt-get install -y ${packageName}`, {
+          stdio: 'inherit'
+        });
+      }
+    } else {
+      if (os.platform() === 'linux') {
+        execSync(`sudo apt-get update && sudo apt-get install -y ${packageName}`, {
+          stdio: 'inherit'
+        });
+      } else if (os.platform() === 'darwin') {
+        execSync(`brew install ${packageName}`, {
+          stdio: 'inherit'
+        });
+      }
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Sistema de entretenimiento
+class Entertainment {
+  static jokes = [
+    "¿Por qué los programadores prefieren el modo oscuro? Porque la luz atrae bugs!",
+    "Un QA entra a un bar. Pide 1 cerveza. Pide 0 cervezas. Pide -1 cervezas.",
+    "¿Cuál es el lenguaje favorito de los piratas? R!",
+    "Hay 10 tipos de personas: las que entienden binario y las que no.",
+    "¿Por qué los programadores confunden Halloween con Navidad? Porque Oct 31 = Dec 25",
+    "¿Qué le dice un bit al otro? Nos vemos en el bus!",
+    "¿Por qué Java y C++ no se llevan bien? Porque tienen diferentes puntos de vista sobre los punteros.",
+    "Mi código no tiene bugs, solo features no documentadas."
+  ];
+
+  static async getJoke() {
+    return new Promise((resolve) => {
+      // Intentar obtener chiste de API
+      const req = https.get('https://icanhazdadjoke.com/', {
+        headers: { 'Accept': 'text/plain' },
+        timeout: 3000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(data.trim()));
+      });
+
+      req.on('error', () => {
+        // Si falla, usar chiste local
+        const randomJoke = this.jokes[Math.floor(Math.random() * this.jokes.length)];
+        resolve(randomJoke);
+      });
+
+      req.on('timeout', () => {
+        req.abort();
+        const randomJoke = this.jokes[Math.floor(Math.random() * this.jokes.length)];
+        resolve(randomJoke);
+      });
+    });
+  }
+
+  static async showSpinner(promise, message = 'Procesando') {
+    const spinners = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let spinnerIndex = 0;
+    let jokeCountdown = 10;
+    let currentJoke = this.jokes[Math.floor(Math.random() * this.jokes.length)];
+    let isFinished = false;
+    let isFirstRender = true;
+
+    // Obtener primer chiste de la API sin bloquear
+    this.getJoke().then(joke => {
+      if (!isFinished) currentJoke = joke;
+    }).catch(() => {}); // Si falla, mantener el local
+
+    // Ocultar cursor
+    process.stdout.write('\x1B[?25l');
+    
+    // Reservar espacio para las 3 líneas
+    process.stdout.write('\n\n\n');
+    
+    const interval = setInterval(() => {
+      if (isFinished) {
+        clearInterval(interval);
+        return;
+      }
+      
+      spinnerIndex++;
+      
+      // Actualizar countdown cada segundo (10 iteraciones de 100ms)
+      if (spinnerIndex % 10 === 0) {
+        jokeCountdown--;
+        
+        // Renovar chiste cada 10 segundos
+        if (jokeCountdown <= 0) {
+          this.getJoke().then(joke => {
+            if (!isFinished) currentJoke = joke;
+          }).catch(() => {
+            if (!isFinished) {
+              currentJoke = this.jokes[Math.floor(Math.random() * this.jokes.length)];
+            }
+          });
+          jokeCountdown = 10;
+        }
+      }
+      
+      // Siempre volver exactamente 3 líneas arriba
+      process.stdout.write('\x1B[3A');
+      
+      // Renderizar las 3 líneas desde el inicio
+      const spinner = spinners[spinnerIndex % spinners.length];
+      
+      // Línea 1: Spinner
+      process.stdout.write('\r\x1B[2K' + `${colors.yellow}${spinner} ${message}${colors.reset}\n`);
+      
+      // Línea 2: Chiste  
+      process.stdout.write('\r\x1B[2K' + `${colors.green}🎭 ${currentJoke}${colors.reset}\n`);
+      
+      // Línea 3: Countdown
+      process.stdout.write('\r\x1B[2K' + `${colors.yellow}⏱️  Próximo chiste en: ${jokeCountdown}s${colors.reset}\n`);
+    }, 100);
+
+    try {
+      const result = await promise;
+      isFinished = true;
+      clearInterval(interval);
+      
+      // Limpiar exactamente 3 líneas completamente
+      process.stdout.write('\x1B[3A'); // Subir 3 líneas
+      process.stdout.write('\r\x1B[2K'); // Limpiar línea 1
+      process.stdout.write('\n\r\x1B[2K'); // Bajar y limpiar línea 2
+      process.stdout.write('\n\r\x1B[2K'); // Bajar y limpiar línea 3
+      process.stdout.write('\x1B[2A'); // Subir 2 líneas para quedar en la primera
+      process.stdout.write('\r'); // Ir al inicio de línea
+      
+      // Mostrar cursor
+      process.stdout.write('\x1B[?25h');
+      
+      return result;
+    } catch (error) {
+      isFinished = true;
+      clearInterval(interval);
+      
+      // Limpiar exactamente 3 líneas completamente
+      process.stdout.write('\x1B[3A'); // Subir 3 líneas
+      process.stdout.write('\r\x1B[2K'); // Limpiar línea 1
+      process.stdout.write('\n\r\x1B[2K'); // Bajar y limpiar línea 2
+      process.stdout.write('\n\r\x1B[2K'); // Bajar y limpiar línea 3
+      process.stdout.write('\x1B[2A'); // Subir 2 líneas para quedar en la primera
+      process.stdout.write('\r'); // Ir al inicio de línea
+      
+      // Mostrar cursor
+      process.stdout.write('\x1B[?25h');
+      
+      throw error;
+    }
+  }
+}
+
 // Verificar si estamos en un repositorio git
 function checkGitRepo() {
   try {
@@ -51,13 +253,33 @@ function getTemplatesPath() {
 }
 
 // Comando install
-function install(args) {
+async function install(args) {
   if (!checkGitRepo()) {
     error('No estás en un repositorio Git. Por favor, ejecuta este comando desde la raíz de un repositorio.');
   }
 
   info('Instalando Claude Git Hooks...');
 
+  // Solicitar contraseña sudo al inicio si es necesario
+  let sudoPassword = null;
+  if (os.platform() === 'linux') {
+    const needsInstall = await checkIfInstallationNeeded();
+    if (needsInstall) {
+      info('Para la instalación automática de dependencias se necesita acceso sudo, por favor ingrese contraseña');
+      sudoPassword = await readPassword('Introduce tu contraseña de Ubuntu para sudo: ');
+      
+      if (sudoPassword && !testSudoPassword(sudoPassword)) {
+        warning('Contraseña incorrecta. Continuando sin instalación automática.');
+        sudoPassword = null;
+      } else if (sudoPassword) {
+        success('Contraseña verificada. Procediendo con instalación automática.');
+      }
+    }
+  }
+
+  // Verificar dependencias con instalación automática
+  await checkAndInstallDependencies(sudoPassword);
+
   const templatesPath = getTemplatesPath();
   const hooksPath = '.git/hooks';
 
@@ -86,18 +308,31 @@ function install(args) {
     success(`${hook} instalado`);
   });
 
-  // Copiar archivos de pautas si no existen
+  // 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);
-      fs.copyFileSync(sourcePath, guideline);
-      success(`${guideline} creado`);
+      if (fs.existsSync(sourcePath)) {
+        fs.copyFileSync(sourcePath, destPath);
+        success(`${guideline} creado en .claude/`);
+      }
     }
   });
 
-  // Verificar dependencias
-  checkDependencies();
+  // Configurar Git
+  configureGit();
+
+  // Actualizar .gitignore
+  updateGitignore();
 
   success('¡Claude Git Hooks instalado exitosamente! 🎉');
   console.log('\nUso:');
@@ -106,31 +341,271 @@ function install(args) {
   console.log('\nPara más opciones: claude-hooks --help');
 }
 
-// Verificar dependencias
-function checkDependencies() {
-  info('\nVerificando dependencias...');
+// Verificar dependencias completas (como setup-wsl.sh)
+async function checkAndInstallDependencies(sudoPassword = null) {
+  info('Verificando dependencias del sistema...');
+  
+  // Verificar Node.js
+  try {
+    const nodeVersion = execSync('node --version', { encoding: 'utf8' }).trim();
+    success(`Node.js ${nodeVersion}`);
+  } catch (e) {
+    error('Node.js no está instalado. Instala Node.js e intenta de nuevo.');
+  }
+  
+  // Verificar npm
+  try {
+    const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
+    success(`npm ${npmVersion}`);
+  } catch (e) {
+    error('npm no está instalado.');
+  }
+  
+  // Verificar e instalar jq
+  try {
+    const jqVersion = execSync('jq --version', { encoding: 'utf8' }).trim();
+    success(`jq ${jqVersion}`);
+  } catch (e) {
+    warning('jq no está instalado. Instalando...');
+    if (installPackage('jq', sudoPassword)) {
+      success('jq instalado correctamente');
+    } else {
+      warning('No se pudo instalar jq automáticamente');
+      if (os.platform() === 'linux') {
+        console.log('Instálalo manualmente con: sudo apt install jq');
+      } else if (os.platform() === 'darwin') {
+        console.log('Instálalo manualmente con: brew install jq');
+      }
+    }
+  }
+  
+  // Verificar e instalar curl
+  try {
+    const curlVersion = execSync('curl --version', { encoding: 'utf8' }).split('\n')[0];
+    success(`curl ${curlVersion.split(' ')[1]}`);
+  } catch (e) {
+    warning('curl no está instalado. Instalando...');
+    if (installPackage('curl', sudoPassword)) {
+      success('curl instalado correctamente');
+    } else {
+      warning('No se pudo instalar curl automáticamente');
+      if (os.platform() === 'linux') {
+        console.log('Instálalo manualmente con: sudo apt install curl');
+      } else if (os.platform() === 'darwin') {
+        console.log('Instálalo manualmente con: brew install curl');
+      }
+    }
+  }
+  
+  // Verificar Git
+  try {
+    const gitVersion = execSync('git --version', { encoding: 'utf8' }).trim();
+    success(`${gitVersion}`);
+  } catch (e) {
+    error('Git no está instalado. Instala Git e intenta de nuevo.');
+  }
+  
+  // Verificar herramientas Unix estándar
+  const unixTools = ['sed', 'awk', 'grep', 'head', 'tail', 'stat', 'tput'];
+  const missingTools = [];
+  
+  unixTools.forEach(tool => {
+    try {
+      execSync(`which ${tool}`, { stdio: 'ignore' });
+    } catch (e) {
+      missingTools.push(tool);
+    }
+  });
+  
+  if (missingTools.length === 0) {
+    success('Herramientas Unix estándar verificadas');
+  } else {
+    error(`Faltan herramientas Unix estándar: ${missingTools.join(', ')}`);
+  }
+  
+  // Verificar e instalar Claude CLI
+  await checkAndInstallClaude();
+  
+  // Verificar autenticación de Claude
+  await checkClaudeAuth();
+  
+  // Limpiar contraseña de memoria
+  sudoPassword = null;
+}
+
+// Verificar si necesitamos instalar dependencias
+async function checkIfInstallationNeeded() {
+  const dependencies = ['jq', 'curl'];
+  
+  for (const dep of dependencies) {
+    try {
+      execSync(`which ${dep}`, { stdio: 'ignore' });
+    } catch (e) {
+      return true; // Necesita instalación
+    }
+  }
   
   // Verificar Claude CLI
   try {
     execSync('claude --version', { stdio: 'ignore' });
-    success('Claude CLI encontrado');
   } catch (e) {
-    warning('Claude CLI no está instalado');
-    console.log('Instálalo con: npm install -g @anthropic-ai/claude-cli');
-    console.log('Luego ejecuta: claude auth login');
+    return true; // Necesita instalación de Claude
+  }
+  
+  return false;
+}
+
+// Verificar e instalar Claude CLI
+async function checkAndInstallClaude() {
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    success('Claude CLI detectado');
+  } catch (e) {
+    info('Claude CLI no detectado. Instalando...');
+    try {
+      execSync('npm install -g @anthropic-ai/claude-cli', { stdio: 'inherit' });
+      success('Claude CLI instalado correctamente');
+    } catch (installError) {
+      error('Error al instalar Claude CLI. Instálalo manualmente: npm install -g @anthropic-ai/claude-cli');
+    }
   }
+}
+
+// Verificar autenticación de Claude con entretenimiento
+async function checkClaudeAuth() {
+  info('Verificando autenticación de Claude...');
   
-  // Verificar jq
+  // Usar spawn para no bloquear, pero con stdio: 'ignore' como el original
+  const authPromise = new Promise((resolve, reject) => {
+    const child = spawn('claude', ['auth', 'status'], {
+      stdio: 'ignore',  // Igual que el original
+      detached: false,
+      windowsHide: true
+    });
+    
+    // Timeout manual ya que spawn no tiene timeout nativo
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(new Error('timeout'));
+    }, 120000); // 2 minutos
+    
+    child.on('exit', (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        resolve('success');
+      } else {
+        reject(new Error('not_authenticated'));
+      }
+    });
+    
+    child.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+
   try {
-    execSync('jq --version', { stdio: 'ignore' });
-    success('jq encontrado');
+    await Entertainment.showSpinner(authPromise, 'Verificando autenticación de Claude');
+    success('Autenticado en Claude');
   } catch (e) {
-    warning('jq no está instalado');
-    if (os.platform() === 'linux') {
-      console.log('Instálalo con: sudo apt install jq');
-    } else if (os.platform() === 'darwin') {
-      console.log('Instálalo con: brew install jq');
+    warning('No estás autenticado en Claude');
+    console.log('Ejecuta: claude auth login');
+    console.log('Después vuelve a ejecutar este comando');
+  }
+}
+
+// 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...');
+  
+  try {
+    // Configurar line endings para WSL
+    execSync('git config core.autocrlf input', { stdio: 'ignore' });
+    success('Line endings configurados para WSL (core.autocrlf = input)');
+    
+    // Intentar configurar en Windows a través de PowerShell
+    try {
+      execSync('powershell.exe -Command "git config core.autocrlf true"', { stdio: 'ignore' });
+      success('Line endings configurados para Windows (core.autocrlf = true)');
+    } catch (psError) {
+      info('No se pudo configurar automáticamente en Windows');
     }
+    
+  } catch (e) {
+    warning('Error al configurar Git');
   }
 }
 
@@ -240,12 +715,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
@@ -315,35 +818,42 @@ Más información: https://github.com/pablorovito/claude-git-hooks
 }
 
 // Main
-const args = process.argv.slice(2);
-const command = args[0];
-
-switch (command) {
-  case 'install':
-    install(args.slice(1));
-    break;
-  case 'uninstall':
-    uninstall();
-    break;
-  case 'enable':
-    enable(args[1]);
-    break;
-  case 'disable':
-    disable(args[1]);
-    break;
-  case 'set-mode':
-    setMode(args[1]);
-    break;
-  case 'status':
-    status();
-    break;
-  case 'help':
-  case '--help':
-  case '-h':
-  case undefined:
-    showHelp();
-    break;
-  default:
-    error(`Comando desconocido: ${command}`);
-    showHelp();
-}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case 'install':
+      await install(args.slice(1));
+      break;
+    case 'uninstall':
+      uninstall();
+      break;
+    case 'enable':
+      enable(args[1]);
+      break;
+    case 'disable':
+      disable(args[1]);
+      break;
+    case 'set-mode':
+      setMode(args[1]);
+      break;
+    case 'status':
+      status();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      showHelp();
+      break;
+    default:
+      error(`Comando desconocido: ${command}`);
+      showHelp();
+  }
+}
+
+// Ejecutar main
+main().catch(err => {
+  error(`Error inesperado: ${err.message}`);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-git-hooks",
-  "version": "1.1.0",
+  "version": "1.2.4",
   "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": {
@@ -35,6 +35,7 @@
     "lib/",
     "templates/",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ]
 }

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/pre-commit

@@ -64,10 +64,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 +78,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 +233,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 +265,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 +285,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 +333,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)"