theus-cli 0.2.83 → 0.2.85

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

@@ -1,165 +0,0 @@
----
-name: tdd-springboot
-description: Desarrollo guiado por pruebas (TDD) para Spring Boot con JUnit 5, Mockito, MockMvc, Testcontainers y JaCoCo. Úsala al añadir funcionalidades, corregir bugs o refactorizar servicios Java.
----
-
-# Flujo TDD para Spring Boot
-
-Guía de TDD para servicios Spring Boot con cobertura de 80 %+ (unitaria + integración).
-
-## Cuándo usarla
-
-- Nuevas funcionalidades o endpoints
-- Correcciones de bugs o refactorizaciones
-- Añadir lógica de acceso a datos o reglas de seguridad
-
-## Flujo de trabajo
-
-1) Escribe primero las pruebas (deben fallar)
-2) Implementa el código mínimo para que pasen
-3) Refactoriza con las pruebas en verde
-4) Exige la cobertura (JaCoCo)
-
-## Pruebas unitarias (JUnit 5 + Mockito)
-
-```java
-@ExtendWith(MockitoExtension.class)
-class MarketServiceTest {
-  @Mock MarketRepository repo;
-  @InjectMocks MarketService service;
-
-  @Test
-  void createsMarket() {
-    CreateMarketRequest req = new CreateMarketRequest("name", "desc", Instant.now(), List.of("cat"));
-    when(repo.save(any())).thenAnswer(inv -> inv.getArgument(0));
-
-    Market result = service.create(req);
-
-    assertThat(result.name()).isEqualTo("name");
-    verify(repo).save(any());
-  }
-}
-```
-
-Patrones:
-- Arrange-Act-Assert (preparar, actuar, verificar)
-- Evita mocks parciales; prefiere stubbing explícito
-- Usa `@ParameterizedTest` para las variantes
-
-## Pruebas de la capa web (MockMvc)
-
-```java
-@WebMvcTest(MarketController.class)
-class MarketControllerTest {
-  @Autowired MockMvc mockMvc;
-  @MockBean MarketService marketService;
-
-  @Test
-  void returnsMarkets() throws Exception {
-    when(marketService.list(any())).thenReturn(Page.empty());
-
-    mockMvc.perform(get("/api/markets"))
-        .andExpect(status().isOk())
-        .andExpect(jsonPath("$.content").isArray());
-  }
-}
-```
-
-## Pruebas de integración (SpringBootTest)
-
-```java
-@SpringBootTest
-@AutoConfigureMockMvc
-@ActiveProfiles("test")
-class MarketIntegrationTest {
-  @Autowired MockMvc mockMvc;
-
-  @Test
-  void createsMarket() throws Exception {
-    mockMvc.perform(post("/api/markets")
-        .contentType(MediaType.APPLICATION_JSON)
-        .content("""
-          {"name":"Test","description":"Desc","endDate":"2030-01-01T00:00:00Z","categories":["general"]}
-        """))
-      .andExpect(status().isCreated());
-  }
-}
-```
-
-## Pruebas de persistencia (DataJpaTest)
-
-```java
-@DataJpaTest
-@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-@Import(TestContainersConfig.class)
-class MarketRepositoryTest {
-  @Autowired MarketRepository repo;
-
-  @Test
-  void savesAndFinds() {
-    MarketEntity entity = new MarketEntity();
-    entity.setName("Test");
-    repo.save(entity);
-
-    Optional<MarketEntity> found = repo.findByName("Test");
-    assertThat(found).isPresent();
-  }
-}
-```
-
-## Testcontainers
-
-- Usa contenedores reutilizables para Postgres/Redis y así replicar producción
-- Conéctalos vía `@DynamicPropertySource` para inyectar las URL JDBC en el contexto de Spring
-
-## Cobertura (JaCoCo)
-
-Fragmento de Maven:
-```xml
-<plugin>
-  <groupId>org.jacoco</groupId>
-  <artifactId>jacoco-maven-plugin</artifactId>
-  <version>0.8.14</version>
-  <executions>
-    <execution>
-      <goals><goal>prepare-agent</goal></goals>
-    </execution>
-    <execution>
-      <id>report</id>
-      <phase>verify</phase>
-      <goals><goal>report</goal></goals>
-    </execution>
-  </executions>
-</plugin>
-```
-
-## Aserciones
-
-- Prefiere AssertJ (`assertThat`) por legibilidad
-- Para respuestas JSON, usa `jsonPath`
-- Para excepciones: `assertThatThrownBy(...)`
-
-## Builders de datos de prueba
-
-```java
-class MarketBuilder {
-  private String name = "Test";
-  MarketBuilder withName(String name) { this.name = name; return this; }
-  Market build() { return new Market(null, name, MarketStatus.ACTIVE); }
-}
-```
-
-## Comandos de CI
-
-- Maven: `mvn -T 4 test` o `mvn verify`
-- Gradle: `./gradlew test jacocoTestReport`
-
-**Recuerda**: mantén las pruebas rápidas, aisladas y deterministas. Prueba el comportamiento, no los detalles de implementación.
-
-## Skills relacionadas
-
-- `patrones-springboot`
-- `seguridad-springboot`
-- `verificacion-springboot`
-- `patrones-jpa`
-- `flujo-tdd`

package/vendor/theus-arsenal/skills/testing-cpp/SKILL.md

@@ -1,328 +0,0 @@
----
-name: testing-cpp
-description: Úsala solo al escribir, actualizar o corregir tests de C++, configurar GoogleTest/CTest,
-  diagnosticar tests fallidos o inestables, o añadir cobertura y sanitizers.
----
-
-# Testing en C++
-
-Flujo de pruebas orientado al agente para C++ moderno (C++17/20) usando GoogleTest/GoogleMock con CMake/CTest.
-
-## Cuándo usarla
-
-- Al escribir tests de C++ nuevos o corregir tests existentes.
-- Al diseñar cobertura de tests unitarios/de integración para componentes C++.
-- Al añadir cobertura, gating de CI o protección contra regresiones.
-- Al configurar flujos de CMake/CTest para una ejecución consistente.
-- Al investigar fallos de tests o comportamiento inestable (flaky).
-- Al habilitar sanitizers para diagnóstico de memoria o carreras.
-
-### Cuándo NO usarla
-
-- Implementar funcionalidades nuevas de producto sin cambios en tests.
-- Refactorizaciones a gran escala no relacionadas con cobertura o fallos de tests.
-- Ajuste de rendimiento sin regresiones de tests que validar.
-- Proyectos que no son C++ o tareas ajenas a los tests.
-
-## Conceptos clave
-
-- **Bucle TDD**: rojo → verde → refactor (tests primero, arreglo mínimo, luego limpieza).
-- **Aislamiento**: prefiere inyección de dependencias y fakes sobre estado global.
-- **Layout de tests**: `tests/unit`, `tests/integration`, `tests/testdata`.
-- **Mocks vs fakes**: mock para interacciones, fake para comportamiento con estado.
-- **Descubrimiento en CTest**: usa `gtest_discover_tests()` para un descubrimiento estable.
-- **Señal de CI**: ejecuta primero un subconjunto, luego la suite completa con `--output-on-failure`.
-
-## Flujo TDD
-
-Sigue el bucle ROJO → VERDE → REFACTOR:
-
-1. **ROJO**: escribe un test que falle y capture el nuevo comportamiento.
-2. **VERDE**: implementa el cambio más pequeño que lo haga pasar.
-3. **REFACTOR**: limpia mientras los tests siguen en verde.
-
-```cpp
-// tests/add_test.cpp
-#include <gtest/gtest.h>
-
-int Add(int a, int b); // Provisto por el código de producción.
-
-TEST(AddTest, SumaDosNumeros) { // ROJO
-  EXPECT_EQ(Add(2, 3), 5);
-}
-
-// src/add.cpp
-int Add(int a, int b) { // VERDE
-  return a + b;
-}
-
-// REFACTOR: simplificar/renombrar una vez que los tests pasan
-```
-
-## Ejemplos de código
-
-### Test unitario básico (gtest)
-
-```cpp
-// tests/calculator_test.cpp
-#include <gtest/gtest.h>
-
-int Add(int a, int b); // Provisto por el código de producción.
-
-TEST(CalculatorTest, SumaDosNumeros) {
-    EXPECT_EQ(Add(2, 3), 5);
-}
-```
-
-### Fixture (gtest)
-
-```cpp
-// tests/user_store_test.cpp
-// Stub de pseudocódigo: reemplaza UserStore/User por los tipos del proyecto.
-#include <gtest/gtest.h>
-#include <memory>
-#include <optional>
-#include <string>
-
-struct User { std::string name; };
-class UserStore {
-public:
-    explicit UserStore(std::string /*path*/) {}
-    void Seed(std::initializer_list<User> /*users*/) {}
-    std::optional<User> Find(const std::string &/*name*/) { return User{"alice"}; }
-};
-
-class UserStoreTest : public ::testing::Test {
-protected:
-    void SetUp() override {
-        store = std::make_unique<UserStore>(":memory:");
-        store->Seed({{"alice"}, {"bob"}});
-    }
-
-    std::unique_ptr<UserStore> store;
-};
-
-TEST_F(UserStoreTest, EncuentraUsuarioExistente) {
-    auto user = store->Find("alice");
-    ASSERT_TRUE(user.has_value());
-    EXPECT_EQ(user->name, "alice");
-}
-```
-
-### Mock (gmock)
-
-```cpp
-// tests/notifier_test.cpp
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <string>
-
-class Notifier {
-public:
-    virtual ~Notifier() = default;
-    virtual void Send(const std::string &message) = 0;
-};
-
-class MockNotifier : public Notifier {
-public:
-    MOCK_METHOD(void, Send, (const std::string &message), (override));
-};
-
-class Service {
-public:
-    explicit Service(Notifier &notifier) : notifier_(notifier) {}
-    void Publish(const std::string &message) { notifier_.Send(message); }
-
-private:
-    Notifier &notifier_;
-};
-
-TEST(ServiceTest, EnviaNotificaciones) {
-    MockNotifier notifier;
-    Service service(notifier);
-
-    EXPECT_CALL(notifier, Send("hola")).Times(1);
-    service.Publish("hola");
-}
-```
-
-### Inicio rápido con CMake/CTest
-
-```cmake
-# CMakeLists.txt (extracto)
-cmake_minimum_required(VERSION 3.20)
-project(example LANGUAGES CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-include(FetchContent)
-# Prefiere versiones fijadas por el proyecto. Si usas un tag, fíjalo según la política del proyecto.
-set(GTEST_VERSION v1.17.0) # Ajustar a la política del proyecto.
-FetchContent_Declare(
-  googletest
-  # Framework Google Test (repositorio oficial)
-  URL https://github.com/google/googletest/archive/refs/tags/${GTEST_VERSION}.zip
-)
-FetchContent_MakeAvailable(googletest)
-
-add_executable(example_tests
-  tests/calculator_test.cpp
-  src/calculator.cpp
-)
-target_link_libraries(example_tests GTest::gtest GTest::gmock GTest::gtest_main)
-
-enable_testing()
-include(GoogleTest)
-gtest_discover_tests(example_tests)
-```
-
-```bash
-cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
-cmake --build build -j
-ctest --test-dir build --output-on-failure
-```
-
-## Ejecutar tests
-
-```bash
-ctest --test-dir build --output-on-failure
-ctest --test-dir build -R ClampTest
-ctest --test-dir build -R "UserStoreTest.*" --output-on-failure
-```
-
-```bash
-./build/example_tests --gtest_filter=ClampTest.*
-./build/example_tests --gtest_filter=UserStoreTest.EncuentraUsuarioExistente
-```
-
-## Depurar fallos
-
-1. Reejecuta el único test que falla con el filtro de gtest.
-2. Añade logging acotado alrededor de la aserción que falla.
-3. Reejecuta con los sanitizers habilitados.
-4. Amplía a la suite completa una vez corregida la causa raíz.
-
-## Cobertura
-
-Prefiere configuración a nivel de target en lugar de flags globales.
-
-```cmake
-option(ENABLE_COVERAGE "Habilitar flags de cobertura" OFF)
-
-if(ENABLE_COVERAGE)
-  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    target_compile_options(example_tests PRIVATE --coverage)
-    target_link_options(example_tests PRIVATE --coverage)
-  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    target_compile_options(example_tests PRIVATE -fprofile-instr-generate -fcoverage-mapping)
-    target_link_options(example_tests PRIVATE -fprofile-instr-generate)
-  endif()
-endif()
-```
-
-GCC + gcov + lcov:
-
-```bash
-cmake -S . -B build-cov -DENABLE_COVERAGE=ON
-cmake --build build-cov -j
-ctest --test-dir build-cov
-lcov --capture --directory build-cov --output-file coverage.info
-lcov --remove coverage.info '/usr/*' --output-file coverage.info
-genhtml coverage.info --output-directory coverage
-```
-
-Clang + llvm-cov:
-
-```bash
-cmake -S . -B build-llvm -DENABLE_COVERAGE=ON -DCMAKE_CXX_COMPILER=clang++
-cmake --build build-llvm -j
-LLVM_PROFILE_FILE="build-llvm/default.profraw" ctest --test-dir build-llvm
-llvm-profdata merge -sparse build-llvm/default.profraw -o build-llvm/default.profdata
-llvm-cov report build-llvm/example_tests -instr-profile=build-llvm/default.profdata
-```
-
-## Sanitizers
-
-```cmake
-option(ENABLE_ASAN "Habilitar AddressSanitizer" OFF)
-option(ENABLE_UBSAN "Habilitar UndefinedBehaviorSanitizer" OFF)
-option(ENABLE_TSAN "Habilitar ThreadSanitizer" OFF)
-
-if(ENABLE_ASAN)
-  add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
-  add_link_options(-fsanitize=address)
-endif()
-if(ENABLE_UBSAN)
-  add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
-  add_link_options(-fsanitize=undefined)
-endif()
-if(ENABLE_TSAN)
-  add_compile_options(-fsanitize=thread)
-  add_link_options(-fsanitize=thread)
-endif()
-```
-
-## Barandillas contra tests inestables
-
-- Nunca uses `sleep` para sincronizar; usa variables de condición o latches.
-- Haz los directorios temporales únicos por test y límpialos siempre.
-- Evita dependencias de tiempo real, red o sistema de archivos en tests unitarios.
-- Usa semillas deterministas para entradas aleatorizadas.
-
-## Buenas prácticas
-
-### SÍ
-
-- Mantén los tests deterministas y aislados.
-- Prefiere inyección de dependencias sobre globales.
-- Usa `ASSERT_*` para precondiciones, `EXPECT_*` para verificaciones múltiples.
-- Separa tests unitarios y de integración con etiquetas de CTest o directorios.
-- Ejecuta sanitizers en CI para detección de memoria y carreras.
-
-### NO
-
-- No dependas de tiempo real ni de red en tests unitarios.
-- No uses sleeps como sincronización cuando puede usarse una variable de condición.
-- No hagas mocks excesivos de objetos de valor simples.
-- No uses coincidencias de cadenas frágiles para logs no críticos.
-
-### Errores comunes
-
-- **Rutas temporales fijas** → genera directorios temporales únicos por test y límpialos.
-- **Depender del reloj de pared** → inyecta un reloj o usa fuentes de tiempo falsas.
-- **Tests de concurrencia inestables** → usa variables de condición/latches y esperas acotadas.
-- **Estado global oculto** → resetea el estado global en fixtures o elimina los globales.
-- **Mocks excesivos** → prefiere fakes para comportamiento con estado y mockea solo interacciones.
-- **Sin ejecuciones con sanitizers** → añade builds ASan/UBSan/TSan en CI.
-- **Cobertura solo en builds de debug** → asegura que los targets de cobertura usen flags consistentes.
-
-## Apéndice opcional: fuzzing / testing de propiedades
-
-Úsalo solo si el proyecto ya soporta LLVM/libFuzzer o una biblioteca de testing de propiedades.
-
-- **libFuzzer**: ideal para funciones puras con E/S mínima.
-- **RapidCheck**: tests basados en propiedades para validar invariantes.
-
-Harness mínimo de libFuzzer (pseudocódigo: reemplaza ParseConfig):
-
-```cpp
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-    std::string input(reinterpret_cast<const char *>(data), size);
-    // ParseConfig(input); // función del proyecto
-    return 0;
-}
-```
-
-## Alternativas a GoogleTest
-
-- **Catch2**: header-only, matchers expresivos.
-- **doctest**: ligero, sobrecarga de compilación mínima.
-
-## Skills relacionadas
-
-- `estandares-cpp` para los estándares de codificación de C++ moderno.