theus-cli-darwin-x64 0.2.84

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

@@ -0,0 +1,148 @@
+---
+description: Revisión integral de código Go en busca de patrones idiomáticos, seguridad en concurrencia, manejo de errores y vulnerabilidades. Invoca al agente revisor-go.
+---
+
+# Revisión de código Go
+
+Este comando invoca al agente **revisor-go** para una revisión integral específica de Go.
+
+## Qué hace este comando
+
+1. **Identifica los cambios en Go**: encuentra los archivos `.go` modificados vía `git diff`
+2. **Ejecuta análisis estático**: corre `go vet`, `staticcheck` y `golangci-lint`
+3. **Escaneo de seguridad**: busca inyección SQL, inyección de comandos y condiciones de carrera
+4. **Revisión de concurrencia**: analiza la seguridad de goroutines, el uso de canales y los patrones de mutex
+5. **Verificación de Go idiomático**: comprueba que el código siga las convenciones y buenas prácticas de Go
+6. **Genera un informe**: clasifica los problemas por severidad
+
+## Cuándo usarlo
+
+Usa /revisar-go cuando:
+- Acabas de escribir o modificar código Go
+- Antes de commitear cambios en Go
+- Revisas pull requests con código Go
+- Te incorporas a un codebase Go nuevo
+- Estás aprendiendo patrones idiomáticos de Go
+
+## Categorías de revisión
+
+### CRÍTICO (corrección obligatoria)
+- Vulnerabilidades de inyección SQL o de comandos
+- Condiciones de carrera sin sincronización
+- Fugas de goroutines
+- Credenciales hardcodeadas
+- Uso inseguro de punteros
+- Errores ignorados en rutas críticas
+
+### ALTO (debería corregirse)
+- Falta envolver errores con contexto
+- Panic en lugar de retornar errores
+- Context no propagado
+- Canales sin buffer que causan deadlocks
+- Errores de interfaz no satisfecha
+- Falta protección con mutex
+
+### MEDIO (a considerar)
+- Patrones de código no idiomáticos
+- Faltan comentarios godoc en símbolos exportados
+- Concatenación de strings ineficiente
+- Slices sin preasignar
+- No se usan tests tabulares
+
+## Verificaciones automatizadas ejecutadas
+
+```bash
+# Análisis estático
+go vet ./...
+
+# Verificaciones avanzadas (si están instaladas)
+staticcheck ./...
+golangci-lint run
+
+# Detección de carreras
+go build -race ./...
+
+# Vulnerabilidades de seguridad
+govulncheck ./...
+```
+
+## Ejemplo de uso
+
+```text
+Usuario: /revisar-go
+
+Agente:
+# Informe de revisión de código Go
+
+## Archivos revisados
+- internal/handler/user.go (modificado)
+- internal/service/auth.go (modificado)
+
+## Resultados del análisis estático
+✓ go vet: sin problemas
+✓ staticcheck: sin problemas
+
+## Problemas encontrados
+
+[CRÍTICO] Condición de carrera
+Archivo: internal/service/auth.go:45
+Problema: mapa compartido accedido sin sincronización
+```go
+var cache = map[string]*Session{}  // ¡Acceso concurrente!
+
+func GetSession(id string) *Session {
+    return cache[id]  // Condición de carrera
+}
+```
+Arreglo: usar sync.RWMutex o sync.Map
+```go
+var (
+    cache   = map[string]*Session{}
+    cacheMu sync.RWMutex
+)
+
+func GetSession(id string) *Session {
+    cacheMu.RLock()
+    defer cacheMu.RUnlock()
+    return cache[id]
+}
+```
+
+[ALTO] Falta contexto en el error
+Archivo: internal/handler/user.go:28
+Problema: error retornado sin contexto
+```go
+return err  // Sin contexto
+```
+Arreglo: envolver con contexto
+```go
+return fmt.Errorf("get user %s: %w", userID, err)
+```
+
+## Resumen
+- CRÍTICO: 1
+- ALTO: 1
+- MEDIO: 0
+
+Recomendación: RECHAZADO: bloquear el merge hasta corregir el problema CRÍTICO
+```
+
+## Criterios de aprobación
+
+| Estado | Condición |
+|--------|-----------|
+| APROBADO: aprobar | Sin problemas CRÍTICOS ni ALTOS |
+| ADVERTENCIA: precaución | Solo problemas MEDIOS (mergear con cautela) |
+| RECHAZADO: bloquear | Se encontraron problemas CRÍTICOS o ALTOS |
+
+## Integración con otros comandos
+
+- Usa /test-go primero para asegurar que los tests pasen
+- Usa /build-go si hay errores de build
+- Usa /revisar-go antes de commitear
+- Usa /revisar-codigo para aspectos no específicos de Go
+
+## Relacionados
+
+- Agente: `agents/revisor-go.md`
+- Skills: `skills/patrones-go/`, `skills/testing-go/`

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

@@ -0,0 +1,140 @@
+---
+description: Revisión integral de código Kotlin orientada a patrones idiomáticos, null safety, seguridad de corrutinas y seguridad. Invoca al agente revisor-kotlin.
+---
+
+# Revisión de código Kotlin
+
+Este comando invoca al agente **revisor-kotlin** para una revisión integral específica de Kotlin.
+
+## Qué hace este comando
+
+1. **Identifica cambios de Kotlin**: encuentra archivos `.kt` y `.kts` modificados vía `git diff`
+2. **Ejecuta build y análisis estático**: corre `./gradlew build`, `detekt`, `ktlintCheck`
+3. **Escaneo de seguridad**: busca inyección SQL, inyección de comandos, secretos hardcodeados
+4. **Revisión de null safety**: analiza el uso de `!!`, manejo de tipos de plataforma, casts inseguros
+5. **Revisión de corrutinas**: comprueba concurrencia estructurada, uso de dispatchers, cancelación
+6. **Genera un informe**: categoriza los hallazgos por severidad
+
+## Cuándo usarlo
+
+Usa `/revisar-kotlin` cuando:
+- Acabas de escribir o modificar código Kotlin
+- Antes de hacer commit de cambios en Kotlin
+- Al revisar pull requests con código Kotlin
+- Al incorporarte a un código base Kotlin nuevo
+- Estás aprendiendo patrones idiomáticos de Kotlin
+
+## Categorías de revisión
+
+### CRÍTICO (obligatorio corregir)
+- Vulnerabilidades de inyección SQL/de comandos
+- Desempaquetado forzado `!!` sin justificación
+- Violaciones de null safety en tipos de plataforma
+- Uso de GlobalScope (violación de concurrencia estructurada)
+- Credenciales hardcodeadas
+- Deserialización insegura
+
+### ALTO (debería corregirse)
+- Estado mutable donde basta con inmutable
+- Llamadas bloqueantes dentro de un contexto de corrutina
+- Falta de chequeos de cancelación en bucles largos
+- `when` no exhaustivo sobre tipos sellados
+- Funciones grandes (>50 líneas)
+- Anidamiento profundo (>4 niveles)
+
+### MEDIO (a considerar)
+- Kotlin no idiomático (patrones estilo Java)
+- Falta de comas finales
+- Mal uso o anidamiento de funciones de alcance (scope functions)
+- Falta de secuencias en cadenas largas sobre colecciones grandes
+- Tipos explícitos redundantes
+
+## Chequeos automáticos ejecutados
+
+```bash
+# Chequeo de build
+./gradlew build
+
+# Análisis estático
+./gradlew detekt
+
+# Chequeo de formato
+./gradlew ktlintCheck
+
+# Tests
+./gradlew test
+```
+
+## Ejemplo de uso
+
+````text
+Usuario: /revisar-kotlin
+
+Agente:
+# Informe de revisión de código Kotlin
+
+## Archivos revisados
+- src/main/kotlin/com/example/service/UserService.kt (modificado)
+- src/main/kotlin/com/example/routes/UserRoutes.kt (modificado)
+
+## Resultados del análisis estático
+✓ Build: exitoso
+✓ detekt: sin hallazgos
+WARNING: ktlint: 2 advertencias de formato
+
+## Hallazgos
+
+[CRÍTICO] Desempaquetado forzado (null safety)
+Archivo: src/main/kotlin/com/example/service/UserService.kt:28
+Problema: uso de !! sobre un resultado anulable del repositorio
+```kotlin
+val user = repository.findById(id)!!  // Riesgo de NPE
+```
+Arreglo: usar llamada segura con manejo de errores
+```kotlin
+val user = repository.findById(id)
+    ?: throw UserNotFoundException("Usuario $id no encontrado")
+```
+
+[ALTO] Uso de GlobalScope
+Archivo: src/main/kotlin/com/example/routes/UserRoutes.kt:45
+Problema: GlobalScope rompe la concurrencia estructurada
+```kotlin
+GlobalScope.launch {
+    notificationService.sendWelcome(user)
+}
+```
+Arreglo: usar el scope de corrutina de la llamada
+```kotlin
+launch {
+    notificationService.sendWelcome(user)
+}
+```
+
+## Resumen
+- CRÍTICO: 1
+- ALTO: 1
+- MEDIO: 0
+
+Recomendación: FAIL: Bloquear el merge hasta corregir el hallazgo CRÍTICO
+````
+
+## Criterios de aprobación
+
+| Estado | Condición |
+|--------|-----------|
+| PASS: Aprobar | Sin hallazgos CRÍTICOS ni ALTOS |
+| WARNING: Advertencia | Solo hallazgos MEDIOS (merge con cautela) |
+| FAIL: Bloquear | Hay hallazgos CRÍTICOS o ALTOS |
+
+## Integración con otros comandos
+
+- Usa `/test-kotlin` primero para asegurar que los tests pasan
+- Usa `/build-kotlin` si aparecen errores de build
+- Usa `/revisar-kotlin` antes de hacer commit
+- Usa `/revisar-codigo` para aspectos no específicos de Kotlin
+
+## Relacionados
+
+- Agente: `agents/revisor-kotlin.md`
+- Skills: `skills/patrones-kotlin/`, `skills/testing-kotlin/`

package/vendor/theus-arsenal/commands/revisar-pr.md

@@ -0,0 +1,37 @@
+---
+description: Revisión integral de un PR usando agentes especializados
+---
+
+Ejecuta una revisión integral y multiperspectiva de un pull request.
+
+## Uso
+
+`/revisar-pr [número-de-PR-o-URL] [--focus=comments|tests|errors|types|code|simplify]`
+
+Si no se especifica un PR, revisa el PR de la rama actual. Si no se especifica un foco, ejecuta la pila completa de revisión.
+
+## Pasos
+
+1. Identificar el PR:
+   - usa `gh pr view` para obtener los detalles del PR, los archivos modificados y el diff
+2. Buscar las guías del proyecto:
+   - busca `THEUS.md`, la configuración del linter, la configuración de TypeScript y las convenciones del repositorio
+3. Ejecutar los agentes de revisión especializados:
+   - `revisor-codigo`
+   - `analista-comentarios`
+   - `analista-tests-pr`
+   - `cazador-fallos-silenciosos`
+   - `analista-tipos`
+   - `simplificador-codigo`
+4. Agregar los resultados:
+   - deduplica los hallazgos que se solapan
+   - ordénalos por severidad
+5. Reportar los hallazgos agrupados por severidad
+
+## Regla de confianza
+
+Reporta solo problemas con confianza >= 80:
+
+- Crítico: bugs, seguridad, pérdida de datos
+- Importante: tests faltantes, problemas de calidad, violaciones de estilo
+- Consultivo: sugerencias solo cuando se soliciten explícitamente

package/vendor/theus-arsenal/commands/revisar-python.md

@@ -0,0 +1,297 @@
+---
+description: "Revisión integral de código Python: cumplimiento de PEP 8, type hints, seguridad e idiomas pythónicos. Invoca al agente revisor-python."
+---
+
+# Revisión de código Python
+
+Este comando invoca al agente **revisor-python** para una revisión integral específica de Python.
+
+## Qué hace este comando
+
+1. **Identificar cambios en Python**: encontrar los archivos `.py` modificados vía `git diff`
+2. **Ejecutar análisis estático**: correr `ruff`, `mypy`, `pylint`, `black --check`
+3. **Escaneo de seguridad**: buscar inyección SQL, inyección de comandos, deserialización insegura
+4. **Revisión de seguridad de tipos**: analizar los type hints y los errores de mypy
+5. **Verificación de código pythónico**: comprobar que el código sigue PEP 8 y las buenas prácticas de Python
+6. **Generar reporte**: categorizar los problemas por severidad
+
+## Cuándo usarlo
+
+Usa `/revisar-python` cuando:
+- Acabes de escribir o modificar código Python
+- Antes de commitear cambios en Python
+- Revises pull requests con código Python
+- Te incorpores a un código Python nuevo
+- Estés aprendiendo patrones e idiomas pythónicos
+
+## Categorías de revisión
+
+### CRÍTICO (obligatorio corregir)
+- Vulnerabilidades de inyección SQL/de comandos
+- Uso inseguro de eval/exec
+- Deserialización insegura con pickle
+- Credenciales hardcodeadas
+- Carga insegura de YAML
+- Cláusulas `except` desnudas que ocultan errores
+
+### ALTO (debería corregirse)
+- Type hints ausentes en funciones públicas
+- Argumentos por defecto mutables
+- Excepciones tragadas silenciosamente
+- No usar context managers para recursos
+- Bucles al estilo C en vez de comprensiones
+- Usar type() en lugar de isinstance()
+- Condiciones de carrera sin locks
+
+### MEDIO (a considerar)
+- Violaciones de formato PEP 8
+- Docstrings ausentes en funciones públicas
+- Sentencias print en lugar de logging
+- Operaciones de strings ineficientes
+- Números mágicos sin constantes con nombre
+- No usar f-strings para formatear
+- Creación innecesaria de listas
+
+## Verificaciones automatizadas que se ejecutan
+
+```bash
+# Verificación de tipos
+mypy .
+
+# Linting y formato
+ruff check .
+black --check .
+isort --check-only .
+
+# Escaneo de seguridad
+bandit -r .
+
+# Auditoría de dependencias
+pip-audit
+safety check
+
+# Tests
+pytest --cov=app --cov-report=term-missing
+```
+
+## Ejemplo de uso
+
+```text
+Usuario: /revisar-python
+
+Agente:
+# Reporte de revisión de código Python
+
+## Archivos revisados
+- app/routes/user.py (modificado)
+- app/services/auth.py (modificado)
+
+## Resultados del análisis estático
+✓ ruff: sin problemas
+✓ mypy: sin errores
+ADVERTENCIA: black: 2 archivos requieren reformateo
+✓ bandit: sin problemas de seguridad
+
+## Problemas encontrados
+
+[CRÍTICO] Vulnerabilidad de inyección SQL
+Archivo: app/routes/user.py:42
+Problema: entrada del usuario interpolada directamente en la consulta SQL
+```python
+query = f"SELECT * FROM users WHERE id = {user_id}"  # Mal
+```
+Corrección: usar una consulta parametrizada
+```python
+query = "SELECT * FROM users WHERE id = %s"  # Bien
+cursor.execute(query, (user_id,))
+```
+
+[ALTO] Argumento por defecto mutable
+Archivo: app/services/auth.py:18
+Problema: un argumento por defecto mutable provoca estado compartido
+```python
+def process_items(items=[]):  # Mal
+    items.append("new")
+    return items
+```
+Corrección: usar None como valor por defecto
+```python
+def process_items(items=None):  # Bien
+    if items is None:
+        items = []
+    items.append("new")
+    return items
+```
+
+[MEDIO] Type hints ausentes
+Archivo: app/services/auth.py:25
+Problema: función pública sin anotaciones de tipo
+```python
+def get_user(user_id):  # Mal
+    return db.find(user_id)
+```
+Corrección: añadir type hints
+```python
+def get_user(user_id: str) -> Optional[User]:  # Bien
+    return db.find(user_id)
+```
+
+[MEDIO] No se usa context manager
+Archivo: app/routes/user.py:55
+Problema: el archivo no se cierra si hay una excepción
+```python
+f = open("config.json")  # Mal
+data = f.read()
+f.close()
+```
+Corrección: usar un context manager
+```python
+with open("config.json") as f:  # Bien
+    data = f.read()
+```
+
+## Resumen
+- CRÍTICO: 1
+- ALTO: 1
+- MEDIO: 2
+
+Recomendación: FALLA — bloquear el merge hasta corregir el problema CRÍTICO
+
+## Formateo requerido
+Ejecutar: `black app/routes/user.py app/services/auth.py`
+```
+
+## Criterios de aprobación
+
+| Estado | Condición |
+|--------|-----------|
+| PASA: aprobar | Sin problemas CRÍTICOS ni ALTOS |
+| ADVERTENCIA | Solo problemas MEDIOS (merge con cautela) |
+| FALLA: bloquear | Se encontraron problemas CRÍTICOS o ALTOS |
+
+## Integración con otros comandos
+
+- Usa primero la skill `flujo-tdd` para asegurar que los tests pasan
+- Usa el agente `revisor-codigo` para aspectos no específicos de Python
+- Usa `/revisar-python` antes de commitear
+- Usa `/arreglar-build` si las herramientas de análisis estático fallan
+
+## Revisiones específicas por framework
+
+### Proyectos Django
+El revisor verifica:
+- Problemas de consultas N+1 (usar `select_related` y `prefetch_related`)
+- Migraciones ausentes tras cambios en los modelos
+- Uso de SQL crudo cuando el ORM bastaría
+- Falta de `transaction.atomic()` en operaciones de varios pasos
+
+### Proyectos FastAPI
+El revisor verifica:
+- Configuración incorrecta de CORS
+- Modelos Pydantic para validar las peticiones
+- Corrección de los modelos de respuesta
+- Uso apropiado de async/await
+- Patrones de inyección de dependencias
+
+### Proyectos Flask
+El revisor verifica:
+- Gestión de contextos (contexto de aplicación, contexto de petición)
+- Manejo de errores apropiado
+- Organización de blueprints
+- Gestión de la configuración
+
+## Relacionado
+
+- Agente: `agents/revisor-python.md`
+- Skills: `skills/patrones-python/`, `skills/testing-python/`
+
+## Correcciones habituales
+
+### Añadir type hints
+```python
+# Antes
+def calculate(x, y):
+    return x + y
+
+# Después
+from typing import Union
+
+def calculate(x: Union[int, float], y: Union[int, float]) -> Union[int, float]:
+    return x + y
+```
+
+### Usar context managers
+```python
+# Antes
+f = open("file.txt")
+data = f.read()
+f.close()
+
+# Después
+with open("file.txt") as f:
+    data = f.read()
+```
+
+### Usar comprensiones de listas
+```python
+# Antes
+result = []
+for item in items:
+    if item.active:
+        result.append(item.name)
+
+# Después
+result = [item.name for item in items if item.active]
+```
+
+### Corregir argumentos por defecto mutables
+```python
+# Antes
+def append(value, items=[]):
+    items.append(value)
+    return items
+
+# Después
+def append(value, items=None):
+    if items is None:
+        items = []
+    items.append(value)
+    return items
+```
+
+### Usar f-strings (Python 3.6+)
+```python
+# Antes
+name = "Alice"
+greeting = "Hello, " + name + "!"
+greeting2 = "Hello, {}".format(name)
+
+# Después
+greeting = f"Hello, {name}!"
+```
+
+### Corregir la concatenación de strings en bucles
+```python
+# Antes
+result = ""
+for item in items:
+    result += str(item)
+
+# Después
+result = "".join(str(item) for item in items)
+```
+
+## Compatibilidad de versiones de Python
+
+El revisor señala cuándo el código usa funcionalidades de versiones más recientes de Python:
+
+| Funcionalidad | Python mínimo |
+|---------|----------------|
+| Type hints | 3.5+ |
+| f-strings | 3.6+ |
+| Operador walrus (`:=`) | 3.8+ |
+| Parámetros solo-posicionales | 3.8+ |
+| Sentencias match | 3.10+ |
+| Uniones de tipos (`x | None`) | 3.10+ |
+
+Asegúrate de que el `pyproject.toml` o `setup.py` de tu proyecto especifique la versión mínima de Python correcta.