theus-cli-linux-arm64 0.2.84

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

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

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

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

@@ -0,0 +1,153 @@
+---
+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
+}
+```