claude-git-hooks 1.2.4 → 1.3.0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ 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

package/README.md

@@ -93,11 +93,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
@@ -172,7 +172,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
@@ -273,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

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,6 +394,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)) {
@@ -420,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
@@ -785,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(`
@@ -794,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)
@@ -807,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
@@ -826,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.4",
+  "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/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