claude-git-hooks 1.5.1 → 1.5.3

package/bin/claude-hooks

@@ -7,24 +7,24 @@ const os = require('os');
 const readline = require('readline');
 const https = require('https');
 
-// Función para obtener la última versión desde NPM
+// Function to get the latest version from NPM
 function getLatestVersion(packageName) {
   return new Promise((resolve, reject) => {
-    // Usar la API principal de NPM, no /latest
+    // Use the main NPM API, not /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'
+          // Get the version from the 'latest' tag
           if (json['dist-tags'] && json['dist-tags'].latest) {
             resolve(json['dist-tags'].latest);
           } else {
-            reject(new Error('No se pudo obtener la versión'));
+            reject(new Error('Could not get the version'));
           }
         } catch (e) {
-          // Si falla, intentar con npm view
+          // If it fails, try with npm view
           try {
             const version = execSync(`npm view ${packageName} version`, { encoding: 'utf8' }).trim();
             resolve(version);
@@ -37,57 +37,57 @@ function getLatestVersion(packageName) {
   });
 }
 
-// Función para verificar versión (usada por los hooks)
+// Function to check version (used by 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
+      return true; // Already updated
     }
     
     console.log('');
-    warning(`Nueva versión disponible: ${latestVersion} (actual: ${currentVersion})`);
+    warning(`New version available: ${latestVersion} (current: ${currentVersion})`);
     
-    // Prompt interactivo compatible con todas las consolas
+    // Interactive prompt compatible with all consoles
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     
     return new Promise((resolve) => {
-      rl.question('¿Deseas actualizar ahora? (s/n): ', (answer) => {
+      rl.question('Do you want to update now? (y/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...');
+        if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+          info('Updating 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
+            success('Update completed. Please run your command again.');
+            process.exit(0); // Exit so user restarts the process
           } catch (e) {
-            error('Error al actualizar: ' + e.message);
+            error('Error updating: ' + e.message);
             resolve(false);
           }
         } else {
-          info('Actualización pospuesta. Puedes actualizar más tarde con: claude-hooks update');
-          resolve(true); // Continuar sin actualizar
+          info('Update postponed. You can update later with: claude-hooks update');
+          resolve(true); // Continue without updating
         }
       });
     });
   } catch (e) {
-    // Si hay error verificando la versión, continuar sin bloquear
+    // If there's an error checking version, continue without blocking
     return true;
   }
 }
 
-// Exportar para uso en hooks
+// Export for use in hooks
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = { checkVersionAndPromptUpdate };
 }
 
-// Colores para output
+// Colors for output
 const colors = {
   reset: '\x1b[0m',
   red: '\x1b[31m',
@@ -117,7 +117,7 @@ function warning(message) {
   log(`⚠️  ${message}`, 'yellow');
 }
 
-// Función para leer contraseña de forma segura
+// Function to read password securely
 function readPassword(prompt) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
@@ -125,7 +125,7 @@ function readPassword(prompt) {
       output: process.stdout
     });
     
-    // Deshabilitar echo
+    // Disable echo
     rl.stdoutMuted = true;
     rl._writeToOutput = function _writeToOutput(stringToWrite) {
       if (rl.stdoutMuted)
@@ -136,13 +136,13 @@ function readPassword(prompt) {
     
     rl.question(prompt, (password) => {
       rl.close();
-      console.log(); // Nueva línea
+      console.log(); // New line
       resolve(password);
     });
   });
 }
 
-// Verificar si la contraseña sudo es correcta
+// Check if sudo password is correct
 function testSudoPassword(password) {
   try {
     execSync('echo "' + password + '" | sudo -S true', { 
@@ -155,7 +155,7 @@ function testSudoPassword(password) {
   }
 }
 
-// Instalar paquete con sudo automático
+// Install package with automatic sudo
 function installPackage(packageName, sudoPassword = null) {
   try {
     if (sudoPassword) {
@@ -181,22 +181,22 @@ function installPackage(packageName, sudoPassword = null) {
   }
 }
 
-// Sistema de entretenimiento
+// Entertainment system
 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."
+    "Why do programmers prefer dark mode? Because light attracts bugs!",
+    "A QA engineer walks into a bar. Orders 1 beer. Orders 0 beers. Orders -1 beers.",
+    "What's a pirate's favorite programming language? R!",
+    "There are 10 types of people: those who understand binary and those who don't.",
+    "Why do programmers confuse Halloween with Christmas? Because Oct 31 = Dec 25",
+    "What does one bit say to another? See you on the bus!",
+    "Why don't Java and C++ get along? Because they have different views on pointers.",
+    "My code doesn't have bugs, just undocumented features."
   ];
 
   static async getJoke() {
     return new Promise((resolve) => {
-      // Intentar obtener chiste de API
+      // Try to get joke from API
       const req = https.get('https://icanhazdadjoke.com/', {
         headers: { 'Accept': 'text/plain' },
         timeout: 3000
@@ -207,7 +207,7 @@ class Entertainment {
       });
 
       req.on('error', () => {
-        // Si falla, usar chiste local
+        // If it fails, use local joke
         const randomJoke = this.jokes[Math.floor(Math.random() * this.jokes.length)];
         resolve(randomJoke);
       });
@@ -220,7 +220,7 @@ class Entertainment {
     });
   }
 
-  static async showSpinner(promise, message = 'Procesando') {
+  static async showSpinner(promise, message = 'Processing') {
     const spinners = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     let spinnerIndex = 0;
     let jokeCountdown = 10;
@@ -228,15 +228,15 @@ class Entertainment {
     let isFinished = false;
     let isFirstRender = true;
 
-    // Obtener primer chiste de la API sin bloquear
+    // Get first joke from API without blocking
     this.getJoke().then(joke => {
       if (!isFinished) currentJoke = joke;
-    }).catch(() => {}); // Si falla, mantener el local
+    }).catch(() => {}); // If it fails, keep the local one
 
-    // Ocultar cursor
+    // Hide cursor
     process.stdout.write('\x1B[?25l');
     
-    // Reservar espacio para las 3 líneas
+    // Reserve space for the 3 lines
     process.stdout.write('\n\n\n');
     
     const interval = setInterval(() => {
@@ -247,11 +247,11 @@ class Entertainment {
       
       spinnerIndex++;
       
-      // Actualizar countdown cada segundo (10 iteraciones de 100ms)
+      // Update countdown every second (10 iterations of 100ms)
       if (spinnerIndex % 10 === 0) {
         jokeCountdown--;
         
-        // Renovar chiste cada 10 segundos
+        // Refresh joke every 10 seconds
         if (jokeCountdown <= 0) {
           this.getJoke().then(joke => {
             if (!isFinished) currentJoke = joke;
@@ -264,20 +264,20 @@ class Entertainment {
         }
       }
       
-      // Siempre volver exactamente 3 líneas arriba
+      // Always go back exactly 3 lines up
       process.stdout.write('\x1B[3A');
       
-      // Renderizar las 3 líneas desde el inicio
+      // Render the 3 lines from the beginning
       const spinner = spinners[spinnerIndex % spinners.length];
       
-      // Línea 1: Spinner
+      // Line 1: Spinner
       process.stdout.write('\r\x1B[2K' + `${colors.yellow}${spinner} ${message}${colors.reset}\n`);
       
-      // Línea 2: Chiste  
+      // Line 2: Joke  
       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`);
+      // Line 3: Countdown
+      process.stdout.write('\r\x1B[2K' + `${colors.yellow}⏱️  Next joke in: ${jokeCountdown}s${colors.reset}\n`);
     }, 100);
 
     try {
@@ -285,15 +285,15 @@ class Entertainment {
       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
+      // Clean exactly 3 lines completely
+      process.stdout.write('\x1B[3A'); // Go up 3 lines
+      process.stdout.write('\r\x1B[2K'); // Clean line 1
+      process.stdout.write('\n\r\x1B[2K'); // Go down and clean line 2
+      process.stdout.write('\n\r\x1B[2K'); // Go down and clean line 3
+      process.stdout.write('\x1B[2A'); // Go up 2 lines to end up on the first
+      process.stdout.write('\r'); // Go to beginning of line
       
-      // Mostrar cursor
+      // Show cursor
       process.stdout.write('\x1B[?25h');
       
       return result;
@@ -301,15 +301,15 @@ class Entertainment {
       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
+      // Clean exactly 3 lines completely
+      process.stdout.write('\x1B[3A'); // Go up 3 lines
+      process.stdout.write('\r\x1B[2K'); // Clean line 1
+      process.stdout.write('\n\r\x1B[2K'); // Go down and clean line 2
+      process.stdout.write('\n\r\x1B[2K'); // Go down and clean line 3
+      process.stdout.write('\x1B[2A'); // Go up 2 lines to end up on the first
+      process.stdout.write('\r'); // Go to beginning of line
       
-      // Mostrar cursor
+      // Show cursor
       process.stdout.write('\x1B[?25h');
       
       throw error;
@@ -317,7 +317,7 @@ class Entertainment {
   }
 }
 
-// Verificar si estamos en un repositorio git
+// Check if we are in a git repository
 function checkGitRepo() {
   try {
     execSync('git rev-parse --git-dir', { stdio: 'ignore' });
@@ -327,92 +327,92 @@ function checkGitRepo() {
   }
 }
 
-// Obtener la ruta de los templates
+// Get the templates path
 function getTemplatesPath() {
   return path.join(__dirname, '..', 'templates');
 }
 
-// Comando install
+// Install command
 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.');
+    error('You are not in a Git repository. Please run this command from the root of a repository.');
   }
 
   const isForce = args.includes('--force');
   const skipAuth = args.includes('--skip-auth');
   
   if (isForce) {
-    info('Instalando Claude Git Hooks (modo force)...');
+    info('Installing Claude Git Hooks (force mode)...');
   } else {
-    info('Instalando Claude Git Hooks...');
+    info('Installing Claude Git Hooks...');
   }
 
-  // Solicitar contraseña sudo al inicio si es necesario
+  // Request sudo password at the beginning if necessary
   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: ');
+      info('Sudo access is needed for automatic dependency installation, please enter password');
+      sudoPassword = await readPassword('Enter your Ubuntu password for sudo: ');
       
       if (sudoPassword && !testSudoPassword(sudoPassword)) {
-        warning('Contraseña incorrecta. Continuando sin instalación automática.');
+        warning('Incorrect password. Continuing without automatic installation.');
         sudoPassword = null;
       } else if (sudoPassword) {
-        success('Contraseña verificada. Procediendo con instalación automática.');
+        success('Password verified. Proceeding with automatic installation.');
       }
     }
   }
 
-  // Verificar dependencias con instalación automática
+  // Check dependencies with automatic installation
   await checkAndInstallDependencies(sudoPassword, skipAuth);
 
   const templatesPath = getTemplatesPath();
   const hooksPath = '.git/hooks';
 
-  // Crear directorio hooks si no existe
+  // Create hooks directory if it doesn't exist
   if (!fs.existsSync(hooksPath)) {
     fs.mkdirSync(hooksPath, { recursive: true });
   }
 
-  // Hooks a instalar
+  // Hooks to install
   const hooks = ['pre-commit', 'prepare-commit-msg'];
   
   hooks.forEach(hook => {
     const sourcePath = path.join(templatesPath, hook);
     const destPath = path.join(hooksPath, hook);
     
-    // Hacer backup si existe
+    // Make backup if it exists
     if (fs.existsSync(destPath)) {
       const backupPath = `${destPath}.backup.${Date.now()}`;
       fs.copyFileSync(destPath, backupPath);
-      info(`Backup creado: ${backupPath}`);
+      info(`Backup created: ${backupPath}`);
     }
     
-    // Copiar hook
+    // Copy hook
     fs.copyFileSync(sourcePath, destPath);
     fs.chmodSync(destPath, '755');
-    success(`${hook} instalado`);
+    success(`${hook} installed`);
   });
 
-  // Copiar script de verificación de versión
+  // Copy version verification script
   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');
+    success('Version verification script installed');
   }
 
-  // Crear directorio .claude si no existe
+  // Create .claude directory if it doesn't exist
   const claudeDir = '.claude';
   if (!fs.existsSync(claudeDir)) {
     fs.mkdirSync(claudeDir, { recursive: true });
     success('.claude directory created');
   }
 
-  // Copiar archivos de pautas y prompts a .claude
+  // Copy guidelines and prompts files to .claude
   const claudeFiles = [
     'CLAUDE_PRE_COMMIT_SONAR.md',
     'CLAUDE_ANALYSIS_PROMPT_SONAR.md',
@@ -423,101 +423,101 @@ async function install(args) {
     const destPath = path.join(claudeDir, file);
     const sourcePath = path.join(templatesPath, file);
     
-    // En modo force o si no existe, copiar el archivo
+    // In force mode or if it doesn't exist, copy the file
     if (isForce || !fs.existsSync(destPath)) {
       if (fs.existsSync(sourcePath)) {
         fs.copyFileSync(sourcePath, destPath);
-        success(`${file} instalado en .claude/`);
+        success(`${file} installed in .claude/`);
       } else {
-        warning(`Archivo de template no encontrado: ${file}`);
+        warning(`Template file not found: ${file}`);
       }
     }
   });
 
-  // Configurar Git
+  // Configure Git
   configureGit();
 
-  // Actualizar .gitignore
+  // Update .gitignore
   updateGitignore();
 
-  success('¡Claude Git Hooks instalado exitosamente! 🎉');
-  console.log('\nUso:');
-  console.log('  git commit -m "auto"     # Genera mensaje automáticamente');
-  console.log('  git commit -m "mensaje"  # Analiza código antes del commit');
-  console.log('  git commit --no-verify   # Omite el análisis completamente');
-  console.log('\nExcluir código del análisis:');
-  console.log('  // SKIP-ANALYSIS         # Excluye la siguiente línea');
-  console.log('  // SKIP_ANALYSIS_BLOCK  # Excluye bloque hasta encontrar otro igual');
-  console.log('  ...código excluido...');
+  success('Claude Git Hooks installed successfully! 🎉');
+  console.log('\nUsage:');
+  console.log('  git commit -m "auto"     # Generate message automatically');
+  console.log('  git commit -m "message"  # Analyze code before commit');
+  console.log('  git commit --no-verify   # Skip analysis completely');
+  console.log('\nExclude code from analysis:');
+  console.log('  // SKIP-ANALYSIS         # Exclude the next line');
+  console.log('  // SKIP_ANALYSIS_BLOCK  # Exclude block until finding another equal one');
+  console.log('  ...excluded code...');
   console.log('  // SKIP_ANALYSIS_BLOCK');
-  console.log('\nPara más opciones: claude-hooks --help');
+  console.log('\nFor more options: claude-hooks --help');
 }
 
-// Verificar dependencias completas (como setup-wsl.sh)
+// Check complete dependencies (like setup-wsl.sh)
 async function checkAndInstallDependencies(sudoPassword = null, skipAuth = false) {
-  info('Verificando dependencias del sistema...');
+  info('Checking system dependencies...');
   
-  // Verificar Node.js
+  // Check 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.');
+    error('Node.js is not installed. Install Node.js and try again.');
   }
   
-  // Verificar npm
+  // Check npm
   try {
     const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
     success(`npm ${npmVersion}`);
   } catch (e) {
-    error('npm no está instalado.');
+    error('npm is not installed.');
   }
   
-  // Verificar e instalar jq
+  // Check and install jq
   try {
     const jqVersion = execSync('jq --version', { encoding: 'utf8' }).trim();
     success(`jq ${jqVersion}`);
   } catch (e) {
-    warning('jq no está instalado. Instalando...');
+    warning('jq is not installed. Installing...');
     if (installPackage('jq', sudoPassword)) {
-      success('jq instalado correctamente');
+      success('jq installed successfully');
     } else {
-      warning('No se pudo instalar jq automáticamente');
+      warning('Could not install jq automatically');
       if (os.platform() === 'linux') {
-        console.log('Instálalo manualmente con: sudo apt install jq');
+        console.log('Install it manually with: sudo apt install jq');
       } else if (os.platform() === 'darwin') {
-        console.log('Instálalo manualmente con: brew install jq');
+        console.log('Install it manually with: brew install jq');
       }
     }
   }
   
-  // Verificar e instalar curl
+  // Check and install 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...');
+    warning('curl is not installed. Installing...');
     if (installPackage('curl', sudoPassword)) {
-      success('curl instalado correctamente');
+      success('curl installed successfully');
     } else {
-      warning('No se pudo instalar curl automáticamente');
+      warning('Could not install curl automatically');
       if (os.platform() === 'linux') {
-        console.log('Instálalo manualmente con: sudo apt install curl');
+        console.log('Install it manually with: sudo apt install curl');
       } else if (os.platform() === 'darwin') {
-        console.log('Instálalo manualmente con: brew install curl');
+        console.log('Install it manually with: brew install curl');
       }
     }
   }
   
-  // Verificar Git
+  // Check 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.');
+    error('Git is not installed. Install Git and try again.');
   }
   
-  // Verificar herramientas Unix estándar
+  // Check standard Unix tools
   const unixTools = ['sed', 'awk', 'grep', 'head', 'tail', 'stat', 'tput'];
   const missingTools = [];
   
@@ -530,26 +530,26 @@ async function checkAndInstallDependencies(sudoPassword = null, skipAuth = false
   });
   
   if (missingTools.length === 0) {
-    success('Herramientas Unix estándar verificadas');
+    success('Standard Unix tools verified');
   } else {
-    error(`Faltan herramientas Unix estándar: ${missingTools.join(', ')}. Reintenta instalación en una consola Ubuntu`);
+    error(`Missing standard Unix tools: ${missingTools.join(', ')}. Retry installation in an Ubuntu console`);
   }
   
-  // Verificar e instalar Claude CLI
+  // Check and install Claude CLI
   await checkAndInstallClaude();
   
-  // Verificar autenticación de Claude (si no se salta)
+  // Check Claude authentication (if not skipped)
   if (!skipAuth) {
     await checkClaudeAuth();
   } else {
-    warning('Saltando verificación de autenticación de Claude (--skip-auth)');
+    warning('Skipping Claude authentication verification (--skip-auth)');
   }
   
-  // Limpiar contraseña de memoria
+  // Clear password from memory
   sudoPassword = null;
 }
 
-// Verificar si necesitamos instalar dependencias
+// Check if we need to install dependencies
 async function checkIfInstallationNeeded() {
   const dependencies = ['jq', 'curl'];
   
@@ -557,7 +557,7 @@ async function checkIfInstallationNeeded() {
     try {
       execSync(`which ${dep}`, { stdio: 'ignore' });
     } catch (e) {
-      return true; // Necesita instalación
+      return true; // Needs installation
     }
   }
   
@@ -565,33 +565,33 @@ async function checkIfInstallationNeeded() {
   try {
     execSync('claude --version', { stdio: 'ignore' });
   } catch (e) {
-    return true; // Necesita instalación de Claude
+    return true; // Needs Claude installation
   }
   
   return false;
 }
 
-// Verificar e instalar Claude CLI
+// Check and install Claude CLI
 async function checkAndInstallClaude() {
   try {
     execSync('claude --version', { stdio: 'ignore' });
-    success('Claude CLI detectado');
+    success('Claude CLI detected');
   } catch (e) {
-    info('Claude CLI no detectado. Instalando...');
+    info('Claude CLI not detected. Installing...');
     try {
       execSync('npm install -g @anthropic-ai/claude-cli', { stdio: 'inherit' });
-      success('Claude CLI instalado correctamente');
+      success('Claude CLI installed successfully');
     } catch (installError) {
-      error('Error al instalar Claude CLI. Instálalo manualmente: npm install -g @anthropic-ai/claude-cli');
+      error('Error installing Claude CLI. Install manually: npm install -g @anthropic-ai/claude-cli');
     }
   }
 }
 
-// Verificar autenticación de Claude con entretenimiento
+// Check Claude authentication with entertainment
 async function checkClaudeAuth() {
-  info('Verificando autenticación de Claude...');
+  info('Checking Claude authentication...');
   
-  // Usar spawn para no bloquear, pero con stdio: 'ignore' como el original
+  // Use spawn to not block, but with stdio: 'ignore' like the original
   const authPromise = new Promise((resolve, reject) => {
     const child = spawn('claude', ['auth', 'status'], {
       stdio: 'ignore',  // Igual que el original
@@ -599,7 +599,7 @@ async function checkClaudeAuth() {
       windowsHide: true
     });
     
-    // Timeout manual ya que spawn no tiene timeout nativo
+    // Manual timeout since spawn doesn't have native timeout
     const timeout = setTimeout(() => {
       child.kill();
       reject(new Error('timeout'));
@@ -621,18 +621,18 @@ async function checkClaudeAuth() {
   });
 
   try {
-    await Entertainment.showSpinner(authPromise, 'Verificando autenticación de Claude');
-    success('Autenticado en Claude');
+    await Entertainment.showSpinner(authPromise, 'Checking Claude authentication');
+    success('Authenticated in Claude');
   } catch (e) {
-    warning('No estás autenticado en Claude');
-    console.log('Ejecuta: claude auth login');
-    console.log('Después vuelve a ejecutar este comando');
+    warning('You are not authenticated in Claude');
+    console.log('Run: claude auth login');
+    console.log('Then run this command again');
   }
 }
 
-// Actualizar .gitignore con las entradas de Claude
+// Update .gitignore with Claude entries
 function updateGitignore() {
-  info('Actualizando .gitignore...');
+  info('Updating .gitignore...');
   
   const gitignorePath = '.gitignore';
   const claudeEntries = [
@@ -646,22 +646,22 @@ function updateGitignore() {
   let gitignoreContent = '';
   let fileExists = false;
   
-  // Leer .gitignore existente si existe
+  // Read existing .gitignore if it exists
   if (fs.existsSync(gitignorePath)) {
     gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
     fileExists = true;
   }
   
-  // Verificar qué entradas faltan
+  // Check which entries are missing
   const missingEntries = [];
   claudeEntries.forEach(entry => {
     if (entry.startsWith('#')) {
-      // Para comentarios, verificar si ya existe algún comentario de Claude
+      // For comments, check if any Claude comment already exists
       if (!gitignoreContent.includes('# Claude')) {
         missingEntries.push(entry);
       }
     } else {
-      // Para entradas normales, verificar si ya están presentes
+      // For normal entries, check if they are already present
       const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'm');
       if (!regex.test(gitignoreContent)) {
         missingEntries.push(entry);
@@ -669,70 +669,70 @@ function updateGitignore() {
     }
   });
   
-  // Si hay entradas faltantes, agregarlas
+  // If there are missing entries, add them
   if (missingEntries.length > 0) {
-    // Asegurar que hay una nueva línea al final si el archivo existe y no está vacío
+    // Ensure there's a newline at the end if the file exists and is not empty
     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 the file is not empty, add a blank line before
     if (gitignoreContent.length > 0) {
       gitignoreContent += '\n';
     }
     
-    // Agregar las entradas faltantes
+    // Add the missing entries
     gitignoreContent += missingEntries.join('\n') + '\n';
     
-    // Escribir el archivo actualizado
+    // Write the updated file
     fs.writeFileSync(gitignorePath, gitignoreContent);
     
     if (fileExists) {
-      success('.gitignore actualizado con entradas de Claude');
+      success('.gitignore updated with Claude entries');
     } else {
-      success('.gitignore creado con entradas de Claude');
+      success('.gitignore created with Claude entries');
     }
     
-    // Mostrar qué se agregó
+    // Show what was added
     missingEntries.forEach(entry => {
       if (!entry.startsWith('#')) {
         info(`  + ${entry}`);
       }
     });
   } else {
-    info('.gitignore ya contiene todas las entradas necesarias');
+    info('.gitignore already contains all necessary entries');
   }
 }
 
-// Configurar Git (line endings, etc.)
+// Configure Git (line endings, etc.)
 function configureGit() {
-  info('Configurando Git...');
+  info('Configuring Git...');
   
   try {
-    // Configurar line endings para WSL
+    // Configure line endings for WSL
     execSync('git config core.autocrlf input', { stdio: 'ignore' });
-    success('Line endings configurados para WSL (core.autocrlf = input)');
+    success('Line endings configured for WSL (core.autocrlf = input)');
     
-    // Intentar configurar en Windows a través de PowerShell
+    // Try to configure on Windows through PowerShell
     try {
       execSync('powershell.exe -Command "git config core.autocrlf true"', { stdio: 'ignore' });
-      success('Line endings configurados para Windows (core.autocrlf = true)');
+      success('Line endings configured for Windows (core.autocrlf = true)');
     } catch (psError) {
-      info('No se pudo configurar automáticamente en Windows');
+      info('Could not configure automatically on Windows');
     }
     
   } catch (e) {
-    warning('Error al configurar Git');
+    warning('Error configuring Git');
   }
 }
 
-// Comando uninstall
+// Uninstall command
 function uninstall() {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
   }
 
-  info('Desinstalando Claude Git Hooks...');
+  info('Uninstalling Claude Git Hooks...');
 
   const hooksPath = '.git/hooks';
   const hooks = ['pre-commit', 'prepare-commit-msg'];
@@ -741,17 +741,17 @@ function uninstall() {
     const hookPath = path.join(hooksPath, hook);
     if (fs.existsSync(hookPath)) {
       fs.unlinkSync(hookPath);
-      success(`${hook} eliminado`);
+      success(`${hook} removed`);
     }
   });
 
-  success('Claude Git Hooks desinstalado');
+  success('Claude Git Hooks uninstalled');
 }
 
-// Comando enable
+// Enable command
 function enable(hookName) {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
   }
 
   const hooks = hookName ? [hookName] : ['pre-commit', 'prepare-commit-msg'];
@@ -762,19 +762,19 @@ function enable(hookName) {
     
     if (fs.existsSync(disabledPath)) {
       fs.renameSync(disabledPath, enabledPath);
-      success(`${hook} habilitado`);
+      success(`${hook} enabled`);
     } else if (fs.existsSync(enabledPath)) {
-      info(`${hook} ya está habilitado`);
+      info(`${hook} is already enabled`);
     } else {
-      warning(`${hook} no encontrado`);
+      warning(`${hook} not found`);
     }
   });
 }
 
-// Comando disable
+// Disable command
 function disable(hookName) {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
   }
 
   const hooks = hookName ? [hookName] : ['pre-commit', 'prepare-commit-msg'];
@@ -785,115 +785,110 @@ function disable(hookName) {
     
     if (fs.existsSync(enabledPath)) {
       fs.renameSync(enabledPath, disabledPath);
-      success(`${hook} deshabilitado`);
+      success(`${hook} disabled`);
     } else if (fs.existsSync(disabledPath)) {
-      info(`${hook} ya está deshabilitado`);
+      info(`${hook} is already disabled`);
     } else {
-      warning(`${hook} no encontrado`);
+      warning(`${hook} not found`);
     }
   });
 }
 
-// Comando analyze-diff
+// Analyze-diff command
 function analyzeDiff(args) {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
     return;
   }
 
   const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
   
   if (!currentBranch) {
-    error('No estás en una rama válida.');
+    error('You are not in a valid branch.');
     return;
   }
 
+  // Update remote references
+  execSync('git fetch', { stdio: 'ignore' });
+
   let baseBranch, compareWith, contextDescription;
 
   if (args[0]) {
-    // Caso con argumento: comparar rama actual vs rama especificada
-    baseBranch = args[0];
+    // Case with argument: compare current branch vs origin/specified-branch
+    const targetBranch = args[0];
+    baseBranch = `origin/${targetBranch}`;
     compareWith = `${baseBranch}...HEAD`;
     contextDescription = `${currentBranch} vs ${baseBranch}`;
     
-    // Verificar que la rama base existe
+    // Check that the origin branch exists
     try {
       execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
     } catch (e) {
-      error(`La rama ${baseBranch} no existe.`);
+      error(`Branch ${baseBranch} does not exist.`);
       return;
     }
   } else {
-    // Caso sin argumento: comparar local vs remoto
+    // Case without argument: compare current branch vs origin/current-branch
+    baseBranch = `origin/${currentBranch}`;
+    compareWith = `${baseBranch}...HEAD`;
+    contextDescription = `${currentBranch} vs ${baseBranch}`;
+    
+    // Check that the origin branch exists
     try {
-      // Obtener la rama remota tracked
-      const remoteBranch = execSync(`git rev-parse --abbrev-ref ${currentBranch}@{upstream}`, { encoding: 'utf8' }).trim();
-      
-      // Actualizar referencias remotas
-      execSync('git fetch', { stdio: 'ignore' });
-      
-      baseBranch = remoteBranch;
-      compareWith = `HEAD..${remoteBranch}`;
-      contextDescription = `cambios locales sin pushear en ${currentBranch}`;
-      
-      info(`Comparando cambios locales vs remoto: ${remoteBranch}`);
+      execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
     } catch (e) {
-      // Si no hay rama remota, usar develop como fallback
-      baseBranch = 'develop';
+      // Try fallback to origin/develop
+      baseBranch = 'origin/develop';
       compareWith = `${baseBranch}...HEAD`;
-      contextDescription = `${currentBranch} vs ${baseBranch} (sin rama remota)`;
+      contextDescription = `${currentBranch} vs ${baseBranch} (fallback)`;
       
       try {
         execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
-        warning(`No hay rama remota configurada. Comparando con ${baseBranch}.`);
+        warning(`Branch origin/${currentBranch} does not exist. Using ${baseBranch} as fallback.`);
       } catch (e2) {
-        baseBranch = 'main';
+        // Try fallback to origin/main
+        baseBranch = 'origin/main';
         compareWith = `${baseBranch}...HEAD`;
         contextDescription = `${currentBranch} vs ${baseBranch} (fallback)`;
         
         try {
           execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
-          warning(`No hay develop ni rama remota. Comparando con main.`);
+          warning(`No origin/develop branch. Using ${baseBranch} as fallback.`);
         } catch (e3) {
-          error('No se pudo encontrar una rama de comparación válida.');
+          error('Could not find a valid comparison branch (tried origin/current, origin/develop, origin/main).');
           return;
         }
       }
     }
   }
 
-  info(`Analizando: ${contextDescription}...`);
+  info(`Analyzing: ${contextDescription}...`);
 
-  // Obtener los archivos modificados
+  // Get modified files
   let diffFiles;
   try {
-    // Para cambios locales sin pushear, invertir la comparación
-    if (!args[0] && compareWith.includes('HEAD..')) {
-      diffFiles = execSync(`git diff ${compareWith} --name-only`, { encoding: 'utf8' }).trim();
-    } else {
-      diffFiles = execSync(`git diff ${compareWith} --name-only`, { encoding: 'utf8' }).trim();
-    }
+    diffFiles = execSync(`git diff ${compareWith} --name-only`, { encoding: 'utf8' }).trim();
     
     if (!diffFiles) {
-      // Verificar si hay cambios staged o unstaged
+      // Check if there are staged or unstaged changes
       const stagedFiles = execSync('git diff --cached --name-only', { encoding: 'utf8' }).trim();
       const unstagedFiles = execSync('git diff --name-only', { encoding: 'utf8' }).trim();
       
       if (stagedFiles || unstagedFiles) {
-        warning('No hay diferencias con el remoto, pero tienes cambios locales sin commitear.');
-        console.log('Cambios staged:', stagedFiles || 'ninguno');
-        console.log('Cambios unstaged:', unstagedFiles || 'ninguno');
+        warning('No differences with remote, but you have uncommitted local changes.');
+        console.log('Staged changes:', stagedFiles || 'none');
+        console.log('Unstaged changes:', unstagedFiles || 'none');
       } else {
-        success('✅ No hay diferencias. Tu rama está sincronizada.');
+        success('✅ No differences. Your branch is synchronized.');
       }
       return;
     }
   } catch (e) {
-    error('Error al obtener las diferencias: ' + e.message);
+    error('Error getting differences: ' + e.message);
     return;
   }
 
-  // Obtener el diff completo
+  // Get the complete diff
   let fullDiff, commits;
   try {
     if (!args[0] && compareWith.includes('HEAD..')) {
@@ -904,50 +899,50 @@ function analyzeDiff(args) {
       commits = execSync(`git log ${baseBranch}..HEAD --oneline`, { encoding: 'utf8' }).trim();
     }
   } catch (e) {
-    error('Error al obtener diff o commits: ' + e.message);
+    error('Error getting diff or commits: ' + e.message);
     return;
   }
   
-  // Crear el prompt para Claude
+  // Create the prompt for Claude
   const tempDir = `/tmp/claude-analyze-${Date.now()}`;
   fs.mkdirSync(tempDir, { recursive: true });
   
   const promptFile = path.join(tempDir, 'prompt.txt');
-  const prompt = `Analiza los siguientes cambios. CONTEXTO: ${contextDescription}
+  const prompt = `Analyze the following changes. CONTEXT: ${contextDescription}
 
-Por favor genera:
-1. Un título de PR conciso y descriptivo (máximo 72 caracteres)
-2. Una descripción detallada del PR que incluya:
-   - Resumen de los cambios
-   - Motivación/contexto  
-   - Tipo de cambio (feature/fix/refactor/docs/etc)
-   - Testing recomendado
-3. Un nombre de rama sugerido siguiendo el formato: tipo/descripcion-corta (ejemplo: feature/add-user-auth, fix/memory-leak)
+Please generate:
+1. A concise and descriptive PR title (maximum 72 characters)
+2. A detailed PR description that includes:
+   - Summary of changes
+   - Motivation/context  
+   - Type of change (feature/fix/refactor/docs/etc)
+   - Recommended testing
+3. A suggested branch name following the format: type/short-description (example: feature/add-user-auth, fix/memory-leak)
 
-IMPORTANTE: Si estos son cambios locales sin pushear, el nombre de rama sugerido debe ser para crear una nueva rama desde la actual.
+IMPORTANT: If these are local changes without push, the suggested branch name should be for creating a new branch from the current one.
 
-Responde EXCLUSIVAMENTE con un JSON válido con esta estructura:
+Respond EXCLUSIVELY with a valid JSON with this structure:
 {
-  "prTitle": "título del PR",
-  "prDescription": "descripción detallada del PR con markdown",
-  "suggestedBranchName": "tipo/nombre-rama-sugerido",
+  "prTitle": "Interesting PR title",
+  "prDescription": "detailed PR description with markdown",
+  "suggestedBranchName": "type/suggested-branch-name",
   "changeType": "feature|fix|refactor|docs|test|chore",
   "breakingChanges": false,
-  "testingNotes": "notas sobre testing necesario"
+  "testingNotes": "notes on necessary testing or 'None'"
 }
 
 === COMMITS ===
 ${commits}
 
-=== ARCHIVOS MODIFICADOS ===
+=== CHANGED FILES ===
 ${diffFiles}
 
-=== DIFF COMPLETO ===
-${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncado)' : ''}`;
+=== FULL DIFF ===
+${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (truncated diff)' : ''}`;
 
   fs.writeFileSync(promptFile, prompt);
 
-  info('Enviando a Claude para análisis...');
+  info('Sending to Claude for analysis...');
   
   try {
     const response = execSync(`claude < "${promptFile}"`, { encoding: 'utf8', maxBuffer: 1024 * 1024 * 10 });
@@ -955,8 +950,8 @@ ${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncad
     // Extraer el JSON de la respuesta
     const jsonMatch = response.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
-      error('No se recibió una respuesta JSON válida de Claude.');
-      console.log('Respuesta completa:', response);
+      error('Did not receive a valid JSON response from Claude.');
+      console.log('Complete response:', response);
       return;
     }
     
@@ -964,45 +959,45 @@ ${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncad
     try {
       result = JSON.parse(jsonMatch[0]);
     } catch (e) {
-      error('Error al parsear la respuesta JSON: ' + e.message);
-      console.log('JSON recibido:', jsonMatch[0]);
+      error('Error parsing JSON response: ' + e.message);
+      console.log('JSON received:', jsonMatch[0]);
       return;
     }
     
-    // Mostrar los resultados
+    // Show the results
     console.log('');
-    console.log('═══════════════════════════════════════════════════════════════');
-    console.log('                    ANÁLISIS DE DIFERENCIAS                    ');
-    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('════════════════════════════════════════════════════════════════');
+    console.log('                      DIFFERENCES ANALYSIS                      ');
+    console.log('════════════════════════════════════════════════════════════════');
     console.log('');
     
-    console.log(`🔍 ${colors.blue}Contexto:${colors.reset} ${contextDescription}`);
-    console.log(`📊 ${colors.blue}Archivos modificados:${colors.reset} ${diffFiles.split('\n').length}`);
+    console.log(`🔍 ${colors.blue}Context:${colors.reset} ${contextDescription}`);
+    console.log(`📊 ${colors.blue}Changed Files:${colors.reset} ${diffFiles.split('\n').length}`);
     console.log('');
     
-    console.log(`📝 ${colors.green}Título del PR:${colors.reset}`);
+    console.log(`📝 ${colors.green}Pull Request Title:${colors.reset}`);
     console.log(`   ${result.prTitle}`);
     console.log('');
     
-    console.log(`🌿 ${colors.green}Nombre de rama sugerido:${colors.reset}`);
+    console.log(`🌿 ${colors.green}Suggested branch name:${colors.reset}`);
     console.log(`   ${result.suggestedBranchName}`);
     console.log('');
     
-    console.log(`📋 ${colors.green}Tipo de cambio:${colors.reset} ${result.changeType}`);
+    console.log(`📋 ${colors.green}Type of change:${colors.reset} ${result.changeType}`);
     
     if (result.breakingChanges) {
       console.log(`⚠️  ${colors.yellow}Breaking Changes: SÍ${colors.reset}`);
     }
     
     console.log('');
-    console.log(`📄 ${colors.green}Descripción del PR:${colors.reset}`);
+    console.log(`📄 ${colors.green}Pull Request Description:${colors.reset}`);
     console.log('───────────────────────────────────────────────────────────────');
     console.log(result.prDescription);
     console.log('───────────────────────────────────────────────────────────────');
     
     if (result.testingNotes) {
       console.log('');
-      console.log(`🧪 ${colors.green}Notas de Testing:${colors.reset}`);
+      console.log(`🧪 ${colors.green}Testing notes:${colors.reset}`);
       console.log(result.testingNotes);
     }
     
@@ -1021,27 +1016,27 @@ ${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncad
     const outputFile = '.claude-pr-analysis.json';
     fs.writeFileSync(outputFile, JSON.stringify(outputData, null, 2));
     console.log('');
-    info(`Resultados guardados en ${outputFile}`);
+    info(`Results saved in ${outputFile}`);
     
     // Sugerencias contextuales
     console.log('');
-    if (!args[0] && contextDescription.includes('cambios locales sin pushear')) {
-      // Caso de cambios locales sin pushear
-      console.log(`💡 ${colors.yellow}Para crear nueva rama con estos cambios:${colors.reset}`);
+    if (!args[0] && contextDescription.includes('local changes without push')) {
+      // Case of local changes without push
+      console.log(`💡 ${colors.yellow}To create new branch with these changes:${colors.reset}`);
       console.log(`   git checkout -b ${result.suggestedBranchName}`);
       console.log(`   git push -u origin ${result.suggestedBranchName}`);
     } else if (currentBranch !== result.suggestedBranchName) {
       // Caso normal de comparación entre ramas  
-      console.log(`💡 ${colors.yellow}Para renombrar tu rama actual:${colors.reset}`);
+      console.log(`💡 ${colors.yellow}For renaming your current branch:${colors.reset}`);
       console.log(`   git branch -m ${result.suggestedBranchName}`);
     }
     
-    console.log(`💡 ${colors.yellow}Tip:${colors.reset} Usa esta información para crear tu PR en GitHub.`);
+    console.log(`💡 ${colors.yellow}Tip:${colors.reset} Use this information to create your PR on GitHub.`);
     
   } catch (e) {
-    error('Error al ejecutar Claude: ' + e.message);
+    error('Error executing Claude: ' + e.message);
   } finally {
-    // Limpiar archivos temporales
+    // Clean temporary files
     fs.rmSync(tempDir, { recursive: true, force: true });
   }
 }
@@ -1049,10 +1044,10 @@ ${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncad
 // Comando status
 function status() {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
   }
 
-  info('Estado de Claude Git Hooks:\n');
+  info('Claude Git Hooks status:\n');
 
   const hooks = ['pre-commit', 'prepare-commit-msg'];
   hooks.forEach(hook => {
@@ -1060,25 +1055,25 @@ function status() {
     const disabledPath = `.git/hooks/${hook}.disabled`;
     
     if (fs.existsSync(enabledPath)) {
-      success(`${hook}: habilitado`);
+      success(`${hook}: enabled`);
     } else if (fs.existsSync(disabledPath)) {
-      warning(`${hook}: deshabilitado`);
+      warning(`${hook}: disabled`);
     } else {
-      error(`${hook}: no instalado`);
+      error(`${hook}: not installed`);
     }
   });
 
-  // Verificar archivos de pautas
-  console.log('\nArchivos de pautas:');
+  // Check guidelines files
+  console.log('\nGuidelines files:');
   const guidelines = ['CLAUDE_PRE_COMMIT_SONAR.md'];
   guidelines.forEach(guideline => {
     const claudePath = path.join('.claude', guideline);
     if (fs.existsSync(claudePath)) {
-      success(`${guideline}: presente en .claude/`);
+      success(`${guideline}: present in .claude/`);
     } else if (fs.existsSync(guideline)) {
-      warning(`${guideline}: presente en raíz (debería estar en .claude/)`);
+      warning(`${guideline}: present in root (should be in .claude/)`);
     } else {
-      warning(`${guideline}: faltante`);
+      warning(`${guideline}: missing`);
     }
   });
 
@@ -1093,25 +1088,25 @@ function status() {
     claudeIgnores.forEach(entry => {
       const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'm');
       if (regex.test(gitignoreContent)) {
-        success(`${entry}: incluido`);
+        success(`${entry}: included`);
       } else {
-        warning(`${entry}: faltante`);
+        warning(`${entry}: missing`);
         allPresent = false;
       }
     });
     
     if (!allPresent) {
-      info('\nEjecuta "claude-hooks install" para actualizar .gitignore');
+      info('\nRun "claude-hooks install" to update .gitignore');
     }
   } else {
-    warning('.gitignore no existe');
+    warning('.gitignore doesn´t exist');
   }
 }
 
 // Comando set-mode
 function setMode(mode) {
   if (!checkGitRepo()) {
-    error('No estás en un repositorio Git.');
+    error('You are not in a Git repository.');
   }
 }
 
@@ -1147,9 +1142,9 @@ function compareVersions(v1, v2) {
   }
 }
 
-// Comando update - actualizar a la última versión
+// Update command - update to the latest version
 async function update() {
-  info('Verificando última versión disponible...');
+  info('Checking latest available version...');
   
   try {
     const currentVersion = require('../package.json').version;
@@ -1158,40 +1153,40 @@ async function update() {
     const comparison = compareVersions(currentVersion, latestVersion);
     
     if (comparison === 0) {
-      success(`Ya tienes la última versión instalada (${currentVersion})`);
+      success(`You already have the latest version installed (${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})`);
+      info(`You are using a development version (${currentVersion})`);
+      info(`Latest published version: ${latestVersion}`);
+      success(`You already have the latest version installed (${currentVersion})`);
       return;
     }
     
-    info(`Versión actual: ${currentVersion}`);
-    info(`Versión disponible: ${latestVersion}`);
+    info(`Current version: ${currentVersion}`);
+    info(`Available version: ${latestVersion}`);
     
     // Actualizar el paquete
-    info('Actualizando claude-git-hooks...');
+    info('Updating claude-git-hooks...');
     try {
       execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
-      success(`Actualizado exitosamente a la versión ${latestVersion}`);
+      success(`Successfully updated to version ${latestVersion}`);
       
-      // Reinstalar hooks con la nueva versión
-      info('Reinstalando hooks con la nueva versión...');
+      // Reinstall hooks with the new version
+      info('Reinstalling hooks with the new version...');
       await install(['--force']);
       
     } catch (updateError) {
-      error('Error al actualizar. Intenta ejecutar: npm install -g claude-git-hooks@latest');
+      error('Error updating. Try running: 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...');
+    warning('Could not check the latest available version');
+    warning('Trying to update anyway...');
     try {
       execSync('npm install -g claude-git-hooks@latest', { stdio: 'inherit' });
-      success('Actualización completada');
+      success('Update completed');
       await install(['--force']);
     } catch (updateError) {
-      error('Error al actualizar: ' + updateError.message);
+      error('Error updating: ' + updateError.message);
     }
   }
 }
@@ -1199,54 +1194,54 @@ async function update() {
 // Comando help
 function showHelp() {
   console.log(`
-Claude Git Hooks - Análisis de código y mensajes automáticos con Claude CLI
-
-Uso: claude-hooks <comando> [opciones]
-
-Comandos:
-  install [opciones]   Instala los hooks en el repositorio actual
-    --force           Reinstala aunque ya existan
-    --skip-auth       Salta la verificación de autenticación de Claude
-  update               Actualiza a la última versión disponible
-  uninstall            Desinstala los hooks del repositorio
-  enable [hook]        Habilita hooks (todos o uno específico)
-  disable [hook]       Deshabilita hooks (todos o uno específico)
-  status               Muestra el estado de los hooks
-  analyze-diff [base]  Analiza diferencias entre ramas y genera PR info
-  help                 Muestra esta ayuda
-
-Hooks disponibles:
-  pre-commit           Análisis de código antes del commit
-  prepare-commit-msg   Generación automática de mensajes
-
-Ejemplos:
-  claude-hooks install              # Instala todos los hooks
-  claude-hooks install --skip-auth  # Instala sin verificar autenticación
-  claude-hooks update               # Actualiza a la última versión
-  claude-hooks disable pre-commit   # Deshabilita solo pre-commit
-  claude-hooks enable               # Habilita todos los hooks
-  claude-hooks status               # Ver estado actual
-  claude-hooks analyze-diff main    # Analiza diferencias con main
-
-Casos de uso de commits:
-  git commit -m "mensaje"           # Mensaje manual + análisis bloqueante
-  git commit -m "auto"              # Mensaje automático + análisis bloqueante
-  git commit --no-verify -m "auto"  # Mensaje automático sin análisis
-  git commit --no-verify -m "msg"   # Mensaje manual sin análisis
-
-Caso de uso analyze-diff:
-  claude-hooks analyze-diff main    # Analiza cambios vs main y genera:
-    → Título PR: "feat: add user authentication module"
-    → Descripción PR: "## Summary\n- Added JWT authentication..." 
-    → Rama sugerida: "feature/user-authentication"
-
-Excluir código del análisis:
-  // SKIP-ANALYSIS                  # Excluye la siguiente línea del análisis
-  // SKIP_ANALYSIS_BLOCK           # Excluye bloque hasta encontrar otro igual
-  ...código excluido...
+Claude Git Hooks - Code analysis and automatic messages with Claude CLI
+
+Usage: claude-hooks <command> [options]
+
+Commands:
+  install [options]    Install hooks in the current repository
+    --force           Reinstall even if they already exist
+    --skip-auth       Skip Claude authentication verification
+  update               Update to the latest available version
+  uninstall            Uninstall hooks from the repository
+  enable [hook]        Enable hooks (all or one specific)
+  disable [hook]       Disable hooks (all or one specific)
+  status               Show the status of hooks
+  analyze-diff [base]  Analyze differences between branches and generate PR info
+  help                 Show this help
+
+Available hooks:
+  pre-commit           Code analysis before commit
+  prepare-commit-msg   Automatic message generation
+
+Examples:
+  claude-hooks install              # Install all hooks
+  claude-hooks install --skip-auth  # Install without verifying authentication
+  claude-hooks update               # Update to the latest version
+  claude-hooks disable pre-commit   # Disable only pre-commit
+  claude-hooks enable               # Enable all hooks
+  claude-hooks status               # View current status
+  claude-hooks analyze-diff main    # Analyze differences with main
+
+Commit use cases:
+  git commit -m "message"           # Manual message + blocking analysis
+  git commit -m "auto"              # Automatic message + blocking analysis
+  git commit --no-verify -m "auto"  # Automatic message without analysis
+  git commit --no-verify -m "msg"   # Manual message without analysis
+
+Analyze-diff use case:
+  claude-hooks analyze-diff main    # Analyze changes vs main and generate:
+    → PR Title: "feat: add user authentication module"
+    → PR Description: "## Summary\n- Added JWT authentication..." 
+    → Suggested branch: "feature/user-authentication"
+
+Exclude code from analysis:
+  // SKIP-ANALYSIS                  # Exclude the next line from analysis
+  // SKIP_ANALYSIS_BLOCK           # Exclude block until finding another equal one
+  ...excluded code...
   // SKIP_ANALYSIS_BLOCK
 
-Más información: https://github.com/pablorovito/claude-git-hooks
+More information: https://github.com/pablorovito/claude-git-hooks
 `);
 }
 
@@ -1284,12 +1279,12 @@ async function main() {
       showHelp();
       break;
     default:
-      error(`Comando desconocido: ${command}`);
+      error(`Unknown command: ${command}`);
       showHelp();
   }
 }
 
-// Ejecutar main
+// Execute main
 main().catch(err => {
-  error(`Error inesperado: ${err.message}`);
+  error(`Unexpected error: ${err.message}`);
 });