npm - theus-cli-linux-x64 - Versions diffs - 1.2.2 → 1.3.0 - Mend

theus-cli-linux-x64 1.2.2 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (758) hide show

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

@@ -1,485 +0,0 @@
----
-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 DELETED Viewed

@@ -1,237 +0,0 @@
----
-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`