claude-git-hooks 1.4.1 → 1.5.0

package/CHANGELOG.md

@@ -5,6 +5,65 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2025-09-10
+
+### Added
+- 🔍 Nuevo comando `claude-hooks analyze-diff [base]` para análisis de diferencias entre ramas
+  - Genera título de PR conciso (máx. 72 caracteres)
+  - Crea descripción detallada del PR con markdown
+  - Sugiere nombre de rama siguiendo formato tipo/descripcion
+  - Identifica tipo de cambio (feature/fix/refactor/docs/test/chore)
+  - Detecta breaking changes
+  - Proporciona notas de testing recomendado
+  - Guarda resultados en `.claude-pr-analysis.json`
+
+### Changed
+- 🎯 Modo SonarQube ahora es el predeterminado (no hay selección interactiva)
+- ⚡ Eliminada lógica de selección de modo del pre-commit hook
+- 🗑️ Removidas referencias a guardado de preferencias `.claude-analysis-mode`
+
+### Fixed
+- 🐛 Eliminado prompt interactivo incompatible con algunas consolas
+- 🔧 Pre-commit ahora va directo al análisis sin solicitar input del usuario
+
+### Removed
+- 🗑️ Eliminada selección interactiva de modo de análisis
+- 🗑️ Removido comando `set-mode` (ya no es necesario)
+- 🗑️ Eliminada variable de entorno `CLAUDE_ANALYSIS_MODE`
+
+## [1.4.2] - 2025-09-08
+
+### Added
+- 🚫 Comentario `// SKIP-ANALYSIS` para excluir código del análisis
+  - Una línea: excluye la siguiente línea
+  - Bloque: código entre dos comentarios `// SKIP-ANALYSIS` es excluido
+- 📝 Excepciones para Spring Framework en criterios de evaluación
+  - `@Autowired` no es considerado issue bloqueante (máximo severidad MAJOR)
+  - Inyección de dependencias con field injection es aceptable
+
+### Changed
+- 📋 Actualizada documentación con casos de uso de commits clarificados
+- 🎯 Templates de prompts actualizados con reglas de Spring Framework
+
+### Fixed
+- 🔧 Clarificado que `git commit --no-verify -m "auto"` genera mensaje automático sin análisis
+
+## [1.4.1] - 2025-09-04
+
+### Changed
+- 🚀 **BREAKING**: Eliminado modo estándar, ahora solo existe modo SonarQube
+- ⚡ Prompts optimizados para Claude: reducción de ~80% en tokens manteniendo eficacia
+- 🎯 Nuevo formato ultra-compacto de prompts usando notación concisa y directivas claras
+- 📝 Templates simplificados: CLAUDE_ANALYSIS_PROMPT_SONAR.md, CLAUDE_PRE_COMMIT_SONAR.md, CLAUDE_RESOLUTION_PROMPT.md
+
+### Fixed
+- 🐛 Mejorada la lógica de escritura para mejor formación del prompt de resolución de problemas críticos
+- 🔧 Corregido el formato del prompt AI-friendly para resolución de issues
+
+### Removed
+- 🗑️ Eliminados archivos del modo estándar: CLAUDE_PRE_COMMIT.md, CLAUDE_ANALYSIS_PROMPT.md
+- 🗑️ Eliminada lógica de selección de modo (ahora siempre usa SonarQube)
+
 ## [1.4.0] - 2025-08-29
 
 ### Added

package/README.md

@@ -201,89 +201,78 @@ Cuando se detectan problemas críticos:
 - **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`
+- **Análisis de PR**: Nuevo comando `analyze-diff` para generar información de Pull Requests
 - **Validación de dependencias**: Verifica que Claude CLI esté autenticado antes de ejecutar
 
 ## 🛠️ Uso
 
 **IMPORTANTE**: Todos los comandos git deben ejecutarse desde WSL.
 
-### Commit normal
+### Casos de uso de commits
 
 ```bash
 # Desde WSL
 git add .
-git commit -m "feat: nueva funcionalidad"
-```
 
-### Commit con mensaje automático 🤖
+# 1. Mensaje manual + análisis bloqueante
+git commit -m "feat: nueva funcionalidad"
 
-```bash
-# Desde WSL
-git add .
+# 2. Mensaje automático + análisis bloqueante  
 git commit -m "auto"  # Claude generará el mensaje automáticamente
+
+# 3. Mensaje manual sin análisis
+git commit --no-verify -m "fix: corrección urgente"
+
+# 4. Mensaje automático sin análisis
+git commit --no-verify -m "auto"
 ```
 
 Claude analizará los cambios y generará un mensaje de commit siguiendo las convenciones (feat, fix, docs, etc.).
 
 **⚠️ Si la generación automática falla**: El commit se cancelará completamente. Simplemente ejecuta `git commit -m "tu mensaje"` manualmente.
 
-### Modos de análisis 📊
-
-Puedes elegir entre dos formatos de análisis:
+### Excluir código del análisis con SKIP-ANALYSIS
 
-#### 🎯 Configurar Modo (Recomendado)
-
-```bash
-# Cambiar a modo SonarQube (métricas y quality gate)
-claude-hooks set-mode sonar
+Puedes excluir código específico del análisis usando comentarios `// SKIP-ANALYSIS`:
 
-# Cambiar a modo estándar (score y recomendaciones)
-claude-hooks set-mode standard
-
-# Ver modo actual
-claude-hooks status
-```
+```java
+// Excluir una sola línea
+// SKIP-ANALYSIS
+@Autowired private LegacyService legacyService;  // Esta línea no será analizada
 
-#### 🔧 Variable de Entorno (Temporal)
-
-```bash
-# Sobrescribir temporalmente el modo configurado
-export CLAUDE_ANALYSIS_MODE=sonar
-git commit -m "mensaje"
-
-# Volver al modo configurado
-unset CLAUDE_ANALYSIS_MODE
+// Excluir un bloque de código
+// SKIP-ANALYSIS
+@Deprecated
+public void methodWithKnownIssues() {
+    // Código legacy que no queremos que sea analizado
+    System.out.println("Debug temporal");
+}
+// SKIP-ANALYSIS
 ```
 
-#### 📋 Diferencias entre Modos
-
-**Modo Estándar**:
-
-- Análisis con puntuación del 1-10
-- Recomendaciones detalladas por categoría
-- Formato tradicional fácil de leer
-
-**Modo SonarQube**:
+**Nota**: El código entre comentarios `SKIP-ANALYSIS` no será enviado a Claude para su análisis.
 
-- Quality Gate (PASSED/FAILED)
-- Métricas: Reliability, Security, Maintainability
-- Issues clasificados por severidad (Blocker, Critical, Major, Minor, Info)
-- Security hotspots
+### Análisis de diferencias entre ramas 🔍
 
-#### 🔄 Cambio de Modo Interactivo
+Nueva funcionalidad para analizar cambios y generar información para Pull Requests:
 
 ```bash
-# Sin parámetros muestra ayuda interactiva
-claude-hooks set-mode
+# Analizar diferencias con la rama main
+claude-hooks analyze-diff
+
+# Analizar diferencias con otra rama base
+claude-hooks analyze-diff develop
 ```
 
-### Saltar la revisión (usar con precaución)
+Este comando genera automáticamente:
+- 📝 Título de PR conciso (máx. 72 caracteres)
+- 📄 Descripción detallada con markdown
+- 🌿 Nombre de rama sugerido (formato: tipo/descripcion)
+- 📋 Tipo de cambio (feature/fix/refactor/docs/test/chore)
+- ⚠️ Indicador de breaking changes
+- 🧪 Notas de testing recomendado
 
-```bash
-# Desde WSL
-git commit --no-verify -m "fix: corrección urgente"
-```
+Los resultados se guardan en `.claude-pr-analysis.json` para fácil acceso.
 
 ### Modo debug
 
@@ -423,12 +412,6 @@ claude-hooks status
 
 ### Variables de entorno disponibles
 
-- **`CLAUDE_ANALYSIS_MODE`**: Selecciona el modo de análisis
-
-  - Valores: `"standard"` o `"sonar"`
-  - Ejemplo: `CLAUDE_ANALYSIS_MODE=sonar git commit -m "mensaje"`
-  - Sobrescribe la preferencia guardada en `.claude-analysis-mode`
-
 - **`DEBUG`**: Activa el modo debug
   - Valores: `1` para activar
   - Ejemplo: `DEBUG=1 git commit -m "mensaje"`

package/bin/claude-hooks

@@ -414,9 +414,7 @@ async function install(args) {
 
   // Copiar archivos de pautas y prompts a .claude
   const claudeFiles = [
-    'CLAUDE_PRE_COMMIT.md', 
     'CLAUDE_PRE_COMMIT_SONAR.md',
-    'CLAUDE_ANALYSIS_PROMPT.md',
     'CLAUDE_ANALYSIS_PROMPT_SONAR.md',
     'CLAUDE_RESOLUTION_PROMPT.md'
   ];
@@ -446,6 +444,12 @@ async function install(args) {
   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         # Entre dos comentarios excluye el bloque');
+  console.log('  ...código excluido...');
+  console.log('  // SKIP-ANALYSIS');
   console.log('\nPara más opciones: claude-hooks --help');
 }
 
@@ -636,7 +640,8 @@ function updateGitignore() {
     '.claude/',
     '.claude-analysis-mode',
     'debug-claude-response.json',
-    'claude_resolution_prompt.md'
+    'claude_resolution_prompt.md',
+    '.claude-pr-analysis.json',
   ];
   
   let gitignoreContent = '';
@@ -790,6 +795,258 @@ function disable(hookName) {
   });
 }
 
+// Comando analyze-diff
+function analyzeDiff(args) {
+  if (!checkGitRepo()) {
+    error('No estás en un repositorio Git.');
+    return;
+  }
+
+  const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+  
+  if (!currentBranch) {
+    error('No estás en una rama válida.');
+    return;
+  }
+
+  let baseBranch, compareWith, contextDescription;
+
+  if (args[0]) {
+    // Caso con argumento: comparar rama actual vs rama especificada
+    baseBranch = args[0];
+    compareWith = `${baseBranch}...HEAD`;
+    contextDescription = `${currentBranch} vs ${baseBranch}`;
+    
+    // Verificar que la rama base existe
+    try {
+      execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+    } catch (e) {
+      error(`La rama ${baseBranch} no existe.`);
+      return;
+    }
+  } else {
+    // Caso sin argumento: comparar local vs remoto
+    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}`);
+    } catch (e) {
+      // Si no hay rama remota, usar develop como fallback
+      baseBranch = 'develop';
+      compareWith = `${baseBranch}...HEAD`;
+      contextDescription = `${currentBranch} vs ${baseBranch} (sin rama remota)`;
+      
+      try {
+        execSync(`git rev-parse --verify ${baseBranch}`, { stdio: 'ignore' });
+        warning(`No hay rama remota configurada. Comparando con ${baseBranch}.`);
+      } catch (e2) {
+        baseBranch = '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.`);
+        } catch (e3) {
+          error('No se pudo encontrar una rama de comparación válida.');
+          return;
+        }
+      }
+    }
+  }
+
+  info(`Analizando: ${contextDescription}...`);
+
+  // Obtener los archivos modificados
+  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();
+    }
+    
+    if (!diffFiles) {
+      // Verificar si hay cambios staged o unstaged
+      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');
+      } else {
+        success('✅ No hay diferencias. Tu rama está sincronizada.');
+      }
+      return;
+    }
+  } catch (e) {
+    error('Error al obtener las diferencias: ' + e.message);
+    return;
+  }
+
+  // Obtener el diff completo
+  let fullDiff, commits;
+  try {
+    if (!args[0] && compareWith.includes('HEAD..')) {
+      fullDiff = execSync(`git diff ${compareWith}`, { encoding: 'utf8' });
+      commits = execSync(`git log ${baseBranch}..HEAD --oneline`, { encoding: 'utf8' }).trim();
+    } else {
+      fullDiff = execSync(`git diff ${compareWith}`, { encoding: 'utf8' });
+      commits = execSync(`git log ${baseBranch}..HEAD --oneline`, { encoding: 'utf8' }).trim();
+    }
+  } catch (e) {
+    error('Error al obtener diff o commits: ' + e.message);
+    return;
+  }
+  
+  // Crear el prompt para 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}
+
+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)
+
+IMPORTANTE: Si estos son cambios locales sin pushear, el nombre de rama sugerido debe ser para crear una nueva rama desde la actual.
+
+Responde EXCLUSIVAMENTE con un JSON válido con esta estructura:
+{
+  "prTitle": "título del PR",
+  "prDescription": "descripción detallada del PR con markdown",
+  "suggestedBranchName": "tipo/nombre-rama-sugerido",
+  "changeType": "feature|fix|refactor|docs|test|chore",
+  "breakingChanges": false,
+  "testingNotes": "notas sobre testing necesario"
+}
+
+=== COMMITS ===
+${commits}
+
+=== ARCHIVOS MODIFICADOS ===
+${diffFiles}
+
+=== DIFF COMPLETO ===
+${fullDiff.substring(0, 50000)} ${fullDiff.length > 50000 ? '\n... (diff truncado)' : ''}`;
+
+  fs.writeFileSync(promptFile, prompt);
+
+  info('Enviando a Claude para análisis...');
+  
+  try {
+    const response = execSync(`claude < "${promptFile}"`, { encoding: 'utf8', maxBuffer: 1024 * 1024 * 10 });
+    
+    // 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);
+      return;
+    }
+    
+    let result;
+    try {
+      result = JSON.parse(jsonMatch[0]);
+    } catch (e) {
+      error('Error al parsear la respuesta JSON: ' + e.message);
+      console.log('JSON recibido:', jsonMatch[0]);
+      return;
+    }
+    
+    // Mostrar los resultados
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('                    ANÁLISIS DE DIFERENCIAS                    ');
+    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('');
+    
+    console.log(`📝 ${colors.green}Título del PR:${colors.reset}`);
+    console.log(`   ${result.prTitle}`);
+    console.log('');
+    
+    console.log(`🌿 ${colors.green}Nombre de rama sugerido:${colors.reset}`);
+    console.log(`   ${result.suggestedBranchName}`);
+    console.log('');
+    
+    console.log(`📋 ${colors.green}Tipo de cambio:${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('───────────────────────────────────────────────────────────────');
+    console.log(result.prDescription);
+    console.log('───────────────────────────────────────────────────────────────');
+    
+    if (result.testingNotes) {
+      console.log('');
+      console.log(`🧪 ${colors.green}Notas de Testing:${colors.reset}`);
+      console.log(result.testingNotes);
+    }
+    
+    // Guardar los resultados en un archivo con contexto
+    const outputData = {
+      ...result,
+      context: {
+        currentBranch,
+        baseBranch,
+        contextDescription,
+        filesChanged: diffFiles.split('\n').length,
+        timestamp: new Date().toISOString()
+      }
+    };
+    
+    const outputFile = '.claude-pr-analysis.json';
+    fs.writeFileSync(outputFile, JSON.stringify(outputData, null, 2));
+    console.log('');
+    info(`Resultados guardados en ${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}`);
+      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(`   git branch -m ${result.suggestedBranchName}`);
+    }
+    
+    console.log(`💡 ${colors.yellow}Tip:${colors.reset} Usa esta información para crear tu PR en GitHub.`);
+    
+  } catch (e) {
+    error('Error al ejecutar Claude: ' + e.message);
+  } finally {
+    // Limpiar archivos temporales
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
 // Comando status
 function status() {
   if (!checkGitRepo()) {
@@ -870,31 +1127,26 @@ function setMode(mode) {
     error('No estás en un repositorio Git.');
   }
 
-  const validModes = ['standard', 'sonar'];
+  const validModes = ['sonar'];
   
   if (!mode) {
     // Modo interactivo
-    console.log('\nSelecciona el modo de análisis:');
-    console.log('1) Standard - Formato clásico con score y recomendaciones');
-    console.log('2) SonarQube - Formato similar a SonarQube con métricas');
-    console.log('\nEjemplo de uso: claude-hooks set-mode standard');
-    console.log('                claude-hooks set-mode sonar');
+    console.log('\nModo de análisis configurado:');
+    console.log('SonarQube - Formato con métricas y quality gate');
+    console.log('\nEjemplo de uso: claude-hooks set-mode sonar');
     return;
   }
 
   if (!validModes.includes(mode)) {
-    error(`Modo inválido: ${mode}. Usa 'standard' o 'sonar'`);
+    error(`Modo inválido: ${mode}. Usa 'sonar'`);
   }
 
   // Guardar el modo
   fs.writeFileSync('.claude-analysis-mode', mode);
   
   if (mode === 'sonar') {
-    success('Modo cambiado a: SonarQube');
+    success('Modo configurado: SonarQube');
     info('Los commits usarán formato SonarQube con métricas y quality gate');
-  } else {
-    success('Modo cambiado a: Estándar');
-    info('Los commits usarán formato clásico con score y recomendaciones');
   }
 }
 
@@ -994,8 +1246,8 @@ Comandos:
   uninstall            Desinstala los hooks del repositorio
   enable [hook]        Habilita hooks (todos o uno específico)
   disable [hook]       Deshabilita hooks (todos o uno específico)
-  set-mode [standard|sonar]  Cambia el modo de análisis
   status               Muestra el estado de los hooks
+  analyze-diff [base]  Analiza diferencias entre ramas y genera PR info
   help                 Muestra esta ayuda
 
 Hooks disponibles:
@@ -1006,11 +1258,28 @@ Ejemplos:
   claude-hooks install              # Instala todos los hooks
   claude-hooks install --skip-auth  # Instala sin verificar autenticación
   claude-hooks update               # Actualiza a la última versión
-  claude-hooks set-mode sonar       # Cambiar a modo SonarQube
-  claude-hooks set-mode standard    # Cambiar a modo estándar
   claude-hooks disable pre-commit   # Deshabilita solo pre-commit
   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                  # Entre dos comentarios excluye el bloque
+  ...código excluido...
+  // SKIP-ANALYSIS
 
 Más información: https://github.com/pablorovito/claude-git-hooks
 `);
@@ -1037,12 +1306,12 @@ async function main() {
     case 'disable':
       disable(args[1]);
       break;
-    case 'set-mode':
-      setMode(args[1]);
-      break;
     case 'status':
       status();
       break;
+    case 'analyze-diff':
+      analyzeDiff(args.slice(1));
+      break;
     case 'help':
     case '--help':
     case '-h':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-git-hooks",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Git hooks con Claude CLI para análisis de código y generación automática de mensajes de commit",
   "main": "lib/index.js",
   "bin": {

package/templates/CLAUDE_ANALYSIS_PROMPT_SONAR.md

@@ -1,61 +1,56 @@
-Eres un revisor de código senior con experiencia en proyectos Spring Boot empresariales y métricas SonarQube.
-
-Tu tarea es analizar los siguientes cambios de código desde una perspectiva de calidad similar a SonarQube y responder exclusivamente con un JSON válido, **sin ningún texto fuera del JSON**, sin introducciones ni explicaciones adicionales.
-
-⚠️ La respuesta debe ser un objeto JSON con esta estructura exacta de SonarQube:
+ROLE:SeniorCodeReviewer,SonarQube-experienced
+TASK:Analyze code->JSON only
+CRITICAL:NoTextOutsideJSON,ValidJSON
 
+OUTPUT_SCHEMA:
 ```json
 {
-  "QUALITY_GATE": "PASSED",          // PASSED o FAILED
-  "approved": true,                  // compatibilidad con modo estándar
-  "score": 1-10,                      // calificación general
-  "metrics": {
-    "reliability": "A",              // A, B, C, D, E
-    "security": "A",                 // A, B, C, D, E  
-    "maintainability": "A",          // A, B, C, D, E
-    "coverage": 85,                  // porcentaje de cobertura estimado
-    "duplications": 2,               // porcentaje de duplicación estimado
-    "complexity": 15                 // complejidad ciclomática estimada
+  "QUALITY_GATE":"PASSED|FAILED",
+  "approved":bool,
+  "score":1-10,
+  "metrics":{
+    "reliability":"A-E",
+    "security":"A-E",
+    "maintainability":"A-E",
+    "coverage":0-100,
+    "duplications":0-100,
+    "complexity":int
   },
-  "issues": {
-    "blocker": 0,                    // cantidad de issues bloqueantes
-    "critical": 0,                   // cantidad de issues críticos
-    "major": 0,                      // cantidad de issues mayores
-    "minor": 0,                      // cantidad de issues menores
-    "info": 0                        // cantidad de issues informativos
+  "issues":{
+    "blocker":int,
+    "critical":int,
+    "major":int,
+    "minor":int,
+    "info":int
   },
-  "details": [                       // detalle de cada issue encontrado con localización
-    {
-      "severity": "CRITICAL",        // BLOCKER, CRITICAL, MAJOR, MINOR, INFO
-      "type": "BUG",                 // BUG, VULNERABILITY, CODE_SMELL
-      "file": "src/main/java/Example.java",
-      "line": 42,
-      "method": "processData",      // método o clase afectada
-      "message": "Null pointer dereference possible",
-      "rule": "java:S2259"          // regla de SonarQube (opcional)
-    }
-  ],
-  "blockingIssues": [               // SIEMPRE array de objetos con issues BLOCKER y CRITICAL
-    {
-      "description": "texto descriptivo del problema",
-      "file": "path/to/file.java",
-      "line": 123,
-      "method": "methodName",
-      "severity": "critical"         // solo "blocker" o "critical" aquí
-    }
-  ],
-  "securityHotspots": 0             // cantidad de security hotspots
+  "details":[{
+    "severity":"BLOCKER|CRITICAL|MAJOR|MINOR|INFO",
+    "type":"BUG|VULNERABILITY|CODE_SMELL",
+    "file":"path",
+    "line":int,
+    "method":"name",
+    "message":"desc",
+    "rule":"optional"
+  }],
+  "blockingIssues":[{
+    "description":"text",
+    "file":"path",
+    "line":int,
+    "method":"name",
+    "severity":"blocker|critical"
+  }],
+  "securityHotspots":int
 }
 ```
 
-✅ Importante:
-- blockingIssues SIEMPRE debe ser un array de objetos, NUNCA un array de strings
-- blockingIssues debe contener TODOS los issues BLOCKER y CRITICAL del array details
-- Cada blockingIssue DEBE incluir: description, file, line, method, severity
-- El QUALITY_GATE debe ser FAILED si hay issues BLOCKER o CRITICAL
-- Los ratings (A-E) deben reflejar la calidad real del código
-- Para cada issue en details, SIEMPRE incluye file, line y method para localización precisa
-- No uses texto fuera del JSON
-- Sé preciso con las localizaciones para facilitar la resolución automatizada
+RULES:
+- blockingIssues=ALWAYS_ARRAY_OF_OBJECTS(never_strings)
+- blockingIssues=ALL(details.severity∈{BLOCKER,CRITICAL})
+- Each_blockingIssue_MUST_have:description,file,line,method,severity
+- QUALITY_GATE=FAILED if(blocker>0||critical>0)
+- details:ALWAYS_include:file,line,method
+- ratings:A(0issues),B(1-2minor),C(1major|3-5minor),D(2+major|1critical),E(1+blocker|2+critical)
+- IMPORTANT: @Autowired usage in Spring is NOT a BLOCKER/CRITICAL issue (max severity: MAJOR)
+- Spring dependency injection patterns (@Autowired) should NOT block commits
 
-A continuación se detallan las pautas y los cambios:
+ANALYZE_BELOW:

package/templates/CLAUDE_PRE_COMMIT_SONAR.md

@@ -1,96 +1,41 @@
-# Pautas de Evaluación de Código - Formato SonarQube
-
-## Objetivo
-Evaluar el código modificado siguiendo métricas similares a SonarQube para asegurar calidad, confiabilidad y mantenibilidad.
-
-## Métricas de Evaluación
-
-### Reliability (Confiabilidad)
-- Bugs potenciales
-- Código que podría fallar en runtime
-- Manejo inadecuado de excepciones
-- Condiciones de carrera
-
-### Security (Seguridad)
-- Vulnerabilidades de seguridad
-- Credenciales expuestas
-- Validación de inputs
-- Inyección de código
-
-### Maintainability (Mantenibilidad)
-- Code smells
-- Complejidad ciclomática
-- 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
-- **BLOCKER**: Debe corregirse inmediatamente
-- **CRITICAL**: Debe corregirse antes del release
-- **MAJOR**: Debe corregirse pronto
-- **MINOR**: Debería corregirse eventualmente
-- **INFO**: Sugerencia o mejora opcional
-
-## Formato de Respuesta Esperado
-
-Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
-
-```json
-{
-  "QUALITY_GATE": "PASSED/FAILED",
-  "metrics": {
-    "reliability": "A/B/C/D/E",
-    "security": "A/B/C/D/E",
-    "maintainability": "A/B/C/D/E",
-    "coverage": 75,
-    "duplications": 5,
-    "complexity": 15
-  },
-  "issues": {
-    "blocker": 0,
-    "critical": 0,
-    "major": 0,
-    "minor": 0,
-    "info": 0
-  },
-  "details": [
-    {
-      "severity": "CRITICAL",
-      "type": "BUG/VULNERABILITY/CODE_SMELL",
-      "message": "Descripción del problema",
-      "file": "archivo.java",
-      "line": 42
-    }
-  ],
-  "securityHotspots": 0,
-  "approved": true/false,
-  "blockingIssues": ["Lista de problemas bloqueantes si existen"]
-}
-```
-
-## Reglas para Quality Gate
-
-- **PASSED** si:
-  - No hay issues BLOCKER
-  - Issues CRITICAL <= 1
-  - Todas las métricas son A o B
-
-- **FAILED** si:
-  - Hay al menos 1 issue BLOCKER
-  - Issues CRITICAL > 1
-  - Alguna métrica es D o E
-  - Security hotspots > 0
-
-## Rating de Métricas
-
-- **A**: Excelente (0 issues)
-- **B**: Bueno (1-2 issues minor)
-- **C**: Aceptable (1 issue major o 3-5 minor)
-- **D**: Pobre (2+ major o 1 critical)
-- **E**: Muy pobre (1+ blocker o 2+ critical)
+# SONARQUBE_EVAL_CRITERIA
+
+## EXCEPTIONS_AND_ALLOWED_PATTERNS
+### Spring Framework Patterns (NOT blocking issues)
+- @Autowired for dependency injection is ALLOWED and NOT a blocking issue
+- Field injection with @Autowired is acceptable in Spring Boot projects
+- Constructor injection is preferred but @Autowired is NOT a blocker
+
+## METRICS
+### Reliability
+- bugs,runtime_failures,exception_handling,race_conditions
+
+### Security
+- vulns,exposed_creds,input_validation,injection
+
+### Maintainability
+- code_smells,cyclomatic_complexity,duplication,tech_debt
+- NOTE: @Autowired usage is NOT considered a code smell for blocking purposes
+
+### Additional
+- coverage:estimated_test_coverage(0-100)
+- duplications:estimated_duplication(0-100)
+- complexity:avg_cyclomatic_complexity
+
+## SEVERITIES
+- BLOCKER:fix_immediately
+- CRITICAL:fix_before_release
+- MAJOR:fix_soon
+- MINOR:fix_eventually
+- INFO:optional_improvement
+
+## QUALITY_GATE
+PASSED:no_blockers AND critical<=1 AND all_metrics∈{A,B}
+FAILED:blocker>=1 OR critical>1 OR any_metric∈{D,E} OR security_hotspots>0
+
+## RATINGS
+A:0_issues
+B:1-2_minor
+C:1_major|3-5_minor
+D:2+_major|1_critical
+E:1+_blocker|2+_critical

package/templates/CLAUDE_RESOLUTION_PROMPT.md

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

package/templates/pre-commit

@@ -109,7 +109,7 @@ generate_resolution_prompt() {
     sed -i "s|{{BRANCH_NAME}}|${BRANCH_NAME}|g" "$RESOLUTION_FILE"
     sed -i "s|{{COMMIT_SHA}}|${COMMIT_SHA}|g" "$RESOLUTION_FILE"
     sed -i "s|{{FILE_COUNT}}|${FILE_COUNT}|g" "$RESOLUTION_FILE"
-    sed -i "s|{{ANALYSIS_MODE}}|${ANALYSIS_MODE:-standard}|g" "$RESOLUTION_FILE"
+    sed -i "s|{{ANALYSIS_MODE}}|sonar|g" "$RESOLUTION_FILE"
     
     # Crear archivo temporal para issues formateados
     local TEMP_ISSUES_FILE=$(mktemp)
@@ -149,65 +149,17 @@ generate_resolution_prompt() {
     echo
 }
 
-# Detectar qué archivo de pautas usar
-# Prioridad: variable de entorno > archivo > pregunta interactiva
-if [ -n "$CLAUDE_ANALYSIS_MODE" ]; then
-    ANALYSIS_MODE="$CLAUDE_ANALYSIS_MODE"
-elif [ -f ".claude-analysis-mode" ]; then
-    ANALYSIS_MODE=$(cat .claude-analysis-mode)
-else
-    ANALYSIS_MODE=""
-fi
+# Usar siempre modo SonarQube
+ANALYSIS_MODE="sonar"
 
-# Verificar si el usuario quiere cambiar el modo (con --change-mode)
-if [ "$1" = "--change-mode" ]; then
-    ANALYSIS_MODE=""
-fi
+# Configurar archivos para modo SonarQube
+GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
+PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
+log "Usando modo de análisis: SonarQube"
 
-# Si no hay modo guardado o es inválido, preguntar
-if [ "$ANALYSIS_MODE" != "standard" ] && [ "$ANALYSIS_MODE" != "sonar" ]; then
-    echo
-    echo "🔍 Selecciona el formato de análisis de código:"
-    echo "1) Estándar - Formato clásico con recomendaciones"
-    echo "2) SonarQube - Formato similar a SonarQube con métricas"
-    echo
-    
-    # Intentar leer desde terminal
-    if [ -t 0 ] && [ -c /dev/tty ]; then
-        read -p "Opción (1 o 2): " -n 1 -r </dev/tty
-        echo
-    else
-        # Si no hay terminal interactiva, usar modo estándar por defecto
-        echo "No se puede leer input interactivo, usando modo estándar por defecto"
-        REPLY="1"
-    fi
-    
-    if [ "$REPLY" = "2" ]; then
-        ANALYSIS_MODE="sonar"
-        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
-        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
-    else
-        ANALYSIS_MODE="standard"
-        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
-        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT.md"
-    fi
-    
-    # Guardar preferencia para futuros commits
-    echo "$ANALYSIS_MODE" > .claude-analysis-mode
-    echo -e "${GREEN}✓ Modo $ANALYSIS_MODE guardado para futuros commits${NC}"
-    echo -e "${YELLOW}Tip: Para cambiar el modo, ejecuta: .git/hooks/pre-commit --change-mode${NC}"
-    echo
-else
-    # Usar modo guardado
-    if [ "$ANALYSIS_MODE" = "sonar" ]; then
-        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
-        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
-        log "Usando modo de análisis: SonarQube"
-    else
-        GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT.md"
-        PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT.md"
-        log "Usando modo de análisis: Estándar"
-    fi
+# Guardar preferencia si no existe
+if [ ! -f ".claude-analysis-mode" ]; then
+    echo "sonar" > .claude-analysis-mode
 fi
 
 # Verificar que el template de prompt existe
@@ -254,6 +206,46 @@ fi
 
 log "Archivos Java/config a revisar: $(echo "$JAVA_FILES" | wc -l)"
 
+# Función para filtrar contenido con SKIP-ANALYSIS
+filter_skip_analysis() {
+    local file_content="$1"
+    local filtered_content=""
+    local skip_next_line=false
+    local inside_skip_block=false
+    
+    while IFS= read -r line; do
+        # Detectar inicio de bloque SKIP-ANALYSIS
+        if echo "$line" | grep -q "// SKIP-ANALYSIS"; then
+            if [ "$inside_skip_block" = true ]; then
+                # Fin del bloque
+                inside_skip_block=false
+            else
+                # Inicio del bloque o línea única
+                inside_skip_block=true
+                skip_next_line=true
+            fi
+            continue
+        fi
+        
+        # Si estamos dentro de un bloque, saltar la línea
+        if [ "$inside_skip_block" = true ]; then
+            continue
+        fi
+        
+        # Si debemos saltar la siguiente línea (comentario único)
+        if [ "$skip_next_line" = true ]; then
+            skip_next_line=false
+            inside_skip_block=false
+            continue
+        fi
+        
+        # Agregar línea al contenido filtrado
+        filtered_content="${filtered_content}${line}"$'\n'
+    done <<< "$file_content"
+    
+    echo "$filtered_content"
+}
+
 # Construir el prompt para análisis de código
 PROMPT_FILE="$TEMP_DIR/code_review_prompt.txt"
 
@@ -278,14 +270,20 @@ for FILE in $JAVA_FILES; do
         
         echo -e "\n--- Archivo: $FILE ---" >> "$PROMPT_FILE"
         
-        # Mostrar el diff del archivo
+        # Obtener el diff y filtrarlo
+        DIFF_CONTENT=$(git diff --cached "$FILE" 2>/dev/null || echo "No se pudo obtener diff")
+        FILTERED_DIFF=$(filter_skip_analysis "$DIFF_CONTENT")
+        
+        # Mostrar el diff filtrado del archivo
         echo -e "\nDiff:" >> "$PROMPT_FILE"
-        git diff --cached "$FILE" >> "$PROMPT_FILE" 2>/dev/null || echo "No se pudo obtener diff"
+        echo "$FILTERED_DIFF" >> "$PROMPT_FILE"
         
-        # Si es un archivo nuevo, mostrar contenido completo
+        # Si es un archivo nuevo, mostrar contenido completo filtrado
         if git diff --cached --name-status | grep "^A.*$FILE" > /dev/null; then
             echo -e "\nContenido completo (archivo nuevo):" >> "$PROMPT_FILE"
-            git show ":$FILE" >> "$PROMPT_FILE" 2>/dev/null || cat "$FILE" >> "$PROMPT_FILE"
+            FILE_CONTENT=$(git show ":$FILE" 2>/dev/null || cat "$FILE")
+            FILTERED_CONTENT=$(filter_skip_analysis "$FILE_CONTENT")
+            echo "$FILTERED_CONTENT" >> "$PROMPT_FILE"
         fi
         
         FILE_COUNT=$((FILE_COUNT + 1))

package/templates/CLAUDE_ANALYSIS_PROMPT.md

@@ -1,44 +0,0 @@
-Eres un revisor de código senior con experiencia en proyectos Spring Boot empresariales.
-
-Tu tarea es analizar los siguientes cambios de código y responder exclusivamente con un JSON válido, **sin ningún texto fuera del JSON**, sin introducciones ni explicaciones adicionales.
-
-⚠️ La respuesta debe ser un objeto JSON con esta estructura exacta:
-
-```json
-{
-  "approved": true,                // true si el commit puede aceptarse, false si debe bloquearse
-  "score": 1-10,                   // calificación de calidad (entero)
-  "blockingIssues": [             // SIEMPRE array de objetos, nunca strings
-    {
-      "description": "texto descriptivo del problema",
-      "file": "path/to/file.java",
-      "line": 123,                // línea donde se detectó el problema
-      "method": "methodName",      // método o clase afectada
-      "severity": "critical"       // critical, high, medium, low
-    }
-  ],
-  "recommendations": [            // sugerencias no bloqueantes (array de strings)
-    "mejora 1",
-    "mejora 2"
-  ],
-  "details": {
-    "security": [                 // comentarios específicos por área
-      "observación sobre seguridad"
-    ],
-    "architecture": [ "..." ],
-    "performance": [ "..." ],
-    "maintainability": [ "..." ]
-  }
-}
-```
-
-✅ Importante:
-- blockingIssues SIEMPRE debe ser un array de objetos, NUNCA un array de strings
-- Cada blockingIssue DEBE incluir: description, file, line, method, severity
-- Usa listas vacías si no hay issues (ejemplo: `"blockingIssues": []`)
-- No uses texto introductorio o explicaciones fuera del JSON
-- No omitas claves aunque estén vacías
-- Sé directo, claro y profesional en tus observaciones
-- Los problemas críticos deben incluir contexto suficiente para que otra IA pueda resolverlos
-
-A continuación se detallan las pautas y los cambios:

package/templates/CLAUDE_PRE_COMMIT.md

@@ -1,63 +0,0 @@
-# Pautas de Evaluación de Código - Claude Pre-commit Hook
-
-## Objetivo
-Evaluar el código modificado antes del commit para asegurar calidad, mantenibilidad y adherencia a buenas prácticas.
-
-## Criterios de Evaluación
-
-### 1. Calidad del Código (40%)
-- **Claridad y legibilidad**: El código es fácil de entender
-- **Nombres descriptivos**: Variables, métodos y clases tienen nombres significativos
-- **Estructura lógica**: El código está bien organizado
-- **Principio DRY**: No hay duplicación innecesaria
-- **Complejidad**: Funciones y métodos no son excesivamente complejos
-
-### 2. Buenas Prácticas (30%)
-- **SOLID principles**: Adherencia cuando aplique
-- **Patrones de diseño**: Uso apropiado cuando sea necesario
-- **Manejo de errores**: Excepciones manejadas correctamente
-- **Validación de inputs**: Datos de entrada validados
-- **Separación de concerns**: Responsabilidades bien definidas
-
-### 3. Seguridad (20%)
-- **No hay credenciales hardcodeadas**
-- **Validación de datos de usuario**
-- **No hay vulnerabilidades obvias** (SQL injection, XSS, etc.)
-- **Manejo seguro de datos sensibles**
-
-### 4. Performance (10%)
-- **No hay operaciones obviamente ineficientes**
-- **Uso apropiado de estructuras de datos**
-- **Queries optimizadas** (cuando aplique)
-
-## Formato de Respuesta Esperado
-
-Responde ÚNICAMENTE con un JSON válido siguiendo esta estructura:
-
-```json
-{
-  "approved": true/false,
-  "score": 8,
-  "recommendations": [
-    "Sugerencia 1",
-    "Sugerencia 2"
-  ],
-  "blockingIssues": [
-    "Problema crítico 1 (si existe)"
-  ],
-  "details": "Información adicional detallada (opcional)"
-}
-```
-
-## Reglas de Aprobación
-
-- **approved = true** si score >= 7 Y no hay blockingIssues
-- **approved = false** si score < 7 O hay blockingIssues
-
-## Problemas que SIEMPRE son Blocking Issues
-
-1. Credenciales o tokens hardcodeados
-2. Vulnerabilidades de seguridad evidentes
-3. Código que podría causar pérdida de datos
-4. Errores de sintaxis o código que no compilaría
-5. Eliminación de tests sin justificación