theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/skills/verificacion-quarkus/SKILL.md

@@ -0,0 +1,485 @@
+---
+name: verificacion-quarkus
+description: "Bucle de verificación para proyectos Quarkus: build, análisis estático, tests con cobertura, escaneos de seguridad, compilación nativa y revisión del diff antes de un release o PR."
+---
+
+# Bucle de verificación para Quarkus
+
+Ejecútalo antes de abrir PRs, después de cambios mayores y antes de desplegar.
+
+## Cuándo usarla
+
+- Antes de abrir un pull request de un servicio Quarkus
+- Después de una refactorización mayor o de actualizar dependencias
+- Verificación previa al despliegue en staging o producción
+- Al ejecutar el pipeline completo build → lint → tests → escaneo de seguridad → compilación nativa
+- Al validar que la cobertura de tests cumple los umbrales (80 %+)
+- Al probar la compatibilidad con imagen nativa
+
+## Fase 1: Build
+
+```bash
+# Maven
+mvn clean verify -DskipTests
+
+# Gradle
+./gradlew clean assemble -x test
+```
+
+Si el build falla, detente y corrige los errores de compilación.
+
+## Fase 2: Análisis estático
+
+### Checkstyle, PMD, SpotBugs (Maven)
+
+```bash
+mvn checkstyle:check pmd:check spotbugs:check
+```
+
+### SonarQube (si está configurado)
+
+```bash
+mvn sonar:sonar \
+  -Dsonar.projectKey=my-quarkus-project \
+  -Dsonar.host.url=http://localhost:9000 \
+  -Dsonar.login=${SONAR_TOKEN}
+```
+
+### Problemas comunes a corregir
+
+- Imports o variables sin usar
+- Métodos complejos (alta complejidad ciclomática)
+- Posibles dereferencias de puntero nulo
+- Problemas de seguridad señalados por SpotBugs
+
+## Fase 3: Tests + cobertura
+
+```bash
+# Ejecutar todos los tests
+mvn clean test
+
+# Generar el reporte de cobertura
+mvn jacoco:report
+
+# Exigir el umbral de cobertura (80 %)
+mvn jacoco:check
+
+# O con Gradle
+./gradlew test jacocoTestReport jacocoTestCoverageVerification
+```
+
+### Categorías de tests
+
+#### Tests unitarios
+Prueba la lógica de servicio con dependencias mockeadas:
+
+```java
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+  @Mock UserRepository userRepository;
+  @InjectMocks UserService userService;
+
+  @Test
+  void createUser_validInput_returnsUser() {
+    var dto = new CreateUserDto("Alice", "alice@example.com");
+
+    // persist() de Panache es void — usa doNothing + verify
+    doNothing().when(userRepository).persist(any(User.class));
+
+    User result = userService.create(dto);
+
+    assertThat(result.name).isEqualTo("Alice");
+    verify(userRepository).persist(any(User.class));
+  }
+}
+```
+
+#### Tests de integración
+Prueba con base de datos real (Testcontainers):
+
+```java
+@QuarkusTest
+@QuarkusTestResource(PostgresTestResource.class)
+class UserRepositoryIntegrationTest {
+
+  @Inject
+  UserRepository userRepository;
+
+  @Test
+  @Transactional
+  void findByEmail_existingUser_returnsUser() {
+    User user = new User();
+    user.name = "Alice";
+    user.email = "alice@example.com";
+    userRepository.persist(user);
+
+    Optional<User> found = userRepository.findByEmail("alice@example.com");
+
+    assertThat(found).isPresent();
+    assertThat(found.get().name).isEqualTo("Alice");
+  }
+}
+```
+
+#### Tests de API
+Prueba los endpoints REST con REST Assured:
+
+```java
+@QuarkusTest
+class UserResourceTest {
+
+  @Test
+  void createUser_validInput_returns201() {
+    given()
+        .contentType(ContentType.JSON)
+        .body("""
+            {"name": "Alice", "email": "alice@example.com"}
+            """)
+        .when().post("/api/users")
+        .then()
+        .statusCode(201)
+        .body("name", equalTo("Alice"));
+  }
+
+  @Test
+  void createUser_invalidEmail_returns400() {
+    given()
+        .contentType(ContentType.JSON)
+        .body("""
+            {"name": "Alice", "email": "invalid"}
+            """)
+        .when().post("/api/users")
+        .then()
+        .statusCode(400);
+  }
+}
+```
+
+### Reporte de cobertura
+
+Revisa `target/site/jacoco/index.html` para la cobertura detallada:
+- Cobertura global de líneas (objetivo: 80 %+)
+- Cobertura de ramas (objetivo: 70 %+)
+- Identifica caminos críticos sin cubrir
+
+## Fase 4: Escaneo de seguridad
+
+### Vulnerabilidades en dependencias (Maven)
+
+```bash
+mvn org.owasp:dependency-check-maven:check
+```
+
+Revisa `target/dependency-check-report.html` en busca de CVEs.
+
+### Auditoría de seguridad de Quarkus
+
+```bash
+# Revisar extensiones vulnerables
+mvn quarkus:audit
+
+# Listar todas las extensiones
+mvn quarkus:list-extensions
+```
+
+### OWASP ZAP (testing de seguridad de APIs)
+
+```bash
+docker run -t owasp/zap2docker-stable zap-api-scan.py \
+  -t http://localhost:8080/q/openapi \
+  -f openapi
+```
+
+### Verificaciones de seguridad comunes
+
+- [ ] Todos los secretos en variables de entorno (no en el código)
+- [ ] Validación de entrada en todos los endpoints
+- [ ] Autenticación/autorización configuradas
+- [ ] CORS configurado correctamente
+- [ ] Cabeceras de seguridad establecidas
+- [ ] Contraseñas hasheadas con BCrypt
+- [ ] Protección contra inyección SQL (consultas parametrizadas)
+- [ ] Rate limiting en los endpoints públicos
+
+## Fase 5: Compilación nativa
+
+Prueba la compatibilidad con imagen nativa GraalVM:
+
+```bash
+# Compilar el ejecutable nativo
+mvn package -Dnative
+
+# O con contenedor
+mvn package -Dnative -Dquarkus.native.container-build=true
+
+# Probar el ejecutable nativo
+./target/*-runner
+
+# Ejecutar smoke tests básicos
+curl http://localhost:8080/q/health/live
+curl http://localhost:8080/q/health/ready
+```
+
+### Solución de problemas con imagen nativa
+
+Problemas comunes:
+- **Reflexión**: añade configuración de reflexión para clases dinámicas
+- **Recursos**: incluye recursos con `quarkus.native.resources.includes`
+- **JNI**: registra las clases JNI si usas bibliotecas nativas
+
+Ejemplo de configuración de reflexión:
+```java
+@RegisterForReflection(targets = {MyDynamicClass.class})
+public class ReflectionConfiguration {}
+```
+
+## Fase 6: Pruebas de rendimiento
+
+### Pruebas de carga con K6
+
+```javascript
+// load-test.js
+import http from 'k6/http';
+import { check } from 'k6';
+
+export const options = {
+  stages: [
+    { duration: '30s', target: 50 },
+    { duration: '1m', target: 100 },
+    { duration: '30s', target: 0 },
+  ],
+};
+
+export default function () {
+  const res = http.get('http://localhost:8080/api/markets');
+  check(res, {
+    'el estado es 200': (r) => r.status === 200,
+    'tiempo de respuesta < 200ms': (r) => r.timings.duration < 200,
+  });
+}
+```
+
+Ejecuta:
+```bash
+k6 run load-test.js
+```
+
+### Métricas a monitorear
+
+- Tiempo de respuesta (p50, p95, p99)
+- Throughput (peticiones/segundo)
+- Tasa de errores
+- Uso de memoria
+- Uso de CPU
+
+## Fase 7: Health checks
+
+```bash
+# Liveness
+curl http://localhost:8080/q/health/live
+
+# Readiness
+curl http://localhost:8080/q/health/ready
+
+# Todos los health checks
+curl http://localhost:8080/q/health
+
+# Métricas (si están habilitadas)
+curl http://localhost:8080/q/metrics
+```
+
+Respuestas esperadas:
+```json
+{
+  "status": "UP",
+  "checks": [
+    {
+      "name": "Database connection",
+      "status": "UP"
+    }
+  ]
+}
+```
+
+## Fase 8: Build de la imagen de contenedor
+
+```bash
+# Construir la imagen de contenedor
+mvn package -Dquarkus.container-image.build=true
+
+# O con un registro específico
+mvn package \
+  -Dquarkus.container-image.build=true \
+  -Dquarkus.container-image.registry=docker.io \
+  -Dquarkus.container-image.group=myorg \
+  -Dquarkus.container-image.tag=1.0.0
+
+# Probar el contenedor
+docker run -p 8080:8080 myorg/my-quarkus-app:1.0.0
+```
+
+### Escaneo de seguridad del contenedor
+
+```bash
+# Trivy
+trivy image myorg/my-quarkus-app:1.0.0
+
+# Grype
+grype myorg/my-quarkus-app:1.0.0
+```
+
+## Fase 9: Validación de configuración
+
+```bash
+# Revisar todas las propiedades de configuración
+mvn quarkus:info
+
+# Listar todas las fuentes de configuración
+curl http://localhost:8080/q/dev/io.quarkus.quarkus-vertx-http/config
+```
+
+### Verificaciones por entorno
+
+- [ ] URLs de base de datos configuradas por entorno
+- [ ] Secretos externalizados (Vault, variables de entorno)
+- [ ] Niveles de logging apropiados
+- [ ] Orígenes CORS configurados correctamente
+- [ ] Rate limiting configurado
+- [ ] Monitoreo/trazado habilitado
+
+## Fase 10: Revisión de documentación
+
+- [ ] Documentación OpenAPI/Swagger al día (`/q/swagger-ui`)
+- [ ] El README tiene instrucciones de configuración
+- [ ] Cambios de API documentados
+- [ ] Guía de migración para cambios incompatibles
+- [ ] Propiedades de configuración documentadas
+
+Genera la especificación OpenAPI:
+```bash
+curl http://localhost:8080/q/openapi -o openapi.json
+```
+
+## Lista de verificación
+
+### Calidad de código
+- [ ] El build pasa sin warnings
+- [ ] Análisis estático limpio (sin issues altos/medios)
+- [ ] El código sigue las convenciones del equipo
+- [ ] Sin código comentado ni TODOs en el PR
+
+### Testing
+- [ ] Todos los tests pasan
+- [ ] Cobertura de código ≥ 80 %
+- [ ] Tests de integración con base de datos real
+- [ ] Los tests de seguridad pasan
+- [ ] Rendimiento dentro de límites aceptables
+
+### Seguridad
+- [ ] Sin vulnerabilidades en dependencias
+- [ ] Autenticación/autorización probadas
+- [ ] Validación de entrada completa
+- [ ] Sin secretos en el código fuente
+- [ ] Cabeceras de seguridad configuradas
+
+### Despliegue
+- [ ] Compilación nativa exitosa
+- [ ] La imagen de contenedor compila
+- [ ] Los health checks responden correctamente
+- [ ] Configuración válida para el entorno objetivo
+
+### Imagen nativa
+- [ ] El ejecutable nativo compila
+- [ ] Los tests nativos pasan
+- [ ] Tiempo de arranque < 100 ms
+- [ ] Huella de memoria aceptable
+
+## Script de verificación automatizado
+
+```bash
+#!/bin/bash
+set -e
+
+echo "=== Fase 1: Build ==="
+mvn clean verify -DskipTests
+
+echo "=== Fase 2: Análisis estático ==="
+mvn checkstyle:check pmd:check spotbugs:check
+
+echo "=== Fase 3: Tests + cobertura ==="
+mvn test jacoco:report jacoco:check
+
+echo "=== Fase 4: Escaneo de seguridad ==="
+mvn org.owasp:dependency-check-maven:check
+
+echo "=== Fase 5: Compilación nativa ==="
+mvn package -Dnative -Dquarkus.native.container-build=true
+
+echo "=== Todas las fases completadas ==="
+echo "Revisa los reportes:"
+echo "  - Cobertura: target/site/jacoco/index.html"
+echo "  - Seguridad: target/dependency-check-report.html"
+echo "  - Nativo: target/*-runner"
+```
+
+## Integración en CI/CD
+
+### Ejemplo con GitHub Actions
+
+```yaml
+name: Verification
+
+on: [push, pull_request]
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v3
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Maven packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.m2
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+
+      - name: Build
+        run: mvn clean verify -DskipTests
+
+      - name: Test with Coverage
+        run: mvn test jacoco:report jacoco:check
+
+      - name: Security Scan
+        run: mvn org.owasp:dependency-check-maven:check
+
+      - name: Upload Coverage
+        uses: codecov/codecov-action@v3
+        with:
+          files: target/site/jacoco/jacoco.xml
+```
+
+## Buenas prácticas
+
+- Ejecuta el bucle de verificación antes de cada PR
+- Automatízalo en el pipeline de CI/CD
+- Corrige los problemas de inmediato; no acumules deuda
+- Mantén la cobertura por encima del 80 %
+- Actualiza las dependencias con regularidad
+- Prueba la compilación nativa periódicamente
+- Monitorea las tendencias de rendimiento
+- Documenta los cambios incompatibles
+- Revisa los resultados de los escaneos de seguridad
+- Valida la configuración de cada entorno
+
+## Skills relacionadas
+
+- `patrones-quarkus`
+- `seguridad-quarkus`
+- `tdd-quarkus`
+- `bucle-verificacion`

package/vendor/theus-arsenal/skills/verificacion-springboot/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: verificacion-springboot
+description: Bucle de verificación para proyectos Spring Boot — build, análisis estático, pruebas con cobertura, escaneo de seguridad y revisión del diff antes de publicar o abrir un PR.
+---
+
+# Bucle de verificación para Spring Boot
+
+Ejecútalo antes de abrir PRs, después de cambios grandes y antes de desplegar.
+
+## Cuándo activarla
+
+- Antes de abrir un pull request para un servicio Spring Boot
+- Después de refactorizaciones grandes o actualizaciones de dependencias
+- Verificación previa al despliegue en staging o producción
+- Ejecutar el pipeline completo build → lint → pruebas → escaneo de seguridad
+- Validar que la cobertura de pruebas cumple los umbrales
+
+## Fase 1: Build
+
+```bash
+mvn -T 4 clean verify -DskipTests
+# o
+./gradlew clean assemble -x test
+```
+
+Si el build falla, detente y corrígelo.
+
+## Fase 2: Análisis estático
+
+Maven (plugins habituales):
+```bash
+mvn -T 4 spotbugs:check pmd:check checkstyle:check
+```
+
+Gradle (si está configurado):
+```bash
+./gradlew checkstyleMain pmdMain spotbugsMain
+```
+
+## Fase 3: Pruebas + cobertura
+
+```bash
+mvn -T 4 test
+mvn jacoco:report   # verifica cobertura de 80 %+
+# o
+./gradlew test jacocoTestReport
+```
+
+Reporta:
+- Total de pruebas, pasadas/fallidas
+- % de cobertura (líneas/ramas)
+
+### Pruebas unitarias
+
+Prueba la lógica de servicio de forma aislada con dependencias simuladas:
+
+```java
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+
+  @Mock private UserRepository userRepository;
+  @InjectMocks private UserService userService;
+
+  @Test
+  void createUser_validInput_returnsUser() {
+    var dto = new CreateUserDto("Alice", "alice@example.com");
+    var expected = new User(1L, "Alice", "alice@example.com");
+    when(userRepository.save(any(User.class))).thenReturn(expected);
+
+    var result = userService.create(dto);
+
+    assertThat(result.name()).isEqualTo("Alice");
+    verify(userRepository).save(any(User.class));
+  }
+
+  @Test
+  void createUser_duplicateEmail_throwsException() {
+    var dto = new CreateUserDto("Alice", "existing@example.com");
+    when(userRepository.existsByEmail(dto.email())).thenReturn(true);
+
+    assertThatThrownBy(() -> userService.create(dto))
+        .isInstanceOf(DuplicateEmailException.class);
+  }
+}
+```
+
+### Pruebas de integración con Testcontainers
+
+Prueba contra una base de datos real en lugar de H2:
+
+```java
+@SpringBootTest
+@Testcontainers
+class UserRepositoryIntegrationTest {
+
+  @Container
+  static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
+      .withDatabaseName("testdb");
+
+  @DynamicPropertySource
+  static void configureProperties(DynamicPropertyRegistry registry) {
+    registry.add("spring.datasource.url", postgres::getJdbcUrl);
+    registry.add("spring.datasource.username", postgres::getUsername);
+    registry.add("spring.datasource.password", postgres::getPassword);
+  }
+
+  @Autowired private UserRepository userRepository;
+
+  @Test
+  void findByEmail_existingUser_returnsUser() {
+    userRepository.save(new User("Alice", "alice@example.com"));
+
+    var found = userRepository.findByEmail("alice@example.com");
+
+    assertThat(found).isPresent();
+    assertThat(found.get().getName()).isEqualTo("Alice");
+  }
+}
+```
+
+### Pruebas de API con MockMvc
+
+Prueba la capa de controladores:
+
+```java
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+
+  @Autowired private MockMvc mockMvc;
+  @MockBean private UserService userService;
+
+  @Test
+  void createUser_validInput_returns201() throws Exception {
+    var user = new UserDto(1L, "Alice", "alice@example.com");
+    when(userService.create(any())).thenReturn(user);
+
+    mockMvc.perform(post("/api/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content("""
+                {"name": "Alice", "email": "alice@example.com"}
+                """))
+        .andExpect(status().isCreated())
+        .andExpect(jsonPath("$.name").value("Alice"));
+  }
+
+  @Test
+  void createUser_invalidEmail_returns400() throws Exception {
+    mockMvc.perform(post("/api/users")
+            .contentType(MediaType.APPLICATION_JSON)
+            .content("""
+                {"name": "Alice", "email": "not-an-email"}
+                """))
+        .andExpect(status().isBadRequest());
+  }
+}
+```
+
+## Fase 4: Escaneo de seguridad
+
+```bash
+# CVE en dependencias
+mvn org.owasp:dependency-check-maven:check
+# o
+./gradlew dependencyCheckAnalyze
+
+# Secretos en el código fuente
+grep -rn "password\s*=\s*\"" src/ --include="*.java" --include="*.yml" --include="*.properties"
+grep -rn "sk-\|api_key\|secret" src/ --include="*.java" --include="*.yml"
+
+# Secretos (historial de git)
+git secrets --scan  # si está configurado
+```
+
+### Hallazgos de seguridad comunes
+
+```
+# Buscar System.out.println (usa un logger en su lugar)
+grep -rn "System\.out\.print" src/main/ --include="*.java"
+
+# Buscar mensajes de excepción crudos en las respuestas
+grep -rn "e\.getMessage()" src/main/ --include="*.java"
+
+# Buscar CORS con comodín
+grep -rn "allowedOrigins.*\*" src/main/ --include="*.java"
+```
+
+## Fase 5: Lint/formato (puerta opcional)
+
+```bash
+mvn spotless:apply   # si usas el plugin Spotless
+./gradlew spotlessApply
+```
+
+## Fase 6: Revisión del diff
+
+```bash
+git diff --stat
+git diff
+```
+
+Checklist:
+- Sin logs de depuración olvidados (`System.out`, `log.debug` sin guardas)
+- Errores con significado y códigos HTTP correctos
+- Transacciones y validación presentes donde hacen falta
+- Cambios de configuración documentados
+
+## Plantilla de salida
+
+```
+INFORME DE VERIFICACIÓN
+=======================
+Build:      [PASA/FALLA]
+Estático:   [PASA/FALLA] (spotbugs/pmd/checkstyle)
+Pruebas:    [PASA/FALLA] (X/Y pasadas, Z% cobertura)
+Seguridad:  [PASA/FALLA] (hallazgos CVE: N)
+Diff:       [X archivos modificados]
+
+Global:     [LISTO / NO LISTO]
+
+Problemas a corregir:
+1. ...
+2. ...
+```
+
+## Modo continuo
+
+- Reejecuta las fases ante cambios significativos o cada 30–60 minutos en sesiones largas
+- Mantén un bucle corto: `mvn -T 4 test` + spotbugs para feedback rápido
+
+**Recuerda**: el feedback rápido vence a las sorpresas tardías. Mantén la puerta estricta — trata las advertencias como defectos en sistemas de producción.
+
+## Skills relacionadas
+
+- `patrones-springboot`
+- `seguridad-springboot`
+- `tdd-springboot`
+- `estandares-java`