theus-cli-linux-arm64 0.2.84

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

@@ -0,0 +1,112 @@
+---
+paths:
+  - "**/*.fs"
+  - "**/*.fsx"
+---
+# Estilo de código F#
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de F#.
+
+## Estándares
+
+- Sigue las convenciones estándar de F# y apóyate en el sistema de tipos para garantizar la corrección
+- Prefiere la inmutabilidad por defecto; usa `mutable` solo cuando el rendimiento lo justifique
+- Mantén los módulos enfocados y cohesivos
+
+## Tipos y modelos
+
+- Prefiere uniones discriminadas para modelar el dominio en lugar de jerarquías de clases
+- Usa records para datos con campos con nombre
+- Usa uniones de un solo caso como envoltorios con seguridad de tipos alrededor de primitivos
+- Evita las clases salvo que la interoperabilidad o el estado mutable las requieran
+
+```fsharp
+type EmailAddress = EmailAddress of string
+
+type OrderStatus =
+    | Pending
+    | Confirmed of confirmedAt: DateTimeOffset
+    | Shipped of trackingNumber: string
+    | Cancelled of reason: string
+
+type Order =
+    { Id: Guid
+      CustomerId: string
+      Status: OrderStatus
+      Items: OrderItem list }
+```
+
+## Inmutabilidad
+
+- Los records son inmutables por defecto; usa expresiones `with` para las actualizaciones
+- Prefiere `list`, `map` y `set` frente a colecciones mutables
+- Evita las celdas `ref` y los campos mutables en la lógica de dominio
+
+```fsharp
+let rename (profile: UserProfile) newName =
+    { profile with Name = newName }
+```
+
+## Estilo de funciones
+
+- Prefiere funciones pequeñas y componibles en lugar de métodos grandes
+- Usa el operador pipe `|>` para construir pipelines de datos legibles
+- Prefiere pattern matching en lugar de cadenas de if/else
+- Usa `Option` en lugar de null; usa `Result` para operaciones que pueden fallar
+
+```fsharp
+let processOrder order =
+    order
+    |> validateItems
+    |> Result.bind calculateTotal
+    |> Result.map applyDiscount
+    |> Result.mapError OrderError
+```
+
+## Async y manejo de errores
+
+- Usa `task { }` para interoperar con las APIs asíncronas de .NET
+- Usa `async { }` para flujos asíncronos nativos de F#
+- Propaga `CancellationToken` a través de las APIs asíncronas públicas
+- Prefiere `Result` y la programación orientada a raíles (railway-oriented) sobre excepciones para los fallos esperados
+
+```fsharp
+let loadOrderAsync (orderId: Guid) (ct: CancellationToken) =
+    task {
+        let! order = repository.FindAsync(orderId, ct)
+        return
+            order
+            |> Option.defaultWith (fun () ->
+                failwith $"No se encontró el pedido {orderId}.")
+    }
+```
+
+## Formato
+
+- Usa `fantomas` para el formateo automático
+- Prefiere el espaciado significativo; evita paréntesis innecesarios
+- Elimina las declaraciones `open` sin usar
+
+### Orden de las declaraciones open
+
+Agrupa las sentencias `open` en cuatro secciones separadas por una línea en blanco, cada sección ordenada lexicográficamente:
+
+1. `System.*`
+2. `Microsoft.*`
+3. Namespaces de terceros
+4. Namespaces propios / del proyecto
+
+```fsharp
+open System
+open System.Collections.Generic
+open System.Threading.Tasks
+
+open Microsoft.AspNetCore.Http
+open Microsoft.Extensions.Logging
+
+open FsCheck.Xunit
+open Swensen.Unquote
+
+open MyApp.Domain
+open MyApp.Infrastructure
+```

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

@@ -0,0 +1,26 @@
+---
+paths:
+  - "**/*.fs"
+  - "**/*.fsx"
+  - "**/*.fsproj"
+  - "**/*.sln"
+  - "**/*.slnx"
+  - "**/Directory.Build.props"
+  - "**/Directory.Build.targets"
+---
+# Hooks para F#
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de F#.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **fantomas**: formatea automáticamente los archivos F# editados
+- **dotnet build**: verifica que la solución o el proyecto sigan compilando tras las ediciones
+- **dotnet test --no-build**: vuelve a ejecutar el proyecto de tests relevante más cercano tras cambios de comportamiento
+
+## Hooks Stop
+
+- Ejecuta un `dotnet build` final antes de terminar una sesión con cambios amplios en F#
+- Avisa cuando haya archivos `appsettings*.json` modificados para que no se suban secretos al repositorio

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

@@ -0,0 +1,111 @@
+---
+paths:
+  - "**/*.fs"
+  - "**/*.fsx"
+---
+# Patrones de F#
+
+> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de F#.
+
+## Tipo Result para el manejo de errores
+
+Usa `Result<'T, 'TError>` con programación orientada a raíles (railway-oriented) en lugar de excepciones para los fallos esperados.
+
+```fsharp
+type OrderError =
+    | InvalidCustomer of string
+    | EmptyItems
+    | ItemOutOfStock of sku: string
+
+let validateOrder (request: CreateOrderRequest) : Result<ValidatedOrder, OrderError> =
+    if String.IsNullOrWhiteSpace request.CustomerId then
+        Error(InvalidCustomer "CustomerId es obligatorio")
+    elif request.Items |> List.isEmpty then
+        Error EmptyItems
+    else
+        Ok { CustomerId = request.CustomerId; Items = request.Items }
+```
+
+## Option para valores ausentes
+
+Prefiere `Option<'T>` en lugar de null. Usa `Option.map`, `Option.bind` y `Option.defaultValue` para transformar.
+
+```fsharp
+let findUser (id: Guid) : User option =
+    users |> Map.tryFind id
+
+let getUserEmail userId =
+    findUser userId
+    |> Option.map (fun u -> u.Email)
+    |> Option.defaultValue "desconocido@example.com"
+```
+
+## Uniones discriminadas para modelar el dominio
+
+Modela los estados de negocio de forma explícita. El compilador exige un manejo exhaustivo.
+
+```fsharp
+type PaymentState =
+    | AwaitingPayment of amount: decimal
+    | Paid of paidAt: DateTimeOffset * transactionId: string
+    | Refunded of refundedAt: DateTimeOffset * reason: string
+    | Failed of error: string
+
+let describePayment = function
+    | AwaitingPayment amount -> $"A la espera del pago de {amount:C}"
+    | Paid (at, txn) -> $"Pagado el {at} (txn: {txn})"
+    | Refunded (at, reason) -> $"Reembolsado el {at}: {reason}"
+    | Failed error -> $"El pago falló: {error}"
+```
+
+## Expresiones de computación
+
+Usa expresiones de computación para simplificar operaciones secuenciales que pueden fallar.
+
+```fsharp
+let placeOrder request =
+    result {
+        let! validated = validateOrder request
+        let! inventory = checkInventory validated.Items
+        let! order = createOrder validated inventory
+        return order
+    }
+```
+
+## Organización en módulos
+
+- Agrupa funciones relacionadas en módulos en lugar de clases
+- Usa `[<RequireQualifiedAccess>]` para evitar colisiones de nombres
+- Mantén los módulos pequeños y enfocados en una única responsabilidad
+
+```fsharp
+[<RequireQualifiedAccess>]
+module Order =
+    let create customerId items = { Id = Guid.NewGuid(); CustomerId = customerId; Items = items; Status = Pending }
+    let confirm order = { order with Status = Confirmed(DateTimeOffset.UtcNow) }
+    let cancel reason order = { order with Status = Cancelled reason }
+```
+
+## Inyección de dependencias
+
+- Define las dependencias como parámetros de función o como un record de funciones
+- Usa interfaces con moderación, principalmente en la frontera con librerías de .NET
+- Prefiere la aplicación parcial para inyectar dependencias en los pipelines
+
+```fsharp
+type OrderDeps =
+    { FindOrder: Guid -> Task<Order option>
+      SaveOrder: Order -> Task<unit>
+      SendNotification: Order -> Task<unit> }
+
+let processOrder (deps: OrderDeps) orderId =
+    task {
+        match! deps.FindOrder orderId with
+        | None -> return Error "Pedido no encontrado"
+        | Some order ->
+            let confirmed = Order.confirm order
+            do! deps.SaveOrder confirmed
+            do! deps.SendNotification confirmed
+            return Ok confirmed
+    }
+```

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

@@ -0,0 +1,76 @@
+---
+paths:
+  - "**/*.fs"
+  - "**/*.fsx"
+  - "**/*.fsproj"
+  - "**/appsettings*.json"
+---
+# Seguridad en F#
+
+> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de F#.
+
+## Gestión de secretos
+
+- Nunca codifiques API keys, tokens ni cadenas de conexión en el código fuente
+- Usa variables de entorno, user secrets para desarrollo local y un gestor de secretos en producción
+- Mantén los `appsettings.*.json` libres de credenciales reales
+
+```fsharp
+// INCORRECTO
+let apiKey = "sk-live-123"
+
+// CORRECTO
+let apiKey =
+    configuration["Pagos:ApiKey"]
+    |> Option.ofObj
+    |> Option.defaultWith (fun () -> failwith "Pagos:ApiKey no está configurada.")
+```
+
+## Prevención de inyección SQL
+
+- Usa siempre consultas parametrizadas con ADO.NET, Dapper o EF Core
+- Nunca concatenes entrada del usuario en cadenas SQL
+- Valida los campos de ordenamiento y los operadores de filtro antes de componer consultas dinámicas
+
+```fsharp
+let findByCustomer (connection: IDbConnection) customerId =
+    task {
+        let sql = "SELECT * FROM Orders WHERE CustomerId = @customerId"
+        return! connection.QueryAsync<Order>(sql, {| customerId = customerId |})
+    }
+```
+
+## Validación de entrada
+
+- Valida las entradas en la frontera de la aplicación usando tipos
+- Usa uniones discriminadas de un solo caso para los valores ya validados
+- Rechaza la entrada inválida antes de que llegue a la lógica de dominio
+
+```fsharp
+type ValidatedEmail = private ValidatedEmail of string
+
+module ValidatedEmail =
+    let create (input: string) =
+        if System.Text.RegularExpressions.Regex.IsMatch(input, @"^[^@]+@[^@]+\.[^@]+$") then
+            Ok(ValidatedEmail input)
+        else
+            Error "Dirección de correo inválida"
+
+    let value (ValidatedEmail v) = v
+```
+
+## Autenticación y autorización
+
+- Prefiere los manejadores de autenticación del framework en lugar de parsear tokens a mano
+- Aplica las políticas de autorización en la frontera de los endpoints o handlers
+- Nunca registres en logs tokens sin procesar, contraseñas ni datos personales (PII)
+
+## Manejo de errores
+
+- Devuelve mensajes seguros de cara al cliente
+- Registra las excepciones detalladas con contexto estructurado en el servidor
+- No expongas stack traces, texto SQL ni rutas del sistema de archivos en las respuestas de la API
+
+## Referencia
+
+Consulta la skill `revision-seguridad` para checklists más amplias de revisión de seguridad de aplicaciones.

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

@@ -0,0 +1,62 @@
+---
+paths:
+  - "**/*.fs"
+  - "**/*.fsx"
+  - "**/*.fsproj"
+---
+# Testing en F#
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de F#.
+
+## Framework de tests
+
+- Prefiere **xUnit** con **FsUnit.xUnit** para aserciones amigables con F#
+- Usa **Unquote** para aserciones basadas en quotations con mensajes de fallo claros
+- Usa **FsCheck.xUnit** para testing basado en propiedades
+- Usa **NSubstitute** o stubs de funciones para simular dependencias
+- Usa **Testcontainers** cuando los tests de integración necesiten infraestructura real
+
+## Organización de los tests
+
+- Refleja la estructura de `src/` bajo `tests/`
+- Separa con claridad la cobertura unitaria, de integración y de extremo a extremo
+- Nombra los tests por comportamiento, no por detalles de implementación
+
+```fsharp
+open Xunit
+open Swensen.Unquote
+
+[<Fact>]
+let ``PlaceOrder devuelve éxito cuando la solicitud es válida`` () =
+    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
+    let result = OrderService.placeOrder request
+    test <@ Result.isOk result @>
+
+[<Fact>]
+let ``PlaceOrder devuelve error cuando los ítems están vacíos`` () =
+    let request = { CustomerId = "cust-123"; Items = [] }
+    let result = OrderService.placeOrder request
+    test <@ Result.isError result @>
+```
+
+## Testing basado en propiedades con FsCheck
+
+```fsharp
+open FsCheck.Xunit
+
+[<Property>]
+let ``el total del pedido nunca es negativo`` (items: OrderItem list) =
+    let total = Order.calculateTotal items
+    total >= 0m
+```
+
+## Tests de integración con ASP.NET Core
+
+- Usa `WebApplicationFactory<TEntryPoint>` para la cobertura de integración de la API
+- Prueba autenticación, validación y serialización a través de HTTP, no saltándote el middleware
+
+## Cobertura
+
+- Apunta a una cobertura de líneas de al menos 80 %
+- Concentra la cobertura en lógica de dominio, validación, autenticación y rutas de fallo
+- Ejecuta `dotnet test` en CI con recolección de cobertura habilitada cuando esté disponible

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

@@ -0,0 +1,32 @@
+---
+paths:
+  - "**/*.go"
+  - "**/go.mod"
+  - "**/go.sum"
+---
+# Estilo de código Go
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de Go.
+
+## Formato
+
+- **gofmt** y **goimports** son obligatorios — sin debates de estilo
+
+## Principios de diseño
+
+- Acepta interfaces, devuelve structs
+- Mantén las interfaces pequeñas (1-3 métodos)
+
+## Manejo de errores
+
+Envuelve siempre los errores con contexto:
+
+```go
+if err != nil {
+    return fmt.Errorf("no se pudo crear el usuario: %w", err)
+}
+```
+
+## Referencia
+
+Ver skill: `patrones-go` para idiomas y patrones de Go en profundidad.

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

@@ -0,0 +1,17 @@
+---
+paths:
+  - "**/*.go"
+  - "**/go.mod"
+  - "**/go.sum"
+---
+# Hooks para Go
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de Go.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **gofmt/goimports**: formatea automáticamente los archivos `.go` después de editarlos
+- **go vet**: ejecuta análisis estático después de editar archivos `.go`
+- **staticcheck**: ejecuta comprobaciones estáticas extendidas sobre los paquetes modificados

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

@@ -0,0 +1,45 @@
+---
+paths:
+  - "**/*.go"
+  - "**/go.mod"
+  - "**/go.sum"
+---
+# Patrones de Go
+
+> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de Go.
+
+## Opciones funcionales
+
+```go
+type Option func(*Server)
+
+func WithPort(port int) Option {
+    return func(s *Server) { s.port = port }
+}
+
+func NewServer(opts ...Option) *Server {
+    s := &Server{port: 8080}
+    for _, opt := range opts {
+        opt(s)
+    }
+    return s
+}
+```
+
+## Interfaces pequeñas
+
+Define las interfaces donde se usan, no donde se implementan.
+
+## Inyección de dependencias
+
+Usa funciones constructoras para inyectar dependencias:
+
+```go
+func NewUserService(repo UserRepository, logger Logger) *UserService {
+    return &UserService{repo: repo, logger: logger}
+}
+```
+
+## Referencia
+
+Ver skill: `patrones-go` para patrones de Go en profundidad, incluyendo concurrencia, manejo de errores y organización de paquetes.

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

@@ -0,0 +1,34 @@
+---
+paths:
+  - "**/*.go"
+  - "**/go.mod"
+  - "**/go.sum"
+---
+# Seguridad en Go
+
+> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de Go.
+
+## Gestión de secretos
+
+```go
+apiKey := os.Getenv("API_KEY")
+if apiKey == "" {
+    log.Fatal("API_KEY no configurada")
+}
+```
+
+## Escaneo de seguridad
+
+- Usa **gosec** para el análisis estático de seguridad:
+  ```bash
+  gosec ./...
+  ```
+
+## Context y timeouts
+
+Usa siempre `context.Context` para controlar los timeouts:
+
+```go
+ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+defer cancel()
+```

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

@@ -0,0 +1,31 @@
+---
+paths:
+  - "**/*.go"
+  - "**/go.mod"
+  - "**/go.sum"
+---
+# Testing en Go
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de Go.
+
+## Framework
+
+Usa el `go test` estándar con **tests basados en tablas** (table-driven tests).
+
+## Detección de condiciones de carrera
+
+Ejecuta siempre con el flag `-race`:
+
+```bash
+go test -race ./...
+```
+
+## Cobertura
+
+```bash
+go test -cover ./...
+```
+
+## Referencia
+
+Ver skill: `testing-go` para patrones y helpers de testing en Go en detalle.

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

@@ -0,0 +1,114 @@
+---
+paths:
+  - "**/*.java"
+---
+# Estilo de código Java
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de Java.
+
+## Formato
+
+- **google-java-format** o **Checkstyle** (estilo Google o Sun) para hacer cumplir el formato
+- Un tipo público de nivel superior por archivo
+- Indentación consistente: 2 o 4 espacios (respeta el estándar del proyecto)
+- Orden de miembros: constantes, campos, constructores, métodos públicos, protegidos, privados
+
+## Inmutabilidad
+
+- Prefiere `record` para tipos de valor (Java 16+)
+- Marca los campos como `final` por defecto — usa estado mutable solo cuando sea imprescindible
+- Devuelve copias defensivas desde las APIs públicas: `List.copyOf()`, `Map.copyOf()`, `Set.copyOf()`
+- Copia al escribir: devuelve instancias nuevas en lugar de mutar las existentes
+
+```java
+// BIEN — tipo de valor inmutable
+public record OrderSummary(Long id, String customerName, BigDecimal total) {}
+
+// BIEN — campos final, sin setters
+public class Order {
+    private final Long id;
+    private final List<LineItem> items;
+
+    public List<LineItem> getItems() {
+        return List.copyOf(items);
+    }
+}
+```
+
+## Nombres
+
+Sigue las convenciones estándar de Java:
+- `PascalCase` para clases, interfaces, records y enums
+- `camelCase` para métodos, campos, parámetros y variables locales
+- `SCREAMING_SNAKE_CASE` para constantes `static final`
+- Paquetes: todo en minúsculas, dominio invertido (`com.example.app.service`)
+
+## Características modernas de Java
+
+Usa las características modernas del lenguaje cuando mejoren la claridad:
+- **Records** para DTOs y tipos de valor (Java 16+)
+- **Clases selladas** para jerarquías de tipos cerradas (Java 17+)
+- **Pattern matching** con `instanceof` — sin cast explícito (Java 16+)
+- **Bloques de texto** para strings multilínea — SQL, plantillas JSON (Java 15+)
+- **Expresiones switch** con sintaxis de flecha (Java 14+)
+- **Pattern matching en switch** — manejo exhaustivo de tipos sellados (Java 21+)
+
+```java
+// Pattern matching con instanceof
+if (shape instanceof Circle c) {
+    return Math.PI * c.radius() * c.radius();
+}
+
+// Jerarquía de tipos sellada
+public sealed interface PaymentMethod permits CreditCard, BankTransfer, Wallet {}
+
+// Expresión switch
+String label = switch (status) {
+    case ACTIVE -> "Activa";
+    case SUSPENDED -> "Suspendida";
+    case CLOSED -> "Cerrada";
+};
+```
+
+## Uso de Optional
+
+- Devuelve `Optional<T>` desde métodos de búsqueda que pueden no tener resultado
+- Usa `map()`, `flatMap()`, `orElseThrow()` — nunca llames a `get()` sin `isPresent()`
+- Nunca uses `Optional` como tipo de campo ni como parámetro de método
+
+```java
+// BIEN
+return repository.findById(id)
+    .map(ResponseDto::from)
+    .orElseThrow(() -> new OrderNotFoundException(id));
+
+// MAL — Optional como parámetro
+public void process(Optional<String> name) {}
+```
+
+## Manejo de errores
+
+- Prefiere excepciones no comprobadas (unchecked) para errores de dominio
+- Crea excepciones específicas del dominio que extiendan `RuntimeException`
+- Evita el `catch (Exception e)` genérico salvo en manejadores de nivel superior
+- Incluye contexto en los mensajes de las excepciones
+
+```java
+public class OrderNotFoundException extends RuntimeException {
+    public OrderNotFoundException(Long id) {
+        super("Pedido no encontrado: id=" + id);
+    }
+}
+```
+
+## Streams
+
+- Usa streams para transformaciones; mantén los pipelines cortos (máximo 3-4 operaciones)
+- Prefiere referencias a métodos cuando sean legibles: `.map(Order::getTotal)`
+- Evita efectos secundarios dentro de las operaciones de stream
+- Para lógica compleja, prefiere un bucle antes que un pipeline de stream enrevesado
+
+## Referencias
+
+Consulta la skill `estandares-java` para los estándares de codificación completos con ejemplos.
+Consulta la skill `patrones-jpa` para patrones de diseño de entidades JPA/Hibernate.

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

@@ -0,0 +1,18 @@
+---
+paths:
+  - "**/*.java"
+  - "**/pom.xml"
+  - "**/build.gradle"
+  - "**/build.gradle.kts"
+---
+# Hooks para Java
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de Java.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **google-java-format**: formatea automáticamente los archivos `.java` después de editarlos
+- **checkstyle**: ejecuta comprobaciones de estilo después de editar archivos Java
+- **./mvnw compile** o **./gradlew compileJava**: verifica la compilación después de los cambios