claude-git-hooks 1.4.1 → 1.4.2

package/CHANGELOG.md

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

@@ -208,26 +208,50 @@ Cuando se detectan problemas críticos:
 
 **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.
 
+### Excluir 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
+// SKIP-ANALYSIS
+@Autowired private LegacyService legacyService;  // Esta línea no será analizada
+
+// 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
+```
+
+**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:
@@ -278,13 +302,6 @@ unset CLAUDE_ANALYSIS_MODE
 claude-hooks set-mode
 ```
 
-### Saltar la revisión (usar con precaución)
-
-```bash
-# Desde WSL
-git commit --no-verify -m "fix: corrección urgente"
-```
-
 ### Modo debug
 
 ```bash

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');
 }
 
@@ -870,31 +874,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');
   }
 }
 
@@ -1012,6 +1011,18 @@ Ejemplos:
   claude-hooks enable               # Habilita todos los hooks
   claude-hooks status               # Ver estado actual
 
+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
+
+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
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-git-hooks",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "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