theus-cli-linux-x64 0.2.84

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

@@ -0,0 +1,44 @@
+---
+paths:
+  - "**/*.cpp"
+  - "**/*.hpp"
+  - "**/*.cc"
+  - "**/*.hh"
+  - "**/*.cxx"
+  - "**/*.h"
+  - "**/CMakeLists.txt"
+---
+# Testing en C++
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de C++.
+
+## Framework
+
+Usa **GoogleTest** (gtest/gmock) con **CMake/CTest**.
+
+## Ejecutar los tests
+
+```bash
+cmake --build build && ctest --test-dir build --output-on-failure
+```
+
+## Cobertura
+
+```bash
+cmake -DCMAKE_CXX_FLAGS="--coverage" -DCMAKE_EXE_LINKER_FLAGS="--coverage" ..
+cmake --build .
+ctest --output-on-failure
+lcov --capture --directory . --output-file coverage.info
+```
+
+## Sanitizers
+
+Ejecuta siempre los tests con sanitizers en CI:
+
+```bash
+cmake -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined" ..
+```
+
+## Referencia
+
+Consulta la skill `testing-cpp` para patrones detallados de testing en C++, flujo TDD y uso de GoogleTest/GMock.

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

@@ -0,0 +1,72 @@
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csx"
+---
+# Estilo de código C#
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de C#.
+
+## Estándares
+
+- Sigue las convenciones actuales de .NET y habilita los tipos de referencia anulables (nullable reference types)
+- Prefiere modificadores de acceso explícitos en las APIs públicas e internas
+- Mantén cada archivo alineado con el tipo principal que define
+
+## Tipos y modelos
+
+- Prefiere `record` o `record struct` para modelos inmutables de tipo valor
+- Usa `class` para entidades o tipos con identidad y ciclo de vida
+- Usa `interface` para límites de servicios y abstracciones
+- Evita `dynamic` en código de aplicación; prefiere genéricos o modelos explícitos
+
+```csharp
+public sealed record UserDto(Guid Id, string Email);
+
+public interface IUserRepository
+{
+    Task<UserDto?> FindByIdAsync(Guid id, CancellationToken cancellationToken);
+}
+```
+
+## Inmutabilidad
+
+- Prefiere setters `init`, parámetros de constructor y colecciones inmutables para el estado compartido
+- No mutes los modelos de entrada en el sitio al producir un estado actualizado
+
+```csharp
+public sealed record UserProfile(string Name, string Email);
+
+public static UserProfile Rename(UserProfile profile, string name) =>
+    profile with { Name = name };
+```
+
+## Asincronía y manejo de errores
+
+- Prefiere `async`/`await` sobre llamadas bloqueantes como `.Result` o `.Wait()`
+- Propaga `CancellationToken` a través de las APIs asíncronas públicas
+- Lanza excepciones específicas y registra con propiedades estructuradas
+
+```csharp
+public async Task<Order> LoadOrderAsync(
+    Guid orderId,
+    CancellationToken cancellationToken)
+{
+    try
+    {
+        return await repository.FindAsync(orderId, cancellationToken)
+            ?? throw new InvalidOperationException($"No se encontró la orden {orderId}.");
+    }
+    catch (Exception ex)
+    {
+        logger.LogError(ex, "Error al cargar la orden {OrderId}", orderId);
+        throw;
+    }
+}
+```
+
+## Formato
+
+- Usa `dotnet format` para el formateo y las correcciones de los analizadores
+- Mantén las directivas `using` organizadas y elimina los imports sin uso
+- Prefiere miembros con cuerpo de expresión solo cuando siguen siendo legibles

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

@@ -0,0 +1,25 @@
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csx"
+  - "**/*.csproj"
+  - "**/*.sln"
+  - "**/Directory.Build.props"
+  - "**/Directory.Build.targets"
+---
+# Hooks para C#
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de C#.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **dotnet format**: formatea automáticamente los archivos C# editados y aplica correcciones de los analizadores
+- **dotnet build**: verifica que la solución o el proyecto siguen compilando después de 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 C#
+- Advierte sobre archivos `appsettings*.json` modificados para que no se cometan secretos

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

@@ -0,0 +1,50 @@
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csx"
+---
+# Patrones de C#
+
+> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de C#.
+
+## Patrón de respuesta de API
+
+```csharp
+public sealed record ApiResponse<T>(
+    bool Success,
+    T? Data = default,
+    string? Error = null,
+    object? Meta = null);
+```
+
+## Patrón Repository
+
+```csharp
+public interface IRepository<T>
+{
+    Task<IReadOnlyList<T>> FindAllAsync(CancellationToken cancellationToken);
+    Task<T?> FindByIdAsync(Guid id, CancellationToken cancellationToken);
+    Task<T> CreateAsync(T entity, CancellationToken cancellationToken);
+    Task<T> UpdateAsync(T entity, CancellationToken cancellationToken);
+    Task DeleteAsync(Guid id, CancellationToken cancellationToken);
+}
+```
+
+## Patrón Options
+
+Usa opciones fuertemente tipadas para la configuración en lugar de leer cadenas sueltas por todo el código.
+
+```csharp
+public sealed class PaymentsOptions
+{
+    public const string SectionName = "Payments";
+    public required string BaseUrl { get; init; }
+    public required string ApiKeySecretName { get; init; }
+}
+```
+
+## Inyección de dependencias
+
+- Depende de interfaces en los límites de los servicios
+- Mantén los constructores enfocados; si un servicio necesita demasiadas dependencias, divide responsabilidades
+- Registra los ciclos de vida de forma intencional: singleton para servicios sin estado o compartidos, scoped para datos de la petición, transient para trabajadores puros y ligeros

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

@@ -0,0 +1,58 @@
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csx"
+  - "**/*.csproj"
+  - "**/appsettings*.json"
+---
+# Seguridad en C#
+
+> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de C#.
+
+## 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
+
+```csharp
+// INCORRECTO
+const string ApiKey = "sk-live-123";
+
+// CORRECTO
+var apiKey = builder.Configuration["Pagos:ApiKey"]
+    ?? throw new InvalidOperationException("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 usar composición dinámica de consultas
+
+```csharp
+const string sql = "SELECT * FROM Orders WHERE CustomerId = @customerId";
+await connection.QueryAsync<Order>(sql, new { customerId });
+```
+
+## Validación de entrada
+
+- Valida los DTO en el límite de la aplicación
+- Usa data annotations, FluentValidation o cláusulas de guarda explícitas
+- Rechaza el model state inválido antes de ejecutar la lógica de negocio
+
+## Autenticación y autorización
+
+- Prefiere los handlers de autenticación del framework en lugar de parsear tokens a mano
+- Aplica las políticas de autorización en los límites de los endpoints o de los handlers
+- Nunca registres tokens en crudo, contraseñas ni 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/csharp/testing.md

@@ -0,0 +1,50 @@
+---
+paths:
+  - "**/*.cs"
+  - "**/*.csx"
+  - "**/*.csproj"
+---
+# Testing en C#
+
+> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de C#.
+
+## Framework de testing
+
+- Prefiere **xUnit** para tests unitarios y de integración
+- Usa **FluentAssertions** para aserciones legibles
+- Usa **Moq** o **NSubstitute** 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
+
+```csharp
+public sealed class OrderServiceTests
+{
+    [Fact]
+    public async Task FindByIdAsync_ReturnsOrder_WhenOrderExists()
+    {
+        // Arrange (preparar)
+        // Act (actuar)
+        // Assert (verificar)
+    }
+}
+```
+
+## Tests de integración de ASP.NET Core
+
+- Usa `WebApplicationFactory<TEntryPoint>` para la cobertura de integración de APIs
+- Prueba autenticación, validación y serialización a través de HTTP, no saltándote el middleware
+
+## Cobertura
+
+- Apunta a 80%+ de cobertura de líneas
+- Concentra la cobertura en la lógica de dominio, la validación, la autenticación y las rutas de fallo
+- Ejecuta `dotnet test` en CI con recolección de cobertura habilitada cuando esté disponible
+
+## Referencia
+
+Consulta la skill `testing-csharp` para patrones de testing de C# en profundidad.

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

@@ -0,0 +1,159 @@
+---
+paths:
+  - "**/*.dart"
+  - "**/pubspec.yaml"
+  - "**/analysis_options.yaml"
+---
+# Estilo de código Dart/Flutter
+
+> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de Dart y Flutter.
+
+## Formato
+
+- **dart format** para todos los archivos `.dart` — obligatorio en CI (`dart format --set-exit-if-changed .`)
+- Longitud de línea: 80 caracteres (valor por defecto de dart format)
+- Comas finales en listas de argumentos/parámetros multilínea para mejorar los diffs y el formateo
+
+## Inmutabilidad
+
+- Prefiere `final` para variables locales y `const` para constantes en tiempo de compilación
+- Usa constructores `const` siempre que todos los campos sean `final`
+- Devuelve colecciones no modificables desde las APIs públicas (`List.unmodifiable`, `Map.unmodifiable`)
+- Usa `copyWith()` para las mutaciones de estado en clases de estado inmutables
+
+```dart
+// INCORRECTO
+var count = 0;
+List<String> items = ['a', 'b'];
+
+// CORRECTO
+final count = 0;
+const items = ['a', 'b'];
+```
+
+## Nomenclatura
+
+Sigue las convenciones de Dart:
+- `camelCase` para variables, parámetros y constructores con nombre
+- `PascalCase` para clases, enums, typedefs y extensiones
+- `snake_case` para nombres de archivos y de librerías
+- `SCREAMING_SNAKE_CASE` para constantes declaradas con `const` a nivel superior
+- Prefija los miembros privados con `_`
+- Los nombres de extensiones describen el tipo que extienden: `StringExtensions`, no `MyHelpers`
+
+## Null safety
+
+- Evita `!` (operador bang) — prefiere `?.`, `??`, `if (x != null)` o el pattern matching de Dart 3; reserva `!` solo para donde un valor nulo sea un error de programación y fallar sea el comportamiento correcto
+- Evita `late` salvo que la inicialización esté garantizada antes del primer uso (prefiere anulable o inicialización en el constructor)
+- Usa `required` para parámetros de constructor que siempre deben proporcionarse
+
+```dart
+// INCORRECTO — falla en tiempo de ejecución si user es null
+final name = user!.name;
+
+// CORRECTO — operadores null-aware
+final name = user?.name ?? 'Desconocido';
+
+// CORRECTO — pattern matching de Dart 3 (exhaustivo, verificado por el compilador)
+final name = switch (user) {
+  User(:final name) => name,
+  null => 'Desconocido',
+};
+
+// CORRECTO — guarda de nulos con retorno temprano
+String getUserName(User? user) {
+  if (user == null) return 'Desconocido';
+  return user.name; // promovido a no nulo después de la guarda
+}
+```
+
+## Tipos sealed y pattern matching (Dart 3+)
+
+Usa clases sealed para modelar jerarquías de estado cerradas:
+
+```dart
+sealed class AsyncState<T> {
+  const AsyncState();
+}
+
+final class Loading<T> extends AsyncState<T> {
+  const Loading();
+}
+
+final class Success<T> extends AsyncState<T> {
+  const Success(this.data);
+  final T data;
+}
+
+final class Failure<T> extends AsyncState<T> {
+  const Failure(this.error);
+  final Object error;
+}
+```
+
+Usa siempre `switch` exhaustivo con tipos sealed — sin default ni comodín:
+
+```dart
+// INCORRECTO
+if (state is Loading) { ... }
+
+// CORRECTO
+return switch (state) {
+  Loading() => const CircularProgressIndicator(),
+  Success(:final data) => DataWidget(data),
+  Failure(:final error) => ErrorWidget(error.toString()),
+};
+```
+
+## Manejo de errores
+
+- Especifica los tipos de excepción en cláusulas `on` — nunca uses un `catch (e)` a secas
+- Nunca captures subtipos de `Error` — indican bugs de programación
+- Usa tipos estilo `Result` o clases sealed para errores recuperables
+- Evita usar excepciones para el control de flujo
+
+```dart
+// INCORRECTO
+try {
+  await fetchUser();
+} catch (e) {
+  log(e.toString());
+}
+
+// CORRECTO
+try {
+  await fetchUser();
+} on NetworkException catch (e) {
+  log('Error de red: ${e.message}');
+} on NotFoundException {
+  handleNotFound();
+}
+```
+
+## Asincronía / Futures
+
+- Espera siempre los Futures con `await` o llama explícitamente a `unawaited()` para señalar un fire-and-forget intencional
+- Nunca marques una función como `async` si nunca usa `await`
+- Usa `Future.wait` / `Future.any` para operaciones concurrentes
+- Comprueba `context.mounted` antes de usar un `BuildContext` después de cualquier `await` (Flutter 3.7+)
+
+```dart
+// INCORRECTO — Future ignorado
+fetchData(); // fire-and-forget sin marcar la intención
+
+// CORRECTO
+unawaited(fetchData()); // fire-and-forget explícito
+await fetchData();      // o esperado correctamente
+```
+
+## Imports
+
+- Usa imports `package:` en todo el código — nunca imports relativos (`../`) para código entre features o entre capas
+- Orden: `dart:` → `package:` externos → `package:` internos (mismo paquete)
+- Sin imports sin uso — `dart analyze` lo impone con `unused_import`
+
+## Generación de código
+
+- Los archivos generados (`.g.dart`, `.freezed.dart`, `.gr.dart`) deben commitearse o ignorarse en git de forma consistente — elige una sola estrategia por proyecto
+- Nunca edites manualmente los archivos generados
+- Mantén las anotaciones del generador (`@JsonSerializable`, `@freezed`, `@riverpod`, etc.) solo en el archivo fuente canónico

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

@@ -0,0 +1,68 @@
+---
+paths:
+  - "**/*.dart"
+  - "**/pubspec.yaml"
+  - "**/analysis_options.yaml"
+---
+# Hooks para Dart/Flutter
+
+> Este archivo extiende [common/hooks.md](../common/hooks.md) con contenido específico de Dart y Flutter.
+
+## Hooks PostToolUse
+
+Configúralos en `~/.theus/settings.json`:
+
+- **dart format**: formatea automáticamente los archivos `.dart` después de editarlos
+- **dart analyze**: ejecuta análisis estático después de editar archivos Dart y muestra las advertencias
+- **flutter test**: opcionalmente ejecuta los tests afectados tras cambios significativos
+
+## Configuración de hooks recomendada
+
+El matcher es una cadena con los nombres de tool separados por `|`; la ruta del archivo editado llega por stdin en el JSON del hook (`.tool_input.file_path`):
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          { "type": "command", "command": "jq -r '.tool_input.file_path // empty' | grep '\\.dart$' | xargs -r dart format" }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Comprobaciones pre-commit
+
+Ejecútalas antes de commitear cambios de Dart/Flutter:
+
+```bash
+dart format --set-exit-if-changed .
+dart analyze --fatal-infos
+flutter test
+```
+
+## One-liners útiles
+
+```bash
+# Formatear todos los archivos Dart
+dart format .
+
+# Analizar y reportar problemas
+dart analyze
+
+# Ejecutar todos los tests con cobertura
+flutter test --coverage
+
+# Regenerar los archivos de generación de código
+dart run build_runner build --delete-conflicting-outputs
+
+# Comprobar paquetes desactualizados
+flutter pub outdated
+
+# Actualizar paquetes dentro de las restricciones
+flutter pub upgrade
+```