claude-git-hooks 1.4.2 → 1.5.1

package/CHANGELOG.md

@@ -5,12 +5,47 @@ 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.1] - 2025-09-11
+
+### Added
+- 📋 Sección CHEATSHEET en README
+
+### Fixed
+- 🔧 SKIP_ANALYSIS_BLOCK funciona correctamente
+- 📝 Estructura del proyecto en documentación
+
+## [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
+  - Bloque: código entre dos comentarios `// SKIP_ANALYSIS_BLOCK` 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

package/README.md

@@ -1,22 +1,129 @@
 # Pre-commit Hook con Claude CLI
 
 Este directorio contiene un pre-commit hook que utiliza Claude CLI para revisar automáticamente el código antes de cada commit.
+Otras funciones de interés:
 
-## 📁 Archivos en este Directorio
+- Generación de mensaje de commit.
+- Generación de información de PR y tests de validación de PR - Utiliza análisis de diferencias entre contenido local y origin.
 
-- **`README.md`** - Esta documentación
-- **`pre-commit`** - Hook principal para análisis de código (con auto-actualización)
-- **`prepare-commit-msg`** - Hook para generar mensajes de commit automáticos
-- **`.gitattributes`** - Configuración para mantener line endings correctos
-- **`.claude/CLAUDE_PRE_COMMIT.md`** - Pautas de evaluación formato estándar
-- **`.claude/CLAUDE_PRE_COMMIT_SONAR.md`** - Pautas de evaluación formato SonarQube
-- **`.claude/CLAUDE_ANALYSIS_PROMPT.md`** - Template de prompt para análisis estándar
-- **`.claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md`** - Template de prompt para análisis SonarQube
-- **`.claude/CLAUDE_RESOLUTION_PROMPT.md`** - Template para generar prompt de resolución AI
+## 📋 CHEATSHEET
+
+### 🚀 Comandos Frecuentes
+
+```bash
+# Commit rápido sin análisis + mensaje automático
+git commit --no-verify -m "auto"
+
+# Analizar diferencias con rama origin actual
+claude-hooks analyze-diff
+
+# Analizar diferencias para PR (comparar con develop)
+claude-hooks analyze-diff develop
+
+# Reinstalar durante desarrollo (después de npm link)
+claude-hooks install --force --skip-auth
+```
+
+### 📦 Instalación y Gestión
+
+```bash
+# Instalación inicial
+claude-hooks install
+
+# Actualizar a última versión
+claude-hooks update
+
+# Desinstalar hooks
+claude-hooks uninstall
+
+# Ver estado actual
+claude-hooks status
+
+# Desactivar temporalmente
+claude-hooks disable
+
+# Reactivar hooks
+claude-hooks enable
+```
+
+### 💻 Flujos de Commit
+
+```bash
+# Commit con análisis de código
+git commit -m "feat: nueva funcionalidad"
+
+# Generar mensaje de commit automático
+git commit -m "auto"
+
+# Saltar análisis (emergencias)
+git commit --no-verify -m "hotfix: corrección urgente"
+
+# Modificar último commit
+git commit --amend
+```
+
+### 🚫 Exclusión de Código del Análisis
+
+```java
+// SKIP-ANALYSIS
+private String legacyCode = "no analizar siguiente línea";
+
+// SKIP_ANALYSIS_BLOCK
+public void methodToIgnore() {
+    // Todo este bloque será ignorado
+    String oldCode = "legacy";
+}
+// SKIP_ANALYSIS_BLOCK
+```
+
+### 🔧 Configuración Avanzada
+
+```bash
+# Archivos de configuración
+.claude/
+├── CLAUDE_PRE_COMMIT_SONAR.md      # Personalizar criterios
+├── CLAUDE_ANALYSIS_PROMPT_SONAR.md # Modificar prompt
+└── settings.local.json              # Configuración local
+
+# Variables de entorno
+export CLAUDE_ANALYSIS_MODE=sonarqube  # Modo de análisis
+export CLAUDE_DEBUG=true               # Debug detallado
+```
+
+### 🎯 Casos de Uso Específicos
+
+```bash
+# Desarrollo local de claude-hooks
+cd /path/to/claude-git-hooks
+npm link
+cd /path/to/your-project
+claude-hooks install --force --skip-auth
+
+# Preparar PR hacia develop
+git checkout -b feature/nueva-funcionalidad
+# ... hacer cambios ...
+git add .
+git commit -m "feat: implementar nueva funcionalidad"
+claude-hooks analyze-diff develop  # Genera título, descripción y tests
+
+# Resolver issues bloqueantes
+git commit -m "fix: resolver issues"
+# Si falla, ver claude_resolution_prompt.md generado
+# Copiar contenido y pegar en Claude para obtener solución
+```
+
+### ⚡ Tips y Trucos
+
+1. **Mensaje automático**: Usa `"auto"` como mensaje para que Claude lo genere
+2. **Skip auth**: Usa `--skip-auth` en CI/CD o desarrollo local
+3. **Force install**: Usa `--force` para reinstalar sin confirmación
+4. **Debug**: Activa `CLAUDE_DEBUG=true` para ver detalles completos
+5. **Archivos grandes**: Se omiten automáticamente archivos > 100KB
+6. **Límite de archivos**: Máximo 10 archivos por commit
 
 ## 🔧 Configuración Previa Importante
 
-### 1. Armonización de Line Endings (EOL)
+### 1. Armonización de Line Endings (EOL) -- Automatizada
 
 Debido a que Claude CLI corre en WSL y el desarrollo puede hacerse en Windows, es crucial configurar correctamente los line endings para evitar que los archivos de hooks se corrompan:
 
@@ -53,8 +160,6 @@ git config --global credential.helper store
 
 ## 🚀 Instalación
 
-### Paquete NPM Global (Recomendado)
-
 **IMPORTANTE**: Claude CLI corre en WSL, por lo que toda la instalación y uso de git debe hacerse desde la terminal WSL.
 
 ```bash
@@ -80,35 +185,6 @@ El comando `claude-hooks install` ahora incluye:
 - `--force`: Reinstala aunque los hooks ya existan
 - `--skip-auth`: Omite la verificación de autenticación de Claude (útil para CI/CD)
 
-#### Añadir como Dependencia de Desarrollo
-
-```bash
-# Instalar como devDependency
-npm install --save-dev claude-git-hooks
-```
-
-Luego añade esto a tu `package.json`:
-
-```json
-{
-  "scripts": {
-    "postinstall": "claude-hooks install"
-  },
-  "devDependencies": {
-    "claude-git-hooks": "^1.2.0"
-  }
-}
-```
-
-## 🤖 Características
-
-**✨ Auto-actualización**: Verifica automáticamente si hay nuevas versiones disponibles antes de cada commit y ofrece actualizar con un simple prompt interactivo.
-
-**Hooks disponibles**:
-
-- `pre-commit`: Análisis de código con Claude (solo archivos Java/config) con verificación automática de versión
-- `prepare-commit-msg`: Generación automática de mensajes de commit
-
 ## 📁 Gestión de Archivos
 
 ### Archivos creados durante la instalación
@@ -119,12 +195,9 @@ El comando `claude-hooks install` crea los siguientes archivos y directorios:
 2. **`.git/hooks/prepare-commit-msg`** - Hook de generación de mensajes
 3. **`.git/hooks/check-version.sh`** - Script de verificación de versión
 4. **`.claude/`** - Directorio para archivos de configuración
-   - `CLAUDE_PRE_COMMIT.md` - Pautas de evaluación estándar
    - `CLAUDE_PRE_COMMIT_SONAR.md` - Pautas de evaluación SonarQube
-   - `CLAUDE_ANALYSIS_PROMPT.md` - Template de prompt para análisis estándar
    - `CLAUDE_ANALYSIS_PROMPT_SONAR.md` - Template de prompt para análisis SonarQube
    - `CLAUDE_RESOLUTION_PROMPT.md` - Template para prompt de resolución AI
-5. **`.claude-analysis-mode`** - Archivo de preferencia de modo (creado al primer uso)
 
 ### Actualización automática de .gitignore
 
@@ -133,9 +206,9 @@ Durante la instalación, Claude Hooks actualiza automáticamente tu `.gitignore`
 ```gitignore
 # Claude Git Hooks
 .claude/
-.claude-analysis-mode
 debug-claude-response.json
 claude_resolution_prompt.md
+.claude-pr-analysis.json
 ```
 
 Esto asegura que:
@@ -155,26 +228,19 @@ Si no existe un `.gitignore`, se creará uno nuevo. Si ya existe, las entradas s
    - Solo analiza: Java, XML, properties, yml, yaml
    - Omite archivos mayores a 100KB
    - Límite de 10 archivos por commit
-3. **Modos de análisis disponibles**:
-   - **Estándar**: Formato clásico con score y recomendaciones detalladas
-   - **SonarQube**: Simula salida de SonarQube con Quality Gate, métricas y clasificación de issues
-4. **Construye prompt inteligente**:
+3. **Construye prompt inteligente**:
    - Usa template de prompt desde `.claude/CLAUDE_ANALYSIS_PROMPT*.md`
    - Lee las pautas desde `.claude/CLAUDE_PRE_COMMIT*.md`
    - Incluye el diff completo para archivos nuevos
    - Muestra solo cambios para archivos existentes
-5. **Envía a Claude CLI para revisión**
-6. **Procesa respuesta JSON estructurada**:
+4. **Envía a Claude CLI para revisión**
+5. **Procesa respuesta JSON estructurada**:
    - blockingIssues siempre como objetos con localización precisa
-   - En modo estándar: evalúa `approved`, `score`, `recommendations`
-   - En modo SonarQube: verifica `QUALITY_GATE`, muestra métricas y issues por severidad
-7. **Decisión final**:
+   - verifica `QUALITY_GATE`, muestra métricas y issues por severidad
+6. **Decisión final**:
    - Si hay problemas críticos → genera prompt AI de resolución y bloquea commit
    - Si todo está bien → commit procede
-
-#### 🤖 Generación de Prompt de Resolución AI
-
-Cuando se detectan problemas críticos:
+7. **Generación de Prompt de Resolución AI** (opcional): Cuando se detectan problemas críticos:
 
 - Se genera automáticamente un archivo `claude_resolution_prompt.md`
 - Contiene información estructurada y AI-friendly de todos los issues
@@ -198,42 +264,20 @@ Cuando se detectan problemas críticos:
 
 ### Características adicionales
 
+- **Generación de información para Pull Requests**: `claude-hooks analyze-diffs {branch}` para comparar rama local con otra rama, propone nombre para rama actual, título y detalles para pull request, da tips para verificar trabajo. 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
+  - 📝 Archivo `.claude-pr-analysis.json`
 - **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.
-
-### Casos de uso de commits
-
-```bash
-# Desde WSL
-git add .
-
-# 1. Mensaje manual + análisis bloqueante
-git commit -m "feat: nueva funcionalidad"
-
-# 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.
-
-### Excluir código del análisis con SKIP-ANALYSIS
-
-Puedes excluir código específico del análisis usando comentarios `// SKIP-ANALYSIS`:
+- **Exclusión de código del análisis con SKIP-ANALYSIS**: Puedes excluir código específico del análisis usando comentarios `// SKIP-ANALYSIS`:
 
 ```java
 // Excluir una sola línea
@@ -241,180 +285,15 @@ Puedes excluir código específico del análisis usando comentarios `// SKIP-ANA
 @Autowired private LegacyService legacyService;  // Esta línea no será analizada
 
 // Excluir un bloque de código
-// SKIP-ANALYSIS
+// SKIP-ANALYSIS_BLOCK
 @Deprecated
 public void methodWithKnownIssues() {
     // Código legacy que no queremos que sea analizado
     System.out.println("Debug temporal");
 }
-// SKIP-ANALYSIS
+// SKIP-ANALYSIS_BLOCK
 ```
 
-**Nota**: El código entre comentarios `SKIP-ANALYSIS` no será enviado a Claude para su análisis.
-
-### Modos de análisis 📊
-
-Puedes elegir entre dos formatos de análisis:
-
-#### 🎯 Configurar Modo (Recomendado)
-
-```bash
-# Cambiar a modo SonarQube (métricas y quality gate)
-claude-hooks set-mode sonar
-
-# Cambiar a modo estándar (score y recomendaciones)
-claude-hooks set-mode standard
-
-# Ver modo actual
-claude-hooks status
-```
-
-#### 🔧 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
-```
-
-#### 📋 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**:
-
-- Quality Gate (PASSED/FAILED)
-- Métricas: Reliability, Security, Maintainability
-- Issues clasificados por severidad (Blocker, Critical, Major, Minor, Info)
-- Security hotspots
-
-#### 🔄 Cambio de Modo Interactivo
-
-```bash
-# Sin parámetros muestra ayuda interactiva
-claude-hooks set-mode
-```
-
-### Modo debug
-
-```bash
-# Desde WSL
-DEBUG=1 git commit -m "mensaje"
-```
-
-## 📊 Formato de Respuesta
-
-Claude responde con un JSON estructurado que incluye:
-
-- `approved`: Si el commit es aprobado (boolean)
-- `score`: Puntuación del 1-10 (integer)
-- `blockingIssues`: Array de objetos con problemas críticos:
-  - `description`: Descripción del problema
-  - `file`: Archivo afectado
-  - `line`: Línea del problema
-  - `method`: Método o clase afectada
-  - `severity`: Severidad (critical, high, etc.)
-- `recommendations`: Array de strings con sugerencias no bloqueantes
-- `details`: Objeto con comentarios por categoría (security, performance, etc.)
-
-### Ejemplos de Respuestas con Problemas Críticos
-
-#### Modo Estándar - Commit Bloqueado
-
-```json
-{
-  "approved": false,
-  "score": 3,
-  "blockingIssues": [
-    {
-      "description": "SQL Injection vulnerability: concatenación directa de strings en query",
-      "file": "src/main/java/UserRepository.java",
-      "line": 45,
-      "method": "findUserByName",
-      "severity": "critical"
-    },
-    {
-      "description": "Posible NullPointerException: variable 'user' no validada",
-      "file": "src/main/java/UserService.java",
-      "line": 78,
-      "method": "processUser",
-      "severity": "high"
-    }
-  ],
-  "recommendations": [
-    "Usar PreparedStatement en lugar de concatenación de strings",
-    "Agregar validación de null antes de acceder a propiedades"
-  ]
-}
-```
-
-#### Modo SonarQube - Quality Gate Failed
-
-```json
-{
-  "QUALITY_GATE": "FAILED",
-  "approved": false,
-  "score": 4,
-  "metrics": {
-    "reliability": "D",
-    "security": "E",
-    "maintainability": "C"
-  },
-  "issues": {
-    "blocker": 1,
-    "critical": 2,
-    "major": 3,
-    "minor": 1
-  },
-  "blockingIssues": [
-    {
-      "description": "Security Hotspot: Hardcoded credentials detected",
-      "file": "src/main/resources/application.yml",
-      "line": 23,
-      "method": "datasource.password",
-      "severity": "blocker"
-    },
-    {
-      "description": "Resource leak: Connection not closed in finally block",
-      "file": "src/main/java/DatabaseUtil.java",
-      "line": 112,
-      "method": "executeQuery",
-      "severity": "critical"
-    }
-  ],
-  "details": [
-    {
-      "severity": "BLOCKER",
-      "type": "VULNERABILITY",
-      "file": "src/main/resources/application.yml",
-      "line": 23,
-      "message": "Never store passwords in plain text",
-      "rule": "java:S2068"
-    }
-  ]
-}
-```
-
-Cuando se detectan estos problemas críticos, se genera automáticamente un archivo `claude_resolution_prompt.md` con toda la información necesaria para que otra instancia de Claude pueda resolver los issues de forma eficiente.
-
-## 🔄 Actualización y Gestión
-
-### Actualizar a la última versión
-
-```bash
-# Actualizar manualmente a la última versión
-claude-hooks update
-```
-
-El comando `update` descarga e instala automáticamente la última versión disponible desde NPM, y luego reinstala los hooks con las nuevas características.
-
 ### Desactivar/Activar hooks
 
 ```bash
@@ -438,103 +317,26 @@ claude-hooks status
 
 ## ⚙️ Configuración
 
-### 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"`
-  - Guarda las respuestas de Claude en `debug-claude-response.json`
-
-### Variables modificables en los archivos de hooks
+### Scripts
 
 En el archivo `pre-commit`:
 
 - **`MAX_FILE_SIZE`**: Tamaño máximo de archivo a analizar (default: 100KB)
 - **`MAX_FILES`**: Número máximo de archivos por commit (default: 10)
 - **`CLAUDE_CLI`**: Comando de Claude CLI (default: "claude")
-- **`GUIDELINES_FILE`**: Archivo de pautas para modo estándar (default: ".claude/CLAUDE_PRE_COMMIT.md")
-- **`GUIDELINES_FILE_SONAR`**: Archivo de pautas para modo SonarQube (default: ".claude/CLAUDE_PRE_COMMIT_SONAR.md")
+- **`GUIDELINES_FILE`**: Archivo de pautas (default: ".claude/CLAUDE_PRE_COMMIT_SONAR.md")
 
 En el archivo `prepare-commit-msg`:
 
 - **`MAX_FILE_SIZE`**: Tamaño máximo para incluir diff completo (default: 100KB)
 - **`CLAUDE_CLI`**: Comando de Claude CLI (default: "claude")
 
-## 🐛 Troubleshooting
-
-### "Claude CLI no está instalado"
-
-```bash
-# Desde WSL
-npm install -g @anthropic-ai/claude-cli
-claude auth login
-```
-
-### "No se recibió respuesta JSON válida"
-
-- Verifica que Claude CLI esté autenticado en WSL
-- Ejecuta en modo DEBUG para ver la respuesta completa
-- Revisa que el archivo de pautas esté bien formateado
-
-### El hook no se ejecuta
-
-- Verifica que estés ejecutando git desde WSL
-- Verifica permisos: `ls -la .git/hooks/pre-commit`
-- Debe mostrar permisos de ejecución (-rwxr-xr-x)
+### Pautas de Evaluación
 
-### Problemas con line endings
-
-- Si ves errores de "^M" o caracteres extraños:
-  ```bash
-  # En WSL
-  git config core.autocrlf input
-  ```
-
-### Los hooks se vacían o corrompen
-
-Este problema suele ocurrir por conflictos de configuración de line endings:
-
-1. **Verifica configuraciones**:
-
-   ```bash
-   git config --local core.autocrlf  # Debe ser 'input'
-   git config --global core.autocrlf # Debe ser 'input'
-   ```
-
-2. **Si están diferentes, corrige**:
-
-   ```bash
-   git config --local core.autocrlf input
-   ```
-
-3. **Restaura los hooks**:
-   ```bash
-   ./git-hooks/setup-wsl.sh --sync
-   ```
-
-### Credenciales no funcionan en WSL
-
-- Las credenciales de Windows no se comparten automáticamente con WSL
-- Reconfigura tus credenciales git en WSL
-
-## 📝 Personalización
-
-### Archivos de Configuración en `.claude/`
-
-#### Pautas de Evaluación
-
-- **`CLAUDE_PRE_COMMIT.md`** - Criterios de evaluación para modo estándar
 - **`CLAUDE_PRE_COMMIT_SONAR.md`** - Criterios para modo SonarQube
 
-#### Templates de Prompts
+### Templates de Prompts
 
-- **`CLAUDE_ANALYSIS_PROMPT.md`** - Estructura del prompt de análisis estándar
 - **`CLAUDE_ANALYSIS_PROMPT_SONAR.md`** - Estructura del prompt SonarQube
 - **`CLAUDE_RESOLUTION_PROMPT.md`** - Template para generar prompts de resolución
 
@@ -544,33 +346,9 @@ Todos estos archivos son personalizables y específicos de tu proyecto. Puedes:
 - Ajustar la estructura de los prompts para obtener respuestas más precisas
 - Personalizar el formato de salida del prompt de resolución
 
-## 🔄 Arquitectura del Sistema
-
-```
-WSL Terminal
-     │
-     ├─→ git add/commit
-     │
-     └─→ .git/hooks/pre-commit
-              │
-              ├─→ Lee archivos modificados
-              ├─→ Lee CLAUDE_PRE_COMMIT.md
-              ├─→ Construye prompt
-              │
-              └─→ Claude CLI
-                       │
-                       └─→ Respuesta JSON
-                              │
-                              ├─→ ✅ Approved → Commit procede
-                              └─→ ❌ Rejected → Commit bloqueado
-```
-
-## 📌 Notas Importantes
+## 🐛 Troubleshooting
 
-1. **Todo en WSL**: Claude CLI solo funciona en WSL, por lo que todos los comandos git deben ejecutarse desde ahí
-2. **Line Endings**: La configuración de `core.autocrlf` es crítica para evitar problemas entre Windows y Linux
-3. **Credenciales**: Necesitarás reconfigurar tus credenciales git en WSL
-4. **Performance**: La revisión puede tardar unos segundos dependiendo del tamaño de los cambios
+No hay... esto es la perfección hecha código.
 
 ## 🔧 Desarrollo y Contribución
 
@@ -579,19 +357,25 @@ WSL Terminal
 ```
 claude-git-hooks/
 ├── bin/
-│   └── claude-hooks          # CLI principal con verificación completa
+│   └── claude-hooks                          # CLI principal con verificación completa
 ├── templates/
-│   ├── pre-commit            # Hook de análisis de código
-│   ├── prepare-commit-msg    # Hook de generación de mensajes
-│   ├── CLAUDE_PRE_COMMIT.md  # Pautas estándar
-│   └── CLAUDE_PRE_COMMIT_SONAR.md # Pautas SonarQube
-├── .claude/                  # Directorio creado en el repo del usuario
-│   ├── CLAUDE_PRE_COMMIT.md  # Pautas copiadas aquí durante la instalación
-│   └── CLAUDE_PRE_COMMIT_SONAR.md
-├── package.json              # Configuración NPM
-├── README.md                 # Este archivo
-├── CHANGELOG.md              # Historial de versiones
-└── PUBLISH.md                # Guía de publicación
+│   ├── pre-commit                            # Hook de análisis de código
+│   ├── prepare-commit-msg                    # Hook de generación de mensajes
+│   ├── check-version.sh                      # Script de verificación de versión
+│   ├── CLAUDE_PRE_COMMIT_SONAR.md            # Pautas SonarQube para pre commit
+│   ├── CLAUDE_ANALYSIS_PROMPT_SONAR.md       # Template de prompt para análisis
+│   └── CLAUDE_RESOLUTION_PROMPT.md           # Template para resolución de issues
+├── .claude/                                  # Directorio de configuración local (gitignore)
+│   └── settings.local.json                   # Configuración local del usuario
+├── package.json                              # Configuración NPM
+├── package-lock.json                         # Lock file de NPM
+├── README.md                                 # Este archivo
+├── README-NPM.md                             # Documentación para publicación NPM
+├── CHANGELOG.md                              # Historial de versiones
+├── PUBLISH.md                                # Guía de publicación
+├── CLAUDE_PRE_COMMIT_SONAR.md                # Pautas de evaluación (legacy)
+├── pre-commit                                # Hook principal (legacy)
+└── .gitignore                                # Archivos ignorados por git
 ```
 
 ### Configuración del Entorno de Desarrollo
@@ -624,23 +408,18 @@ Los hooks están en `templates/`:
 #### 2. Probar Localmente
 
 ```bash
-# Después de modificar archivos
+# Después de modificar archivos, repo de claude-hooks
 npm link
 
 # En un repo de prueba
-claude-hooks install --force  # Fuerza reinstalación
-
-# Probar funcionalidad
-git add .
-git commit -m "auto"  # Probar generación automática
-git commit -m "test"  # Probar análisis
+claude-hooks install --force  # Fuerza reinstalación, luego probar lo que se desee
 ```
 
 #### 3. Actualizar Documentación
 
 - `README.md` - Documentación principal
+- `CHANGELOG.md` - Documentación principal
 - `README-NPM.md` - Para usuarios de NPM
-- `templates/CLAUDE_PRE_COMMIT*.md` - Pautas de evaluación
 
 #### 4. Versioning y Publicación
 
@@ -652,68 +431,4 @@ npm version major  # 1.0.0 -> 2.0.0
 
 # Publicar nueva versión
 npm publish
-
-# Tag en git
-git push --tags
 ```
-
-### Debugging
-
-#### Modo Debug
-
-```bash
-# Activar debug en hooks
-DEBUG=1 git commit -m "test"
-
-# Ver logs del CLI
-claude-hooks install --debug
-```
-
-#### Logs Útiles
-
-- `debug-claude-response.json` - Respuestas de Claude en modo debug
-- `~/.npm/_logs/` - Logs de npm install
-- `.git/hooks/` - Verificar que hooks están instalados
-
-### Testing
-
-#### Test Manual
-
-```bash
-# 1. Crear repo de prueba
-mkdir test-repo && cd test-repo
-git init
-
-# 2. Instalar hooks
-claude-hooks install
-
-# 3. Crear archivos de prueba
-echo 'public class Test {}' > Test.java
-git add .
-
-# 4. Probar análisis
-git commit -m "test: nueva clase"
-
-# 5. Probar generación automática
-echo 'public void newMethod() {}' >> Test.java
-git add .
-git commit -m "auto"
-```
-
-#### Casos de Prueba
-
-- ✅ Análisis de código Java
-- ✅ Generación automática de mensajes
-- ✅ Modo SonarQube
-- ✅ Archivos grandes (>100KB)
-- ✅ Commits sin archivos Java
-- ✅ Enable/disable hooks
-- ✅ Modo debug
-
-### Contribuir
-
-1. **Fork** el repositorio
-2. **Crear branch** para tu feature: `git checkout -b feature/nueva-funcionalidad`
-3. **Commit** tus cambios: `git commit -m "feat: nueva funcionalidad"`
-4. **Push** al branch: `git push origin feature/nueva-funcionalidad`
-5. **Abrir Pull Request**

package/bin/claude-hooks

@@ -447,9 +447,9 @@ async function install(args) {
   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('  // SKIP_ANALYSIS_BLOCK  # Excluye bloque hasta encontrar otro igual');
   console.log('  ...código excluido...');
-  console.log('  // SKIP-ANALYSIS');
+  console.log('  // SKIP_ANALYSIS_BLOCK');
   console.log('\nPara más opciones: claude-hooks --help');
 }
 
@@ -638,9 +638,9 @@ function updateGitignore() {
   const claudeEntries = [
     '# Claude Git Hooks',
     '.claude/',
-    '.claude-analysis-mode',
     'debug-claude-response.json',
-    'claude_resolution_prompt.md'
+    'claude_resolution_prompt.md',
+    '.claude-pr-analysis.json',
   ];
   
   let gitignoreContent = '';
@@ -794,6 +794,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()) {
@@ -816,21 +1068,9 @@ function status() {
     }
   });
 
-  // Verificar modo de análisis actual
-  console.log('\nModo de análisis:');
-  const analysisMode = fs.existsSync('.claude-analysis-mode') 
-    ? fs.readFileSync('.claude-analysis-mode', 'utf8').trim()
-    : 'standard (por defecto)';
-  
-  if (analysisMode === 'sonar') {
-    info(`Modo actual: SonarQube`);
-  } else {
-    info(`Modo actual: Estándar`);
-  }
-
   // Verificar archivos de pautas
   console.log('\nArchivos de pautas:');
-  const guidelines = ['CLAUDE_PRE_COMMIT.md', 'CLAUDE_PRE_COMMIT_SONAR.md'];
+  const guidelines = ['CLAUDE_PRE_COMMIT_SONAR.md'];
   guidelines.forEach(guideline => {
     const claudePath = path.join('.claude', guideline);
     if (fs.existsSync(claudePath)) {
@@ -847,7 +1087,7 @@ function status() {
   const gitignorePath = '.gitignore';
   if (fs.existsSync(gitignorePath)) {
     const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
-    const claudeIgnores = ['.claude/', '.claude-analysis-mode', 'debug-claude-response.json'];
+    const claudeIgnores = ['.claude/', 'debug-claude-response.json', '.claude-pr-analysis.json'];
     let allPresent = true;
     
     claudeIgnores.forEach(entry => {
@@ -873,28 +1113,6 @@ function setMode(mode) {
   if (!checkGitRepo()) {
     error('No estás en un repositorio Git.');
   }
-
-  const validModes = ['sonar'];
-  
-  if (!mode) {
-    // Modo interactivo
-    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 'sonar'`);
-  }
-
-  // Guardar el modo
-  fs.writeFileSync('.claude-analysis-mode', mode);
-  
-  if (mode === 'sonar') {
-    success('Modo configurado: SonarQube');
-    info('Los commits usarán formato SonarQube con métricas y quality gate');
-  }
 }
 
 // Función para comparar versiones usando el script compartido
@@ -993,8 +1211,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:
@@ -1005,11 +1223,10 @@ 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
@@ -1017,11 +1234,17 @@ Casos de uso de commits:
   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
+  // SKIP_ANALYSIS_BLOCK           # Excluye bloque hasta encontrar otro igual
   ...código excluido...
-  // SKIP-ANALYSIS
+  // SKIP_ANALYSIS_BLOCK
 
 Más información: https://github.com/pablorovito/claude-git-hooks
 `);
@@ -1048,12 +1271,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.2",
+  "version": "1.5.1",
   "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/pre-commit

@@ -109,7 +109,6 @@ 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}}|sonar|g" "$RESOLUTION_FILE"
     
     # Crear archivo temporal para issues formateados
     local TEMP_ISSUES_FILE=$(mktemp)
@@ -149,18 +148,10 @@ generate_resolution_prompt() {
     echo
 }
 
-# Usar siempre modo SonarQube
-ANALYSIS_MODE="sonar"
-
 # 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"
 
-# Guardar preferencia si no existe
-if [ ! -f ".claude-analysis-mode" ]; then
-    echo "sonar" > .claude-analysis-mode
-fi
 
 # Verificar que el template de prompt existe
 if [ ! -f "$PROMPT_TEMPLATE" ]; then
@@ -214,15 +205,20 @@ filter_skip_analysis() {
     local inside_skip_block=false
     
     while IFS= read -r line; do
-        # Detectar inicio de bloque SKIP-ANALYSIS
+        # Detectar SKIP-ANALYSIS para línea única
         if echo "$line" | grep -q "// SKIP-ANALYSIS"; then
+            skip_next_line=true
+            continue
+        fi
+        
+        # Detectar inicio/fin de bloque SKIP_ANALYSIS_BLOCK
+        if echo "$line" | grep -q "// SKIP_ANALYSIS_BLOCK"; then
             if [ "$inside_skip_block" = true ]; then
                 # Fin del bloque
                 inside_skip_block=false
             else
-                # Inicio del bloque o línea única
+                # Inicio del bloque
                 inside_skip_block=true
-                skip_next_line=true
             fi
             continue
         fi
@@ -235,7 +231,6 @@ filter_skip_analysis() {
         # 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
         
@@ -337,10 +332,9 @@ if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
         BLOCKING_ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].description' 2>/dev/null | sed '/^$/d')
     fi
     
-    # Verificar si estamos en modo SonarQube
     QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.QUALITY_GATE // ""' 2>/dev/null)
     
-    if [ "$ANALYSIS_MODE" = "sonar" ] && [ -n "$QUALITY_GATE" ] && [ "$QUALITY_GATE" != "null" ]; then
+    if [ -n "$QUALITY_GATE" ] && [ "$QUALITY_GATE" != "null" ]; then
         # Mostrar resultados estilo SonarQube
         echo
         echo "╔════════════════════════════════════════════════════════════════════╗"