theus-cli-linux-x64 1.2.2 → 1.4.0

package/vendor/theus-arsenal/commands/test-flutter.md

@@ -1,143 +0,0 @@
----
-description: Ejecuta tests de Flutter/Dart, informa los fallos y corrige los problemas de forma incremental. Cubre tests unitarios, de widgets, golden y de integración.
----
-
-# Test Flutter
-
-Este comando ejecuta la suite de tests de Flutter e informa los resultados. Cuando hay fallos, los diagnostica y corrige de forma incremental.
-
-## Qué hace este comando
-
-1. **Ejecutar tests**: ejecuta `flutter test` (o lo acota a los archivos cambiados)
-2. **Analizar fallos**: identifica los tests que fallan por tipo y causa
-3. **Corregir incrementalmente**: un fallo a la vez cuando sea posible
-4. **Verificar**: vuelve a ejecutar tras cada arreglo
-5. **Informar**: muestra el resumen de cobertura y los fallos restantes
-
-## Cuándo usarlo
-
-Usa `/test-flutter` cuando:
-- Tras implementar una funcionalidad, para verificar que nada se rompió
-- Después de ejecutar `/build-flutter`, para asegurar que los tests pasan
-- Para revisar la cobertura de tests del código nuevo
-- Cuando un archivo de test específico está fallando
-- Antes de enviar un PR
-
-## Comandos ejecutados
-
-```bash
-# Ejecutar todos los tests
-flutter test 2>&1
-
-# Ejecutar con cobertura
-flutter test --coverage 2>&1
-
-# Ejecutar un archivo de test específico
-flutter test test/unit/domain/usecases/get_user_test.dart 2>&1
-
-# Ejecutar tests que coincidan con un patrón de nombre
-flutter test --name "CartBloc" 2>&1
-
-# Ejecutar tests de integración (requiere dispositivo/emulador)
-flutter test integration_test/ 2>&1
-
-# Actualizar los archivos golden cuando hay cambios visuales intencionales
-flutter test --update-goldens 2>&1
-```
-
-## Sesión de ejemplo
-
-````text
-Usuario: /test-flutter
-
-Agente:
-# Ejecución de tests de Flutter
-
-## Ejecución
-
-```
-$ flutter test
-00:05 +42 -2: Some tests failed.
-
-FAILED: test/unit/data/user_repository_test.dart
-  UserRepository getById
-    returns null when user not found
-    Expected: null
-    Actual: User(id: 'test-id', name: 'Test User')
-
-FAILED: test/widget/cart_page_test.dart
-  CartPage
-    shows empty state when cart is empty
-    Expected: exactly one widget with text 'Your cart is empty'
-    Found: no widget with text 'Your cart is empty'
-```
-
-## Arreglo 1: test del repositorio
-
-Archivo: test/unit/data/user_repository_test.dart
-Fallo: `getById` devuelve un usuario cuando debería devolver null para un ID inexistente
-
-Causa raíz: el setup del test agrega un usuario con ID 'test-id' pero la consulta usa 'missing-id'.
-Arreglo: se actualizó el test para consultar con 'missing-id' — el setup era correcto, la consulta estaba mal.
-
-```
-$ flutter test test/unit/data/user_repository_test.dart
-1 test passed.
-```
-
-## Arreglo 2: test de widget
-
-Archivo: test/widget/cart_page_test.dart
-Fallo: no se encuentra el widget de texto del estado vacío
-
-Causa raíz: el mensaje de estado vacío se renombró de 'Your cart is empty' a 'Cart is empty' en el widget.
-Arreglo: se actualizó la cadena del test para coincidir con el texto actual del widget.
-
-```
-$ flutter test test/widget/cart_page_test.dart
-1 test passed.
-```
-
-## Ejecución final
-
-```
-$ flutter test --coverage
-All 44 tests passed.
-Coverage: 84.2% (target: 80%)
-```
-
-## Resumen
-
-| Métrica | Valor |
-|---------|-------|
-| Tests totales | 44 |
-| Pasaron | 44 |
-| Fallaron | 0 |
-| Cobertura | 84.2% |
-
-Estado de los tests: PASS ✓
-````
-
-## Fallos de test comunes
-
-| Fallo | Arreglo típico |
-|-------|----------------|
-| `Expected: <X> Actual: <Y>` | Actualizar la aserción o corregir la implementación |
-| `Widget not found` | Corregir el selector del finder o actualizar el test tras renombrar el widget |
-| `Golden file not found` | Ejecutar `flutter test --update-goldens` para generarlo |
-| `Golden mismatch` | Inspeccionar el diff; ejecutar `--update-goldens` si el cambio era intencional |
-| `MissingPluginException` | Simular (mock) el platform channel en el setup del test |
-| `LateInitializationError` | Inicializar los campos `late` en `setUp()` |
-| `pumpAndSettle timed out` | Reemplazar por llamadas explícitas a `pump(Duration)` |
-
-## Comandos relacionados
-
-- `/build-flutter` — Corregir los errores de build antes de ejecutar los tests
-- `/revisar-flutter` — Revisar el código cuando los tests pasen
-- Skill `flujo-tdd` — Flujo de desarrollo guiado por tests
-
-## Relacionados
-
-- Agente: `agents/revisor-flutter.md`
-- Agente: `agents/resolutor-builds-dart.md`
-- Skill: `skills/revision-codigo-flutter-dart/`

package/vendor/theus-arsenal/commands/test-go.md

@@ -1,268 +0,0 @@
----
-description: Aplica el flujo TDD para Go. Escribe primero tests tabulares, luego implementa. Verifica cobertura de 80%+ con go test -cover.
----
-
-# Comando TDD para Go
-
-Este comando aplica la metodología de desarrollo guiado por tests (TDD) para código Go usando los patrones idiomáticos de testing de Go.
-
-## Qué hace este comando
-
-1. **Define tipos e interfaces**: primero el andamiaje de firmas de funciones
-2. **Escribe tests tabulares**: crea casos de prueba exhaustivos (ROJO)
-3. **Ejecuta los tests**: verifica que fallen por la razón correcta
-4. **Implementa el código**: escribe el mínimo código para pasar (VERDE)
-5. **Refactoriza**: mejora manteniendo los tests en verde
-6. **Verifica la cobertura**: asegura 80%+ de cobertura
-
-## Cuándo usarlo
-
-Usa /test-go cuando:
-- Implementas nuevas funciones en Go
-- Agregas cobertura de tests a código existente
-- Corriges bugs (primero escribe el test que falla)
-- Construyes lógica de negocio crítica
-- Estás aprendiendo el flujo TDD en Go
-
-## Ciclo TDD
-
-```
-ROJO       → Escribir un test tabular que falla
-VERDE      → Implementar el mínimo código para pasar
-REFACTOR   → Mejorar el código, los tests siguen en verde
-REPETIR    → Siguiente caso de prueba
-```
-
-## Sesión de ejemplo
-
-````
-Usuario: /test-go Necesito una función para validar direcciones de email
-
-Agente:
-# Sesión TDD: validador de email
-
-## Paso 1: Definir la interfaz
-
-```go
-// validator/email.go
-package validator
-
-// ValidateEmail verifica si la cadena dada es una dirección de email válida.
-// Retorna nil si es válida; en caso contrario, un error que describe el problema.
-func ValidateEmail(email string) error {
-    panic("not implemented")
-}
-```
-
-## Paso 2: Escribir tests tabulares (ROJO)
-
-```go
-// validator/email_test.go
-package validator
-
-import (
-    "testing"
-)
-
-func TestValidateEmail(t *testing.T) {
-    tests := []struct {
-        name    string
-        email   string
-        wantErr bool
-    }{
-        // Emails válidos
-        {"email simple", "user@example.com", false},
-        {"con subdominio", "user@mail.example.com", false},
-        {"con signo más", "user+tag@example.com", false},
-        {"con puntos", "first.last@example.com", false},
-
-        // Emails inválidos
-        {"cadena vacía", "", true},
-        {"sin arroba", "userexample.com", true},
-        {"sin dominio", "user@", true},
-        {"sin parte local", "@example.com", true},
-        {"doble arroba", "user@@example.com", true},
-        {"espacios", "user @example.com", true},
-        {"sin tld", "user@example", true},
-    }
-
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            err := ValidateEmail(tt.email)
-            if tt.wantErr && err == nil {
-                t.Errorf("ValidateEmail(%q) = nil; want error", tt.email)
-            }
-            if !tt.wantErr && err != nil {
-                t.Errorf("ValidateEmail(%q) = %v; want nil", tt.email, err)
-            }
-        })
-    }
-}
-```
-
-## Paso 3: Ejecutar tests — verificar el FALLO
-
-```bash
-$ go test ./validator/...
-
---- FAIL: TestValidateEmail (0.00s)
-    --- FAIL: TestValidateEmail/email_simple (0.00s)
-        panic: not implemented
-
-FAIL
-```
-
-✓ Los tests fallan como se esperaba (panic).
-
-## Paso 4: Implementar el mínimo código (VERDE)
-
-```go
-// validator/email.go
-package validator
-
-import (
-    "errors"
-    "regexp"
-)
-
-var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
-
-var (
-    ErrEmailEmpty   = errors.New("email cannot be empty")
-    ErrEmailInvalid = errors.New("email format is invalid")
-)
-
-func ValidateEmail(email string) error {
-    if email == "" {
-        return ErrEmailEmpty
-    }
-    if !emailRegex.MatchString(email) {
-        return ErrEmailInvalid
-    }
-    return nil
-}
-```
-
-## Paso 5: Ejecutar tests — verificar el PASE
-
-```bash
-$ go test ./validator/...
-
-PASS
-ok      project/validator    0.003s
-```
-
-✓ ¡Todos los tests pasan!
-
-## Paso 6: Verificar la cobertura
-
-```bash
-$ go test -cover ./validator/...
-
-PASS
-coverage: 100.0% of statements
-ok      project/validator    0.003s
-```
-
-✓ Cobertura: 100%
-
-## ¡TDD completo!
-````
-
-## Patrones de testing
-
-### Tests tabulares
-```go
-tests := []struct {
-    name     string
-    input    InputType
-    want     OutputType
-    wantErr  bool
-}{
-    {"caso 1", input1, want1, false},
-    {"caso 2", input2, want2, true},
-}
-
-for _, tt := range tests {
-    t.Run(tt.name, func(t *testing.T) {
-        got, err := Function(tt.input)
-        // aserciones
-    })
-}
-```
-
-### Tests en paralelo
-```go
-for _, tt := range tests {
-    tt := tt // Capturar
-    t.Run(tt.name, func(t *testing.T) {
-        t.Parallel()
-        // cuerpo del test
-    })
-}
-```
-
-### Helpers de test
-```go
-func setupTestDB(t *testing.T) *sql.DB {
-    t.Helper()
-    db := createDB()
-    t.Cleanup(func() { db.Close() })
-    return db
-}
-```
-
-## Comandos de cobertura
-
-```bash
-# Cobertura básica
-go test -cover ./...
-
-# Perfil de cobertura
-go test -coverprofile=coverage.out ./...
-
-# Ver en el navegador
-go tool cover -html=coverage.out
-
-# Cobertura por función
-go tool cover -func=coverage.out
-
-# Con detección de carreras
-go test -race -cover ./...
-```
-
-## Objetivos de cobertura
-
-| Tipo de código | Objetivo |
-|----------------|----------|
-| Lógica de negocio crítica | 100% |
-| APIs públicas | 90%+ |
-| Código general | 80%+ |
-| Código generado | Excluir |
-
-## Buenas prácticas de TDD
-
-**SÍ:**
-- Escribir el test PRIMERO, antes de cualquier implementación
-- Ejecutar los tests después de cada cambio
-- Usar tests tabulares para cobertura exhaustiva
-- Testear el comportamiento, no los detalles de implementación
-- Incluir casos límite (vacío, nil, valores máximos)
-
-**NO:**
-- Escribir la implementación antes que los tests
-- Saltarse la fase ROJA
-- Testear funciones privadas directamente
-- Usar `time.Sleep` en los tests
-- Ignorar tests intermitentes
-
-## Comandos relacionados
-
-- /build-go — corregir errores de build
-- /revisar-go — revisar el código tras la implementación
-- Skill `bucle-verificacion` — bucle de verificación completo
-
-## Relacionados
-
-- Skill: `skills/testing-go/`
-- Skill: `skills/flujo-tdd/`

package/vendor/theus-arsenal/commands/test-kotlin.md

@@ -1,312 +0,0 @@
----
-description: Aplica el flujo TDD para Kotlin. Escribe primero tests con Kotest, luego implementa. Verifica cobertura de 80%+ con Kover.
----
-
-# Comando TDD para Kotlin
-
-Este comando aplica la metodología de desarrollo guiado por tests (TDD) para código Kotlin usando Kotest, MockK y Kover.
-
-## Qué hace este comando
-
-1. **Define tipos e interfaces**: primero el andamiaje de firmas de funciones
-2. **Escribe tests con Kotest**: crea especificaciones de prueba exhaustivas (ROJO)
-3. **Ejecuta los tests**: verifica que fallen por la razón correcta
-4. **Implementa el código**: escribe el mínimo código para pasar (VERDE)
-5. **Refactoriza**: mejora manteniendo los tests en verde
-6. **Comprueba la cobertura**: asegura 80%+ de cobertura con Kover
-
-## Cuándo usarlo
-
-Usa `/test-kotlin` cuando:
-- Implementes funciones o clases nuevas en Kotlin
-- Añadas cobertura de tests a código Kotlin existente
-- Corrijas bugs (escribe primero el test que falla)
-- Construyas lógica de negocio crítica
-- Estés aprendiendo el flujo TDD en Kotlin
-
-## Ciclo TDD
-
-```
-ROJO       -> Escribe un test Kotest que falle
-VERDE      -> Implementa el mínimo código para pasar
-REFACTOR   -> Mejora el código, los tests siguen en verde
-REPITE     -> Siguiente caso de prueba
-```
-
-## Sesión de ejemplo
-
-````text
-Usuario: /test-kotlin Necesito una función que valide solicitudes de registro de usuarios
-
-Agente:
-# Sesión TDD: Validador de registro
-
-## Paso 1: Definir la interfaz
-
-```kotlin
-// validator/RegistrationValidator.kt
-package com.example.validator
-
-data class RegistrationRequest(
-    val name: String,
-    val email: String,
-    val password: String,
-)
-
-sealed class ValidationResult {
-    data object Valid : ValidationResult()
-    data class Invalid(val errors: List<String>) : ValidationResult()
-}
-
-fun validateRegistration(request: RegistrationRequest): ValidationResult {
-    TODO("sin implementar")
-}
-```
-
-## Paso 2: Escribir los tests Kotest (ROJO)
-
-```kotlin
-// validator/RegistrationValidatorTest.kt
-package com.example.validator
-
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.kotest.matchers.types.shouldBeInstanceOf
-
-class RegistrationValidatorTest : FunSpec({
-    test("un registro válido devuelve Valid") {
-        val request = RegistrationRequest(
-            name = "Alicia",
-            email = "alicia@example.com",
-            password = "ClaveSegur@1",
-        )
-
-        val result = validateRegistration(request)
-
-        result.shouldBeInstanceOf<ValidationResult.Valid>()
-    }
-
-    test("un nombre en blanco devuelve Invalid") {
-        val request = RegistrationRequest(
-            name = "",
-            email = "alicia@example.com",
-            password = "ClaveSegur@1",
-        )
-
-        val result = validateRegistration(request)
-
-        val invalid = result.shouldBeInstanceOf<ValidationResult.Invalid>()
-        invalid.errors shouldBe listOf("El nombre es obligatorio")
-    }
-
-    test("un email inválido devuelve Invalid") {
-        val request = RegistrationRequest(
-            name = "Alicia",
-            email = "no-es-un-email",
-            password = "ClaveSegur@1",
-        )
-
-        val result = validateRegistration(request)
-
-        val invalid = result.shouldBeInstanceOf<ValidationResult.Invalid>()
-        invalid.errors shouldBe listOf("Formato de email inválido")
-    }
-
-    test("una contraseña corta devuelve Invalid") {
-        val request = RegistrationRequest(
-            name = "Alicia",
-            email = "alicia@example.com",
-            password = "corta",
-        )
-
-        val result = validateRegistration(request)
-
-        val invalid = result.shouldBeInstanceOf<ValidationResult.Invalid>()
-        invalid.errors shouldBe listOf("La contraseña debe tener al menos 8 caracteres")
-    }
-
-    test("varios errores devuelve todos los errores") {
-        val request = RegistrationRequest(
-            name = "",
-            email = "malo",
-            password = "corta",
-        )
-
-        val result = validateRegistration(request)
-
-        val invalid = result.shouldBeInstanceOf<ValidationResult.Invalid>()
-        invalid.errors.size shouldBe 3
-    }
-})
-```
-
-## Paso 3: Ejecutar los tests — verificar que FALLAN
-
-```bash
-$ ./gradlew test
-
-RegistrationValidatorTest > un registro válido devuelve Valid FAILED
-  kotlin.NotImplementedError: An operation is not implemented
-
-FAILED (5 tests, 0 passed, 5 failed)
-```
-
-✓ Los tests fallan como se esperaba (NotImplementedError).
-
-## Paso 4: Implementar el mínimo código (VERDE)
-
-```kotlin
-// validator/RegistrationValidator.kt
-package com.example.validator
-
-private val EMAIL_REGEX = Regex("^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$")
-private const val MIN_PASSWORD_LENGTH = 8
-
-fun validateRegistration(request: RegistrationRequest): ValidationResult {
-    val errors = buildList {
-        if (request.name.isBlank()) add("El nombre es obligatorio")
-        if (!EMAIL_REGEX.matches(request.email)) add("Formato de email inválido")
-        if (request.password.length < MIN_PASSWORD_LENGTH) add("La contraseña debe tener al menos $MIN_PASSWORD_LENGTH caracteres")
-    }
-
-    return if (errors.isEmpty()) ValidationResult.Valid
-    else ValidationResult.Invalid(errors)
-}
-```
-
-## Paso 5: Ejecutar los tests — verificar que PASAN
-
-```bash
-$ ./gradlew test
-
-RegistrationValidatorTest > un registro válido devuelve Valid PASSED
-RegistrationValidatorTest > un nombre en blanco devuelve Invalid PASSED
-RegistrationValidatorTest > un email inválido devuelve Invalid PASSED
-RegistrationValidatorTest > una contraseña corta devuelve Invalid PASSED
-RegistrationValidatorTest > varios errores devuelve todos los errores PASSED
-
-PASSED (5 tests, 5 passed, 0 failed)
-```
-
-✓ ¡Todos los tests pasan!
-
-## Paso 6: Comprobar la cobertura
-
-```bash
-$ ./gradlew koverHtmlReport
-
-Coverage: 100.0% of statements
-```
-
-✓ Cobertura: 100%
-
-## ¡TDD completado!
-````
-
-## Patrones de test
-
-### StringSpec (el más simple)
-
-```kotlin
-class CalculatorTest : StringSpec({
-    "suma dos números positivos" {
-        Calculator.add(2, 3) shouldBe 5
-    }
-})
-```
-
-### BehaviorSpec (BDD)
-
-```kotlin
-class OrderServiceTest : BehaviorSpec({
-    Given("un pedido válido") {
-        When("se realiza") {
-            Then("debe quedar confirmado") { /* ... */ }
-        }
-    }
-})
-```
-
-### Tests dirigidos por datos
-
-```kotlin
-class ParserTest : FunSpec({
-    context("entradas válidas") {
-        withData("2026-01-15", "2026-12-31", "2000-01-01") { input ->
-            parseDate(input).shouldNotBeNull()
-        }
-    }
-})
-```
-
-### Testing de corrutinas
-
-```kotlin
-class AsyncServiceTest : FunSpec({
-    test("la carga concurrente termina") {
-        runTest {
-            val result = service.fetchAll()
-            result.shouldNotBeEmpty()
-        }
-    }
-})
-```
-
-## Comandos de cobertura
-
-```bash
-# Ejecutar tests con cobertura
-./gradlew koverHtmlReport
-
-# Verificar umbrales de cobertura
-./gradlew koverVerify
-
-# Informe XML para CI
-./gradlew koverXmlReport
-
-# Abrir el informe HTML
-open build/reports/kover/html/index.html
-
-# Ejecutar una clase de test concreta
-./gradlew test --tests "com.example.UserServiceTest"
-
-# Ejecutar con salida detallada
-./gradlew test --info
-```
-
-## Objetivos de cobertura
-
-| Tipo de código | Objetivo |
-|----------------|----------|
-| Lógica de negocio crítica | 100% |
-| APIs públicas | 90%+ |
-| Código general | 80%+ |
-| Código generado | Excluir |
-
-## Buenas prácticas de TDD
-
-**SÍ:**
-- Escribe el test PRIMERO, antes de cualquier implementación
-- Ejecuta los tests después de cada cambio
-- Usa los matchers de Kotest para aserciones expresivas
-- Usa `coEvery`/`coVerify` de MockK para funciones suspend
-- Testea comportamiento, no detalles de implementación
-- Incluye casos límite (vacío, null, valores máximos)
-
-**NO:**
-- Escribas la implementación antes que los tests
-- Te saltes la fase ROJA
-- Testees funciones privadas directamente
-- Uses `Thread.sleep()` en tests de corrutinas
-- Ignores tests inestables (flaky)
-
-## Comandos relacionados
-
-- `/build-kotlin` — corregir errores de build
-- `/revisar-kotlin` — revisar el código tras implementar
-- Skill `bucle-verificacion` — ejecutar el bucle completo de verificación
-
-## Relacionados
-
-- Skill: `skills/testing-kotlin/`
-- Skill: `skills/flujo-tdd/`