theus-cli-linux-x64 1.2.2 → 1.4.0

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

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

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

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

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

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

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

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

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