theus-cli-darwin-x64 0.2.84

package/vendor/theus-arsenal/rules/rust/patterns.md

@@ -0,0 +1,168 @@
+---
+paths:
+  - "**/*.rs"
+---
+# Patrones de Rust
+
+> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de Rust.
+
+## Patrón Repository con traits
+
+Encapsula el acceso a datos detrás de un trait:
+
+```rust
+pub trait OrderRepository: Send + Sync {
+    fn find_by_id(&self, id: u64) -> Result<Option<Order>, StorageError>;
+    fn find_all(&self) -> Result<Vec<Order>, StorageError>;
+    fn save(&self, order: &Order) -> Result<Order, StorageError>;
+    fn delete(&self, id: u64) -> Result<(), StorageError>;
+}
+```
+
+Las implementaciones concretas manejan los detalles de almacenamiento (Postgres, SQLite, en memoria para tests).
+
+## Capa de servicios
+
+Lógica de negocio en structs de servicio; inyecta las dependencias vía constructor:
+
+```rust
+pub struct OrderService {
+    repo: Box<dyn OrderRepository>,
+    payment: Box<dyn PaymentGateway>,
+}
+
+impl OrderService {
+    pub fn new(repo: Box<dyn OrderRepository>, payment: Box<dyn PaymentGateway>) -> Self {
+        Self { repo, payment }
+    }
+
+    pub fn place_order(&self, request: CreateOrderRequest) -> anyhow::Result<OrderSummary> {
+        let order = Order::from(request);
+        self.payment.charge(order.total())?;
+        let saved = self.repo.save(&order)?;
+        Ok(OrderSummary::from(saved))
+    }
+}
+```
+
+## Patrón newtype para seguridad de tipos
+
+Evita confusiones de argumentos con tipos envolventes distintos:
+
+```rust
+struct UserId(u64);
+struct OrderId(u64);
+
+fn get_order(user: UserId, order: OrderId) -> anyhow::Result<Order> {
+    // Imposible intercambiar por accidente los IDs de usuario y pedido al llamar
+    todo!()
+}
+```
+
+## Máquinas de estados con enums
+
+Modela los estados como enums — haz que los estados ilegales sean irrepresentables:
+
+```rust
+enum ConnectionState {
+    Disconnected,
+    Connecting { attempt: u32 },
+    Connected { session_id: String },
+    Failed { reason: String, retries: u32 },
+}
+
+fn handle(state: &ConnectionState) {
+    match state {
+        ConnectionState::Disconnected => connect(),
+        ConnectionState::Connecting { attempt } if *attempt > 3 => abort(),
+        ConnectionState::Connecting { .. } => wait(),
+        ConnectionState::Connected { session_id } => use_session(session_id),
+        ConnectionState::Failed { retries, .. } if *retries < 5 => retry(),
+        ConnectionState::Failed { reason, .. } => log_failure(reason),
+    }
+}
+```
+
+Haz siempre match exhaustivo — nada de comodín `_` en enums críticos para el negocio.
+
+## Patrón Builder
+
+Úsalo para structs con muchos parámetros opcionales:
+
+```rust
+pub struct ServerConfig {
+    host: String,
+    port: u16,
+    max_connections: usize,
+}
+
+impl ServerConfig {
+    pub fn builder(host: impl Into<String>, port: u16) -> ServerConfigBuilder {
+        ServerConfigBuilder {
+            host: host.into(),
+            port,
+            max_connections: 100,
+        }
+    }
+}
+
+pub struct ServerConfigBuilder {
+    host: String,
+    port: u16,
+    max_connections: usize,
+}
+
+impl ServerConfigBuilder {
+    pub fn max_connections(mut self, n: usize) -> Self {
+        self.max_connections = n;
+        self
+    }
+
+    pub fn build(self) -> ServerConfig {
+        ServerConfig {
+            host: self.host,
+            port: self.port,
+            max_connections: self.max_connections,
+        }
+    }
+}
+```
+
+## Traits sellados para controlar la extensibilidad
+
+Usa un módulo privado para sellar un trait e impedir implementaciones externas:
+
+```rust
+mod private {
+    pub trait Sealed {}
+}
+
+pub trait Format: private::Sealed {
+    fn encode(&self, data: &[u8]) -> Vec<u8>;
+}
+
+pub struct Json;
+impl private::Sealed for Json {}
+impl Format for Json {
+    fn encode(&self, data: &[u8]) -> Vec<u8> { todo!() }
+}
+```
+
+## Sobre de respuesta de API
+
+Respuestas de API consistentes usando un enum genérico:
+
+```rust
+#[derive(Debug, serde::Serialize)]
+#[serde(tag = "status")]
+pub enum ApiResponse<T: serde::Serialize> {
+    #[serde(rename = "ok")]
+    Ok { data: T },
+    #[serde(rename = "error")]
+    Error { message: String },
+}
+```
+
+## Referencias
+
+Ver skill: `patrones-rust` para patrones en profundidad, incluyendo ownership, traits, genéricos, concurrencia y async.

package/vendor/theus-arsenal/rules/rust/security.md

@@ -0,0 +1,141 @@
+---
+paths:
+  - "**/*.rs"
+---
+# Seguridad en Rust
+
+> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de Rust.
+
+## Gestión de secretos
+
+- Nunca escribas claves de API, tokens ni credenciales directamente en el código fuente
+- Usa variables de entorno: `std::env::var("API_KEY")`
+- Falla rápido en el arranque si faltan secretos requeridos
+- Mantén los archivos `.env` en `.gitignore`
+
+```rust
+// MAL
+const API_KEY: &str = "sk-abc123...";
+
+// BIEN — variable de entorno con validación temprana
+fn load_api_key() -> anyhow::Result<String> {
+    std::env::var("PAYMENT_API_KEY")
+        .context("PAYMENT_API_KEY debe estar definida")
+}
+```
+
+## Prevención de inyección SQL
+
+- Usa siempre consultas parametrizadas — nunca formatees entrada del usuario dentro de cadenas SQL
+- Usa un query builder u ORM (sqlx, diesel, sea-orm) con parámetros bind
+
+```rust
+// MAL — inyección SQL vía format string
+let query = format!("SELECT * FROM users WHERE name = '{name}'");
+sqlx::query(&query).fetch_one(&pool).await?;
+
+// BIEN — consulta parametrizada con sqlx
+// La sintaxis del placeholder varía según el backend: Postgres: $1  |  MySQL: ?  |  SQLite: $1
+sqlx::query("SELECT * FROM users WHERE name = $1")
+    .bind(&name)
+    .fetch_one(&pool)
+    .await?;
+```
+
+## Validación de entradas
+
+- Valida toda entrada del usuario en las fronteras del sistema antes de procesarla
+- Usa el sistema de tipos para hacer cumplir invariantes (patrón newtype)
+- Parsea, no valides — convierte datos sin estructura a structs tipados en la frontera
+- Rechaza la entrada inválida con mensajes de error claros
+
+```rust
+// Parsea, no valides — los estados inválidos son irrepresentables
+pub struct Email(String);
+
+impl Email {
+    pub fn parse(input: &str) -> Result<Self, ValidationError> {
+        let trimmed = input.trim();
+        let at_pos = trimmed.find('@')
+            .filter(|&p| p > 0 && p < trimmed.len() - 1)
+            .ok_or_else(|| ValidationError::InvalidEmail(input.to_string()))?;
+        let domain = &trimmed[at_pos + 1..];
+        if trimmed.len() > 254 || !domain.contains('.') {
+            return Err(ValidationError::InvalidEmail(input.to_string()));
+        }
+        // Para producción, prefiere un crate de email validado (p. ej. `email_address`)
+        Ok(Self(trimmed.to_string()))
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+```
+
+## Código unsafe
+
+- Minimiza los bloques `unsafe` — prefiere abstracciones seguras
+- Todo bloque `unsafe` debe llevar un comentario `// SAFETY:` que explique el invariante
+- Nunca uses `unsafe` para saltarte el borrow checker por comodidad
+- Audita todo el código `unsafe` durante la revisión — sin justificación es una señal de alarma
+- Prefiere wrappers de FFI seguros alrededor de librerías C
+
+```rust
+// BIEN — el comentario de seguridad documenta TODOS los invariantes requeridos
+let widget: &Widget = {
+    // SAFETY: `ptr` no es nulo, está alineado, apunta a un Widget inicializado,
+    // y no existen referencias mutables ni mutaciones durante su lifetime.
+    unsafe { &*ptr }
+};
+
+// MAL — sin justificación de seguridad
+unsafe { &*ptr }
+```
+
+## Seguridad de dependencias
+
+- Ejecuta `cargo audit` para detectar CVEs conocidos en las dependencias
+- Ejecuta `cargo deny check` para cumplimiento de licencias y advisories
+- Usa `cargo tree` para auditar las dependencias transitivas
+- Mantén las dependencias actualizadas — configura Dependabot o Renovate
+- Minimiza la cantidad de dependencias — evalúa antes de añadir crates nuevos
+
+```bash
+# Auditoría de seguridad
+cargo audit
+
+# Rechazar advisories, versiones duplicadas y licencias restringidas
+cargo deny check
+
+# Inspeccionar el árbol de dependencias
+cargo tree
+cargo tree -d  # Mostrar solo duplicados
+```
+
+## Mensajes de error
+
+- Nunca expongas rutas internas, stack traces ni errores de base de datos en respuestas de API
+- Registra los errores detallados en el servidor; devuelve mensajes genéricos a los clientes
+- Usa `tracing` o `log` para logging estructurado del lado del servidor
+
+```rust
+// Mapea los errores a códigos de estado apropiados y mensajes genéricos
+// (El ejemplo usa axum; adapta el tipo de respuesta a tu framework)
+match order_service.find_by_id(id) {
+    Ok(order) => Ok((StatusCode::OK, Json(order))),
+    Err(ServiceError::NotFound(_)) => {
+        tracing::info!(order_id = id, "pedido no encontrado");
+        Err((StatusCode::NOT_FOUND, "Recurso no encontrado"))
+    }
+    Err(e) => {
+        tracing::error!(order_id = id, error = %e, "error inesperado");
+        Err((StatusCode::INTERNAL_SERVER_ERROR, "Error interno del servidor"))
+    }
+}
+```
+
+## Referencias
+
+Ver skill: `patrones-rust` para pautas de código unsafe y patrones de ownership.
+Ver skill: `revision-seguridad` para checklists de seguridad generales.

package/vendor/theus-arsenal/rules/rust/testing.md

@@ -0,0 +1,154 @@
+---
+paths:
+  - "**/*.rs"
+---
+# Testing en Rust
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de Rust.
+
+## Framework de tests
+
+- **`#[test]`** con módulos `#[cfg(test)]` para tests unitarios
+- **rstest** para tests parametrizados y fixtures
+- **proptest** para testing basado en propiedades
+- **mockall** para mocking basado en traits
+- **`#[tokio::test]`** para tests async
+
+## Organización de tests
+
+```text
+my_crate/
+├── src/
+│   ├── lib.rs           # Tests unitarios en módulos #[cfg(test)]
+│   ├── auth/
+│   │   └── mod.rs       # #[cfg(test)] mod tests { ... }
+│   └── orders/
+│       └── service.rs   # #[cfg(test)] mod tests { ... }
+├── tests/               # Tests de integración (cada archivo = binario separado)
+│   ├── api_test.rs
+│   ├── db_test.rs
+│   └── common/          # Utilidades de test compartidas
+│       └── mod.rs
+└── benches/             # Benchmarks con Criterion
+    └── benchmark.rs
+```
+
+Los tests unitarios van dentro de módulos `#[cfg(test)]` en el mismo archivo. Los tests de integración van en `tests/`.
+
+## Patrón de test unitario
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn creates_user_with_valid_email() {
+        let user = User::new("Alice", "alice@example.com").unwrap();
+        assert_eq!(user.name, "Alice");
+    }
+
+    #[test]
+    fn rejects_invalid_email() {
+        let result = User::new("Bob", "not-an-email");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("invalid email"));
+    }
+}
+```
+
+## Tests parametrizados
+
+```rust
+use rstest::rstest;
+
+#[rstest]
+#[case("hello", 5)]
+#[case("", 0)]
+#[case("rust", 4)]
+fn test_string_length(#[case] input: &str, #[case] expected: usize) {
+    assert_eq!(input.len(), expected);
+}
+```
+
+## Tests async
+
+```rust
+#[tokio::test]
+async fn fetches_data_successfully() {
+    let client = TestClient::new().await;
+    let result = client.get("/data").await;
+    assert!(result.is_ok());
+}
+```
+
+## Mocking con mockall
+
+Define los traits en el código de producción; genera los mocks en los módulos de test:
+
+```rust
+// Trait de producción — pub para que los tests de integración puedan importarlo
+pub trait UserRepository {
+    fn find_by_id(&self, id: u64) -> Option<User>;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mockall::predicate::eq;
+
+    mockall::mock! {
+        pub Repo {}
+        impl UserRepository for Repo {
+            fn find_by_id(&self, id: u64) -> Option<User>;
+        }
+    }
+
+    #[test]
+    fn service_returns_user_when_found() {
+        let mut mock = MockRepo::new();
+        mock.expect_find_by_id()
+            .with(eq(42))
+            .times(1)
+            .returning(|_| Some(User { id: 42, name: "Alice".into() }));
+
+        let service = UserService::new(Box::new(mock));
+        let user = service.get_user(42).unwrap();
+        assert_eq!(user.name, "Alice");
+    }
+}
+```
+
+## Nombres de tests
+
+Usa nombres descriptivos que expliquen el escenario:
+- `creates_user_with_valid_email()`
+- `rejects_order_when_insufficient_stock()`
+- `returns_none_when_not_found()`
+
+## Cobertura
+
+- Apunta a 80%+ de cobertura de líneas
+- Usa **cargo-llvm-cov** para los reportes de cobertura
+- Céntrate en la lógica de negocio — excluye código generado y bindings de FFI
+
+```bash
+cargo llvm-cov                       # Resumen
+cargo llvm-cov --html                # Reporte HTML
+cargo llvm-cov --fail-under-lines 80 # Falla si está por debajo del umbral
+```
+
+## Comandos de testing
+
+```bash
+cargo test                       # Ejecutar todos los tests
+cargo test -- --nocapture        # Mostrar la salida de println
+cargo test test_name             # Ejecutar tests que coincidan con el patrón
+cargo test --lib                 # Solo tests unitarios
+cargo test --test api_test       # Test de integración específico (tests/api_test.rs)
+cargo test --doc                 # Solo doc tests
+```
+
+## Referencias
+
+Ver skill: `testing-rust` para patrones de testing en profundidad, incluyendo testing basado en propiedades, fixtures y benchmarking con Criterion.

package/vendor/theus-arsenal/rules/swift/coding-style.md

@@ -0,0 +1,47 @@
+---
+paths:
+  - "**/*.swift"
+  - "**/Package.swift"
+---
+# Estilo de código Swift
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de Swift.
+
+## Formato
+
+- **SwiftFormat** para el autoformateo, **SwiftLint** para hacer cumplir el estilo
+- `swift-format` viene incluido con Xcode 16+ como alternativa
+
+## Inmutabilidad
+
+- Prefiere `let` sobre `var` — declara todo como `let` y cámbialo a `var` solo si el compilador lo exige
+- Usa `struct` con semántica de valor por defecto; usa `class` solo cuando se necesite identidad o semántica de referencia
+
+## Nomenclatura
+
+Sigue las [Apple API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/):
+
+- Claridad en el punto de uso — omite palabras innecesarias
+- Nombra métodos y propiedades por su rol, no por su tipo
+- Usa `static let` para constantes en lugar de constantes globales
+
+## Manejo de errores
+
+Usa typed throws (Swift 6+) y coincidencia de patrones:
+
+```swift
+func load(id: String) throws(LoadError) -> Item {
+    guard let data = try? read(from: path) else {
+        throw .fileNotFound(id)
+    }
+    return try decode(data)
+}
+```
+
+## Concurrencia
+
+Habilita la verificación estricta de concurrencia de Swift 6. Prefiere:
+
+- Tipos de valor `Sendable` para datos que cruzan fronteras de aislamiento
+- Actores para estado mutable compartido
+- Concurrencia estructurada (`async let`, `TaskGroup`) en lugar de `Task {}` sin estructura

package/vendor/theus-arsenal/rules/swift/hooks.md

@@ -0,0 +1,20 @@
+---
+paths:
+  - "**/*.swift"
+  - "**/Package.swift"
+---
+# Hooks para Swift
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de Swift.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **SwiftFormat**: autoformatear archivos `.swift` después de editarlos
+- **SwiftLint**: ejecutar el linter después de editar archivos `.swift`
+- **swift build**: verificar tipos de los paquetes modificados después de editar
+
+## Advertencia
+
+Advertir sobre sentencias `print()` — usa `os.Logger` o logging estructurado en código de producción.

package/vendor/theus-arsenal/rules/swift/patterns.md

@@ -0,0 +1,66 @@
+---
+paths:
+  - "**/*.swift"
+  - "**/Package.swift"
+---
+# Patrones de Swift
+
+> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de Swift.
+
+## Diseño orientado a protocolos
+
+Define protocolos pequeños y enfocados. Usa extensiones de protocolo para valores por defecto compartidos:
+
+```swift
+protocol Repository: Sendable {
+    associatedtype Item: Identifiable & Sendable
+    func find(by id: Item.ID) async throws -> Item?
+    func save(_ item: Item) async throws
+}
+```
+
+## Tipos de valor
+
+- Usa structs para objetos de transferencia de datos y modelos
+- Usa enums con valores asociados para modelar estados distintos:
+
+```swift
+enum LoadState<T: Sendable>: Sendable {
+    case idle
+    case loading
+    case loaded(T)
+    case failed(Error)
+}
+```
+
+## Patrón actor
+
+Usa actores para estado mutable compartido en lugar de locks o colas de dispatch:
+
+```swift
+actor Cache<Key: Hashable & Sendable, Value: Sendable> {
+    private var storage: [Key: Value] = [:]
+
+    func get(_ key: Key) -> Value? { storage[key] }
+    func set(_ key: Key, value: Value) { storage[key] = value }
+}
+```
+
+## Inyección de dependencias
+
+Inyecta protocolos con parámetros por defecto — producción usa los valores por defecto, los tests inyectan mocks:
+
+```swift
+struct UserService {
+    private let repository: any UserRepository
+
+    init(repository: any UserRepository = DefaultUserRepository()) {
+        self.repository = repository
+    }
+}
+```
+
+## Referencias
+
+Consulta la skill `persistencia-actores-swift` para patrones de persistencia basados en actores.
+Consulta la skill `testing-protocolos-di-swift` para inyección de dependencias basada en protocolos y testing.

package/vendor/theus-arsenal/rules/swift/security.md

@@ -0,0 +1,33 @@
+---
+paths:
+  - "**/*.swift"
+  - "**/Package.swift"
+---
+# Seguridad en Swift
+
+> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de Swift.
+
+## Gestión de secretos
+
+- Usa **Keychain Services** para datos sensibles (tokens, contraseñas, claves) — nunca `UserDefaults`
+- Usa variables de entorno o archivos `.xcconfig` para secretos en tiempo de build
+- Nunca incluyas secretos en el código fuente — las herramientas de descompilación los extraen trivialmente
+
+```swift
+let apiKey = ProcessInfo.processInfo.environment["API_KEY"]
+guard let apiKey, !apiKey.isEmpty else {
+    fatalError("API_KEY no configurada")
+}
+```
+
+## Seguridad de transporte
+
+- App Transport Security (ATS) se aplica por defecto — no lo desactives
+- Usa certificate pinning para los endpoints críticos
+- Valida todos los certificados del servidor
+
+## Validación de entrada
+
+- Sanitiza toda entrada del usuario antes de mostrarla para prevenir inyecciones
+- Usa `URL(string:)` con validación en lugar de force-unwrapping
+- Valida los datos de fuentes externas (APIs, deep links, portapapeles) antes de procesarlos

package/vendor/theus-arsenal/rules/swift/testing.md

@@ -0,0 +1,45 @@
+---
+paths:
+  - "**/*.swift"
+  - "**/Package.swift"
+---
+# Testing en Swift
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de Swift.
+
+## Framework
+
+Usa **Swift Testing** (`import Testing`) para los tests nuevos. Usa `@Test` y `#expect`:
+
+```swift
+@Test("La creación de usuario valida el email")
+func userCreationValidatesEmail() throws {
+    #expect(throws: ValidationError.invalidEmail) {
+        try User(email: "no-es-un-email")
+    }
+}
+```
+
+## Aislamiento de tests
+
+Cada test recibe una instancia nueva — prepara en `init`, limpia en `deinit`. Sin estado mutable compartido entre tests.
+
+## Tests parametrizados
+
+```swift
+@Test("Valida formatos", arguments: ["json", "xml", "csv"])
+func validatesFormat(format: String) throws {
+    let parser = try Parser(format: format)
+    #expect(parser.isValid)
+}
+```
+
+## Cobertura
+
+```bash
+swift test --enable-code-coverage
+```
+
+## Referencia
+
+Consulta la skill `testing-protocolos-di-swift` para inyección de dependencias basada en protocolos y patrones de mocks con Swift Testing.