theus-cli-linux-arm64 0.2.84

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

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

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

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