theus-cli 0.2.82 → 0.2.84

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

@@ -1,249 +0,0 @@
----
-paths:
-  - "**/*.component.ts"
-  - "**/*.component.html"
-  - "**/*.service.ts"
-  - "**/*.store.ts"
-  - "**/*.routes.ts"
----
-# Patrones de Angular
-
-> Este archivo extiende [common/patterns.md](../common/patterns.md) con contenido específico de Angular.
-
-## Separación de componentes smart / dumb
-
-Los componentes smart (contenedores) son dueños de la obtención de datos y del estado. Los componentes dumb (presentacionales) solo reciben inputs y emiten outputs — sin inyección de servicios.
-
-```typescript
-// Smart — dueño de los datos
-@Component({ standalone: true, changeDetection: ChangeDetectionStrategy.OnPush })
-export class UserPageComponent {
-  private userService = inject(UserService);
-  user = toSignal(this.userService.getUser(this.userId));
-}
-```
-
-```html
-<!-- Dumb — presentación pura -->
-<app-user-card [user]="user()" (select)="onSelect($event)" />
-```
-
-## Capa de servicios
-
-Los servicios son dueños de todo el acceso a datos y la lógica de negocio. Los componentes delegan — nada de `HttpClient` en componentes.
-
-```typescript
-@Injectable({ providedIn: 'root' })
-export class UserService {
-  private http = inject(HttpClient);
-
-  getUsers(): Observable<User[]> {
-    return this.http.get<User[]>('/api/users');
-  }
-}
-```
-
-## Datos asíncronos con `resource`
-
-Usa `resource()` para la obtención asíncrona reactiva. Prefiérelo sobre pipelines manuales de RxJS para cargas de datos simples:
-
-```typescript
-export class UserDetailComponent {
-  userId = input.required<string>();
-
-  userResource = resource({
-    request: () => ({ id: this.userId() }),
-    loader: ({ request }) =>
-      firstValueFrom(inject(UserService).getUser(request.id)),
-  });
-}
-```
-
-Acceso al estado: `userResource.value()`, `userResource.isLoading()`, `userResource.error()`, `userResource.reload()`.
-
-## Patrones de estado con signals
-
-```typescript
-// Estado local mutable
-count = signal(0);
-
-// Derivado (nunca duplicado)
-doubled = computed(() => this.count() * 2);
-
-// Estado derivado escribible que se reinicia con la fuente
-selectedItem = linkedSignal(() => this.items()[0]);
-
-// Puente de Observable a signal
-users = toSignal(this.userService.getUsers(), { initialValue: [] });
-```
-
-Nunca guardes valores derivados en signals separados — usa `computed`. Nunca uses `effect` para sincronizar signals — usa `computed` o `linkedSignal`.
-
-## Limpieza de suscripciones
-
-Usa `takeUntilDestroyed()` para todas las suscripciones manuales. Nunca uses `ngOnDestroy` manual + `Subject` + `takeUntil` en código nuevo.
-
-```typescript
-export class UserComponent {
-  private destroyRef = inject(DestroyRef);
-
-  ngOnInit() {
-    this.userService.updates$
-      .pipe(takeUntilDestroyed(this.destroyRef))
-      .subscribe(update => this.handleUpdate(update));
-  }
-}
-```
-
-## Enrutamiento
-
-### Definición de rutas
-
-```typescript
-// app.routes.ts
-export const routes: Routes = [
-  { path: '', component: HomeComponent },
-  {
-    path: 'admin',
-    canMatch: [authGuard],           // CanMatch evita cargar el chunk por completo
-    loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
-  },
-  {
-    path: 'users/:id',
-    resolve: { user: userResolver },
-    component: UserDetailComponent,
-  },
-];
-```
-
-- Usa `canMatch` en lugar de `canActivate` cuando el módulo de la ruta no debe cargarse para usuarios no autorizados
-- Carga de forma diferida (lazy) todos los módulos de funcionalidad con `loadChildren`
-- Pre-obtén datos con `resolve` para evitar estados de carga en los componentes
-
-### Guards funcionales
-
-```typescript
-export const authGuard: CanActivateFn = () => {
-  const auth = inject(AuthService);
-  return auth.isAuthenticated()
-    ? true
-    : inject(Router).createUrlTree(['/login']);
-};
-```
-
-### Resolvers de datos
-
-```typescript
-export const userResolver: ResolveFn<User> = (route) => {
-  return inject(UserService).getUser(route.paramMap.get('id')!);
-};
-```
-
-### View Transitions
-
-Habilita transiciones de ruta fluidas con la API de View Transitions:
-
-```typescript
-// app.config.ts
-provideRouter(routes, withViewTransitions())
-```
-
-## Patrones de inyección de dependencias
-
-### Providers con alcance acotado
-
-Provee servicios a nivel de componente o de ruta cuando no deban ser singletons:
-
-```typescript
-@Component({
-  providers: [UserEditService],   // acotado al subárbol de este componente
-})
-export class UserEditComponent {}
-```
-
-### `InjectionToken`
-
-```typescript
-export const CONFIG = new InjectionToken<AppConfig>('APP_CONFIG');
-
-// En providers:
-{ provide: CONFIG, useValue: appConfig }
-{ provide: CONFIG, useFactory: () => loadConfig(), deps: [] }
-
-// Consumir:
-private config = inject(CONFIG);
-```
-
-### `viewProviders` vs `providers`
-
-- `providers`: disponible para el componente y todos sus hijos de contenido
-- `viewProviders`: disponible solo para la vista propia del componente (no para el contenido proyectado)
-
-## Interceptores HTTP
-
-Usa interceptores funcionales (v15+) para autenticación, manejo de errores y reintentos:
-
-```typescript
-export const authInterceptor: HttpInterceptorFn = (req, next) => {
-  const token = inject(AuthService).token();
-  if (!token) return next(req);
-  return next(req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }));
-};
-```
-
-Regístralos en `app.config.ts`:
-
-```typescript
-provideHttpClient(withInterceptors([authInterceptor, errorInterceptor]))
-```
-
-## Operadores de RxJS
-
-- `switchMap` — búsqueda, navegación (cancela lo anterior)
-- `mergeMap` — peticiones paralelas independientes
-- `exhaustMap` — envíos de formularios (ignora hasta completar)
-- Maneja siempre los errores con `catchError` — nunca dejes que los streams mueran en silencio
-
-```typescript
-search$ = this.query$.pipe(
-  debounceTime(300),
-  distinctUntilChanged(),
-  switchMap(q => this.service.search(q).pipe(catchError(() => of([])))),
-);
-```
-
-## Formularios
-
-Sigue la estrategia de formularios existente del proyecto. Para apps nuevas en v21+, prefiere signal forms.
-
-```typescript
-// Reactive Forms — estándar para formularios complejos
-export class UserFormComponent {
-  private fb = inject(FormBuilder);
-
-  form = this.fb.group({
-    name: ['', Validators.required],
-    email: ['', [Validators.required, Validators.email]],
-  });
-}
-```
-
-## Estrategias de renderizado
-
-- **CSR** (predeterminado): SPA estándar
-- **SSR + Hydration**: `ng add @angular/ssr` — mejora el FCP y el SEO
-- **SSG (prerenderizado)**: páginas estáticas en tiempo de build para rutas con mucho contenido
-
-Al usar SSR, evita `window`, `document` y `localStorage` directamente — usa `isPlatformBrowser` o el token `DOCUMENT`.
-
-## Accesibilidad
-
-Usa el CDK de Angular para componentes headless accesibles (Accordion, Listbox, Combobox, Menu, Tabs, Toolbar, Tree, Grid). Estiliza los atributos ARIA en lugar de gestionarlos manualmente:
-
-```css
-[aria-selected="true"] { background: var(--color-selected); }
-```
-
-## Referencia
-
-Consulta la skill `patrones-angular` para orientación en profundidad sobre signals, formularios, enrutamiento, DI, SSR y patrones de accesibilidad.

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

@@ -1,87 +0,0 @@
----
-paths:
-  - "**/*.component.ts"
-  - "**/*.component.html"
-  - "**/*.service.ts"
-  - "**/*.interceptor.ts"
----
-# Seguridad en Angular
-
-> Este archivo extiende [common/security.md](../common/security.md) con contenido específico de Angular.
-
-## Prevención de XSS
-
-Angular sanitiza automáticamente los valores enlazados. Nunca omitas el sanitizador con entradas controladas por el usuario.
-
-```typescript
-// INCORRECTO: omite la sanitización — riesgo de XSS
-this.safeHtml = this.sanitizer.bypassSecurityTrustHtml(userInput);
-
-// CORRECTO: sanitiza explícitamente antes de confiar
-this.safeHtml = this.sanitizer.sanitize(SecurityContext.HTML, userInput);
-```
-
-- Nunca uses los métodos `bypassSecurityTrust*` sin una razón documentada y revisada
-- Evita `[innerHTML]` con contenido no confiable — usa `innerText` o un pipe sanitizador
-- Nunca enlaces `[href]` a entradas del usuario — Angular no bloquea las URLs `javascript:` en todos los contextos
-- Nunca construyas cadenas de plantilla a partir de datos del usuario
-
-## Seguridad HTTP
-
-Usa `HttpClient` de forma exclusiva — nunca `fetch()` ni `XHR` en crudo salvo que no exista alternativa.
-
-```typescript
-// INCORRECTO: omite los interceptores (cabeceras de autenticación, manejo de errores, logging)
-const res = await fetch('/api/users');
-
-// CORRECTO
-users$ = this.http.get<User[]>('/api/users');
-```
-
-- Adjunta los tokens de autenticación mediante interceptores — nunca los codifiques en llamadas individuales de servicios
-- Tipa y valida las respuestas de la API — trata los datos externos como `unknown` en la frontera
-- Nunca registres en logs respuestas HTTP que puedan contener tokens, datos personales o credenciales
-
-## Gestión de secretos
-
-```typescript
-// INCORRECTO: secreto codificado en el código fuente
-const apiKey = 'sk-live-xxxx';
-
-// CORRECTO: inyectado vía entorno
-import { environment } from '../environments/environment';
-const apiKey = environment.apiKey;
-```
-
-- Trata `environment.ts` como una forma de configuración — nunca guardes secretos reales en archivos de entorno bajo control de versiones
-- Inyecta los secretos de producción vía CI/CD (variables de entorno, gestores de secretos)
-
-## Guards de rutas
-
-Toda ruta autenticada o restringida por rol debe tener un guard. Nunca confíes solo en ocultar elementos de la interfaz.
-
-```typescript
-{
-  path: 'admin',
-  canMatch: [authGuard, roleGuard('admin')],
-  loadChildren: () => import('./admin/admin.routes'),
-}
-```
-
-Usa `canMatch` para rutas sensibles — evita que el módulo de la ruta se cargue por completo para usuarios no autorizados.
-
-## Seguridad en SSR
-
-Al usar Angular SSR:
-
-- Nunca expongas variables de entorno del servidor al cliente vía `TransferState`, salvo que sean intencionalmente públicas
-- Sanitiza todas las entradas antes del renderizado en servidor — el XSS basado en DOM también puede ocurrir del lado del servidor
-- Evita `window`, `document` y `localStorage` en el servidor — protégelos con `isPlatformBrowser` o inyéctalos vía el token `DOCUMENT`
-
-## Content Security Policy
-
-Configura las cabeceras CSP del lado del servidor. Evita `unsafe-inline` en `script-src`. Al usar SSR con scripts inline, usa nonces mediante el soporte de CSP de Angular.
-
-## Apoyo de skills
-
-- Usa la skill `revision-seguridad` para auditorías de seguridad exhaustivas

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

@@ -1,164 +0,0 @@
----
-paths:
-  - "**/*.spec.ts"
-  - "**/*.test.ts"
----
-# Testing en Angular
-
-> Este archivo extiende [common/testing.md](../common/testing.md) con contenido específico de Angular.
-
-## Runner de tests
-
-Usa el runner de tests configurado por el proyecto. Revisa `angular.json` y `package.json`; los proyectos Angular suelen usar Vitest, Jest o Jasmine + Karma.
-
-```bash
-ng test               # modo watch
-ng test --no-watch    # modo CI
-```
-
-## Configuración de TestBed
-
-Para componentes standalone, importa el componente directamente. Llama a `compileComponents()` en componentes con plantillas externas.
-
-```typescript
-describe('UserCardComponent', () => {
-  let fixture: ComponentFixture<UserCardComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      imports: [UserCardComponent],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(UserCardComponent);
-  });
-});
-```
-
-## Inputs basados en signals
-
-Establece los inputs basados en signals mediante `fixture.componentRef.setInput()`:
-
-```typescript
-fixture.componentRef.setInput('user', mockUser);
-fixture.detectChanges();
-```
-
-## Component harnesses
-
-Prefiere los component harnesses del CDK de Angular sobre consultas directas al DOM para la interacción con la interfaz. Los harnesses son más resistentes a cambios de marcado.
-
-```typescript
-import { HarnessLoader } from '@angular/cdk/testing';
-import { TestbedHarnessEnvironment } from '@angular/cdk/testing/testbed';
-import { MatButtonHarness } from '@angular/material/button/testing';
-
-let loader: HarnessLoader;
-
-beforeEach(() => {
-  loader = TestbedHarnessEnvironment.loader(fixture);
-});
-
-it('dispara el guardado al hacer clic en el botón', async () => {
-  const button = await loader.getHarness(MatButtonHarness.with({ text: 'Save' }));
-  await button.click();
-  expect(saveSpy).toHaveBeenCalled();
-});
-```
-
-## Testing del router
-
-Usa `RouterTestingHarness` para componentes que dependen del router:
-
-```typescript
-import { RouterTestingHarness } from '@angular/router/testing';
-
-it('renderiza el usuario al navegar', async () => {
-  const harness = await RouterTestingHarness.create();
-  const component = await harness.navigateByUrl('/users/1', UserDetailComponent);
-  expect(component.userId()).toBe('1');
-});
-```
-
-## Testing asíncrono
-
-Usa `fakeAsync` + `tick` para asincronía controlada. Usa `waitForAsync` para asincronía real con `fixture.whenStable()`.
-
-```typescript
-it('carga el usuario tras el retraso', fakeAsync(() => {
-  const service = TestBed.inject(UserService);
-  vi.spyOn(service, 'getUser').mockReturnValue(of(mockUser));
-
-  fixture.detectChanges();
-  tick();
-  fixture.detectChanges();
-
-  expect(fixture.nativeElement.querySelector('.name').textContent).toBe(mockUser.name);
-}));
-```
-
-## Testing de HTTP
-
-```typescript
-import { provideHttpClientTesting } from '@angular/common/http/testing';
-import { HttpTestingController } from '@angular/common/http/testing';
-
-beforeEach(() => {
-  TestBed.configureTestingModule({
-    providers: [provideHttpClient(), provideHttpClientTesting()],
-  });
-  httpMock = TestBed.inject(HttpTestingController);
-});
-
-afterEach(() => httpMock.verify());
-```
-
-## Testing de servicios
-
-Inyecta los servicios directamente, sin fixture de componente:
-
-```typescript
-describe('UserService', () => {
-  let service: UserService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideHttpClient(), provideHttpClientTesting()],
-    });
-    service = TestBed.inject(UserService);
-  });
-});
-```
-
-## Qué probar
-
-- **Servicios**: todos los métodos públicos, rutas de error, interacciones HTTP
-- **Componentes**: enlaces de input/output, salida renderizada para los estados clave, interacciones del usuario mediante harnesses
-- **Pipes**: transformación pura — tests unitarios simples, sin TestBed
-- **Guards/Resolvers**: valores de retorno para estados permitidos y denegados usando `RouterTestingHarness`
-
-## Testing E2E
-
-Usa el framework E2E configurado del proyecto, como Cypress o Playwright, para los flujos de usuario críticos.
-
-```typescript
-describe('Flujo de inicio de sesión', () => {
-  it('redirige al dashboard con credenciales válidas', () => {
-    cy.visit('/login');
-    cy.get('[data-cy=email]').type('user@example.com');
-    cy.get('[data-cy=password]').type('password123');
-    cy.get('[data-cy=submit]').click();
-    cy.url().should('include', '/dashboard');
-  });
-});
-```
-
-- Añade atributos `data-cy` a los elementos interactivos para tener selectores estables
-- No dependas de clases CSS ni del contenido de texto como selectores en tests E2E
-
-## Cobertura
-
-Apunta a ≥80% en servicios y pipes. Componentes: prueba el comportamiento, no los detalles de implementación.
-
-## Referencia
-
-Consulta la skill `patrones-angular` para patrones de testing completos, uso de harnesses y buenas prácticas de asincronía.

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

@@ -1,153 +0,0 @@
----
-paths:
-  - "**/*.ets"
-  - "**/*.ts"
-  - "**/module.json5"
-  - "**/oh-package.json5"
-  - "**/build-profile.json5"
----
-# Estilo de código HarmonyOS / ArkTS
-
-> Este archivo extiende [common/coding-style.md](../common/coding-style.md) con contenido específico de HarmonyOS y ArkTS.
-
-## Restricciones del lenguaje ArkTS
-
-ArkTS es un subconjunto estricto y con tipado estático de TypeScript. Violar estas restricciones provoca **errores de compilación**.
-
-### Sistema de tipos
-
-- Nada de tipos `any` ni `unknown`: usa siempre tipos explícitos
-- Sin tipos de acceso por índice: usa los nombres de tipo directamente
-- Sin alias de tipos condicionales ni la palabra clave `infer`
-- Sin tipos intersección: usa herencia
-- Sin mapped types: usa clases e idiomas convencionales
-- Nada de `typeof` en anotaciones de tipo: usa declaraciones de tipo explícitas
-- Sin aserciones `as const`: usa anotaciones de tipo explícitas
-- Sin tipado estructural: usa herencia, interfaces o alias de tipo
-- Sin utility types de TypeScript excepto `Partial`, `Required`, `Readonly` y `Record`
-- Para `Record<K, V>`, el tipo de la expresión de índice es `V | undefined`
-- Omite la anotación de tipo en las cláusulas `catch` (ArkTS no admite `any`/`unknown`)
-
-### Funciones y clases
-
-- Sin expresiones de función: usa funciones flecha
-- Sin funciones anidadas: usa lambdas
-- Sin funciones generadoras: usa `async`/`await` para la multitarea
-- Nada de `Function.apply`, `Function.call` ni `Function.bind`: sigue la POO tradicional para `this`
-- Sin expresiones de tipo constructor: usa lambdas
-- Sin firmas de constructor en interfaces u object types: usa métodos o clases
-- No declares campos de clase en el constructor: decláralos en el cuerpo de la clase
-- Nada de `this` en funciones sueltas o métodos estáticos: solo en métodos de instancia
-- Sin `new.target`
-- Sin aserciones de asignación definitiva (`let v!: T`): usa declaraciones inicializadas
-- Sin literales de clase: introduce tipos de clase con nombre
-- No uses clases como objetos (asignarlas a variables): las declaraciones de clase introducen tipos, no valores
-- Solo un bloque estático por clase: fusiona todas las sentencias estáticas
-
-### Acceso a objetos y propiedades
-
-- Sin declaración dinámica de campos ni acceso `obj["field"]`: usa la sintaxis `obj.field`
-- Sin operador `delete`: usa un tipo nullable con `null` para marcar la ausencia
-- Sin asignación al prototipo: usa clases e interfaces
-- Sin operador `in`: usa `instanceof`
-- No reasignes métodos de objetos: usa funciones envoltorio o herencia
-- Sin la API `Symbol()` (excepto `Symbol.iterator`)
-- Sin `globalThis` ni ámbito global: usa exports/imports explícitos de módulo
-- Sin namespaces usados como objetos: usa clases o módulos
-- Sin sentencias dentro de namespaces: usa funciones
-
-### Desestructuración y spread
-
-- Sin asignaciones ni declaraciones de variables por desestructuración: usa objetos intermedios y acceso campo a campo
-- Sin desestructuración en la declaración de parámetros: pasa los parámetros directamente y asigna nombres locales a mano
-- El operador spread solo para expandir arrays (o clases derivadas de array) en parámetros rest o literales de array
-
-### Módulos e imports
-
-- Sin `require()`: usa la sintaxis `import` normal
-- Sin `export = ...`: usa export/import normales
-- Sin import assertions: en ArkTS los imports se resuelven en tiempo de compilación
-- Sin módulos UMD
-- Sin comodines en los nombres de módulo
-- Todas las sentencias `import` deben ir antes que cualquier otra sentencia
-- El código TypeScript no debe depender de código ArkTS vía import (la dirección inversa sí está soportada)
-
-### Otras restricciones
-
-- Nada de `var`: usa `let`
-- Sin bucles `for...in`: usa bucles `for` normales para arrays
-- Sin sentencias `with`
-- Sin expresiones JSX
-- Sin identificadores privados `#`: usa la palabra clave `private`
-- Sin declaration merging (clases, interfaces, enums): mantén las definiciones compactas
-- Sin index signatures: usa arrays
-- El operador coma solo en bucles `for`
-- Los operadores unarios `+`, `-`, `~` solo con tipos numéricos (sin conversión implícita de strings)
-- Miembros de enum: solo expresiones de tiempo de compilación del mismo tipo en los inicializadores explícitos
-- La inferencia del tipo de retorno de funciones es limitada: especifica el tipo de retorno explícitamente al llamar funciones que lo omiten
-
-### Literales de objeto
-
-- Solo se admiten cuando el compilador puede inferir la clase o interfaz correspondiente
-- NO se admiten para: tipos `any`/`Object`/`object`, clases o interfaces con métodos, clases con constructores parametrizados, clases con campos `readonly`
-
-## Convenciones de nombres
-
-- Variables / funciones: `camelCase` (p. ej., `getUserInfo`, `goodsList`)
-- Clases / interfaces: `PascalCase` (p. ej., `UserViewModel`, `IGoodsModel`)
-- Constantes: `UPPER_SNAKE_CASE` (p. ej., `MAX_PAGE_SIZE`, `COLOR_PRIMARY`)
-- Nombres de archivo: `PascalCase` para componentes (p. ej., `HomePage.ets`), `camelCase` para utilidades
-
-## Formato
-
-- Prefiere comillas dobles para strings
-- Punto y coma al final de cada sentencia
-- Nunca uses `var`: prefiere `const`, luego `let`
-- Todos los métodos, parámetros y valores de retorno deben tener anotaciones de tipo completas
-
-## Organización de archivos
-
-- Archivos de componente (`.ets`): un `@ComponentV2` por archivo
-- Archivos de ViewModel: una clase ViewModel por archivo
-- Archivos de modelo: los modelos de datos relacionados pueden compartir archivo
-- Mantén los archivos por debajo de 400 líneas; extrae helpers en archivos que se acerquen a 800 líneas
-
-## Comentarios
-
-- Cabecera de archivo: `@file` (propósito del archivo) + `@author` (desarrollador), si el proyecto ya usa cabeceras de archivo
-- Métodos públicos: JSDoc con `@param` y `@returns`; añade `@example` en métodos complejos
-- Ajusta el idioma de la documentación al ya existente en el proyecto; usa inglés salvo que el repositorio ya haya estandarizado comentarios en chino
-
-## Manejo de errores
-
-```typescript
-// Usa try/catch con un manejo de errores adecuado
-try {
-  const result = await riskyOperation()
-  return result
-} catch (error) {
-  hilog.error(0x0000, 'TAG', 'La operación falló: %{public}s', error)
-  throw new Error('Mensaje de error comprensible para el usuario')
-}
-```
-
-## Inmutabilidad
-
-Sigue los principios comunes de inmutabilidad: crea objetos nuevos en lugar de mutar los existentes.
-
-```typescript
-// INCORRECTO: mutación
-function updateUser(user: UserModel, name: string): UserModel {
-  user.name = name  // mutación directa
-  return user
-}
-
-// CORRECTO: inmutable - crear una instancia nueva
-function updateUser(user: UserModel, name: string): UserModel {
-  const updated = new UserModel()
-  updated.id = user.id
-  updated.name = name
-  updated.email = user.email
-  return updated
-}
-```