theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/skills/seguridad-springboot/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: seguridad-springboot
+description: Buenas prácticas de Spring Security para servicios Java con Spring Boot — autenticación y autorización, validación de entrada, prevención de inyección SQL, CSRF, gestión de secretos, cabeceras de seguridad, CORS, rate limiting y seguridad de dependencias.
+---
+
+# Revisión de seguridad en Spring Boot
+
+Úsala al añadir autenticación, manejar entrada de usuarios, crear endpoints o trabajar con secretos.
+
+## Cuándo activarla
+
+- Añadir autenticación (JWT, OAuth2, basada en sesión)
+- Implementar autorización (`@PreAuthorize`, acceso basado en roles)
+- Validar entrada del usuario (Bean Validation, validadores personalizados)
+- Configurar CORS, CSRF o cabeceras de seguridad
+- Gestionar secretos (Vault, variables de entorno)
+- Añadir rate limiting o protección contra fuerza bruta
+- Escanear dependencias en busca de CVE
+
+## Autenticación
+
+- Prefiere JWT sin estado o tokens opacos con lista de revocación
+- Usa cookies `httpOnly`, `Secure`, `SameSite=Strict` para sesiones
+- Valida tokens con `OncePerRequestFilter` o un resource server
+
+```java
+@Component
+public class JwtAuthFilter extends OncePerRequestFilter {
+  private final JwtService jwtService;
+
+  public JwtAuthFilter(JwtService jwtService) {
+    this.jwtService = jwtService;
+  }
+
+  @Override
+  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
+      FilterChain chain) throws ServletException, IOException {
+    String header = request.getHeader(HttpHeaders.AUTHORIZATION);
+    if (header != null && header.startsWith("Bearer ")) {
+      String token = header.substring(7);
+      Authentication auth = jwtService.authenticate(token);
+      SecurityContextHolder.getContext().setAuthentication(auth);
+    }
+    chain.doFilter(request, response);
+  }
+}
+```
+
+## Autorización
+
+- Habilita la seguridad a nivel de método: `@EnableMethodSecurity`
+- Usa `@PreAuthorize("hasRole('ADMIN')")` o `@PreAuthorize("@authz.canEdit(#id)")`
+- Deniega por defecto; expón solo los scopes necesarios
+
+```java
+@RestController
+@RequestMapping("/api/admin")
+public class AdminController {
+
+  @PreAuthorize("hasRole('ADMIN')")
+  @GetMapping("/users")
+  public List<UserDto> listUsers() {
+    return userService.findAll();
+  }
+
+  @PreAuthorize("@authz.isOwner(#id, authentication)")
+  @DeleteMapping("/users/{id}")
+  public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
+    userService.delete(id);
+    return ResponseEntity.noContent().build();
+  }
+}
+```
+
+## Validación de entrada
+
+- Usa Bean Validation con `@Valid` en los controladores
+- Aplica restricciones en los DTO: `@NotBlank`, `@Email`, `@Size`, validadores personalizados
+- Sanitiza cualquier HTML con una lista blanca antes de renderizar
+
+```java
+// MAL: sin validación
+@PostMapping("/users")
+public User createUser(@RequestBody UserDto dto) {
+  return userService.create(dto);
+}
+
+// BIEN: DTO validado
+public record CreateUserDto(
+    @NotBlank @Size(max = 100) String name,
+    @NotBlank @Email String email,
+    @NotNull @Min(0) @Max(150) Integer age
+) {}
+
+@PostMapping("/users")
+public ResponseEntity<UserDto> createUser(@Valid @RequestBody CreateUserDto dto) {
+  return ResponseEntity.status(HttpStatus.CREATED)
+      .body(userService.create(dto));
+}
+```
+
+## Prevención de inyección SQL
+
+- Usa repositorios de Spring Data o consultas parametrizadas
+- Para consultas nativas, usa bindings `:param`; nunca concatenes strings
+
+```java
+// MAL: concatenación de strings en consulta nativa
+@Query(value = "SELECT * FROM users WHERE name = '" + name + "'", nativeQuery = true)
+
+// BIEN: consulta nativa parametrizada
+@Query(value = "SELECT * FROM users WHERE name = :name", nativeQuery = true)
+List<User> findByName(@Param("name") String name);
+
+// BIEN: consulta derivada de Spring Data (parametrizada automáticamente)
+List<User> findByEmailAndActiveTrue(String email);
+```
+
+## Cifrado de contraseñas
+
+- Hashea siempre las contraseñas con BCrypt o Argon2 — nunca las guardes en texto plano
+- Usa el bean `PasswordEncoder`, no hashing manual
+
+```java
+@Bean
+public PasswordEncoder passwordEncoder() {
+  return new BCryptPasswordEncoder(12); // factor de costo 12
+}
+
+// En el servicio
+public User register(CreateUserDto dto) {
+  String hashedPassword = passwordEncoder.encode(dto.password());
+  return userRepository.save(new User(dto.email(), hashedPassword));
+}
+```
+
+## Protección CSRF
+
+- Para apps de navegador con sesión, mantén CSRF habilitado; incluye el token en formularios/cabeceras
+- Para APIs puras con tokens Bearer, deshabilita CSRF y confía en la autenticación sin estado
+
+```java
+http
+  .csrf(csrf -> csrf.disable())
+  .sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS));
+```
+
+## Gestión de secretos
+
+- Nada de secretos en el código fuente; cárgalos desde el entorno o un vault
+- Mantén `application.yml` libre de credenciales; usa placeholders
+- Rota tokens y credenciales de base de datos con regularidad
+
+```yaml
+# MAL: hardcodeado en application.yml
+spring:
+  datasource:
+    password: mySecretPassword123
+
+# BIEN: placeholder de variable de entorno
+spring:
+  datasource:
+    password: ${DB_PASSWORD}
+
+# BIEN: integración con Spring Cloud Vault
+spring:
+  cloud:
+    vault:
+      uri: https://vault.example.com
+      token: ${VAULT_TOKEN}
+```
+
+## Cabeceras de seguridad
+
+```java
+http
+  .headers(headers -> headers
+    .contentSecurityPolicy(csp -> csp
+      .policyDirectives("default-src 'self'"))
+    .frameOptions(HeadersConfigurer.FrameOptionsConfig::sameOrigin)
+    .xssProtection(Customizer.withDefaults())
+    .referrerPolicy(rp -> rp.policy(ReferrerPolicyHeaderWriter.ReferrerPolicy.NO_REFERRER)));
+```
+
+## Configuración de CORS
+
+- Configura CORS a nivel del filtro de seguridad, no por controlador
+- Restringe los orígenes permitidos — nunca uses `*` en producción
+
+```java
+@Bean
+public CorsConfigurationSource corsConfigurationSource() {
+  CorsConfiguration config = new CorsConfiguration();
+  config.setAllowedOrigins(List.of("https://app.example.com"));
+  config.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE"));
+  config.setAllowedHeaders(List.of("Authorization", "Content-Type"));
+  config.setAllowCredentials(true);
+  config.setMaxAge(3600L);
+
+  UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+  source.registerCorsConfiguration("/api/**", config);
+  return source;
+}
+
+// En el SecurityFilterChain:
+http.cors(cors -> cors.configurationSource(corsConfigurationSource()));
+```
+
+## Rate limiting
+
+- Aplica Bucket4j o límites a nivel de gateway en los endpoints costosos
+- Registra y alerta ante ráfagas; devuelve 429 con indicaciones de reintento
+
+```java
+// Rate limiting por endpoint con Bucket4j
+@Component
+public class RateLimitFilter extends OncePerRequestFilter {
+  private final Map<String, Bucket> buckets = new ConcurrentHashMap<>();
+
+  private Bucket createBucket() {
+    return Bucket.builder()
+        .addLimit(Bandwidth.classic(100, Refill.intervally(100, Duration.ofMinutes(1))))
+        .build();
+  }
+
+  @Override
+  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
+      FilterChain chain) throws ServletException, IOException {
+    String clientIp = request.getRemoteAddr();
+    Bucket bucket = buckets.computeIfAbsent(clientIp, k -> createBucket());
+
+    if (bucket.tryConsume(1)) {
+      chain.doFilter(request, response);
+    } else {
+      response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
+      response.getWriter().write("{\"error\": \"Límite de peticiones excedido\"}");
+    }
+  }
+}
+```
+
+## Seguridad de dependencias
+
+- Ejecuta OWASP Dependency Check / Snyk en CI
+- Mantén Spring Boot y Spring Security en versiones con soporte
+- Haz fallar el build ante CVE conocidos
+
+## Logs y datos personales (PII)
+
+- Nunca registres secretos, tokens, contraseñas ni datos completos de tarjetas (PAN)
+- Redacta los campos sensibles; usa logging estructurado en JSON
+
+## Subida de archivos
+
+- Valida tamaño, tipo de contenido y extensión
+- Almacena fuera de la raíz web; escanea si es necesario
+
+## Checklist antes de publicar
+
+- [ ] Tokens de autenticación validados y con expiración correcta
+- [ ] Guardas de autorización en cada ruta sensible
+- [ ] Todas las entradas validadas y sanitizadas
+- [ ] Sin SQL concatenado con strings
+- [ ] Postura de CSRF correcta para el tipo de app
+- [ ] Secretos externalizados; ninguno commiteado
+- [ ] Cabeceras de seguridad configuradas
+- [ ] Rate limiting en las APIs
+- [ ] Dependencias escaneadas y actualizadas
+- [ ] Logs libres de datos sensibles
+
+**Recuerda**: deniega por defecto, valida las entradas, mínimo privilegio y seguridad por configuración primero.
+
+## Skills relacionadas
+
+- `patrones-springboot`
+- `tdd-springboot`
+- `verificacion-springboot`
+- `patrones-jpa`
+- `estandares-java`

package/vendor/theus-arsenal/skills/seo/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: seo
+description: Auditar, planificar e implementar mejoras de SEO en SEO técnico, optimización on-page, datos estructurados, Core Web Vitals, estrategia de contenido y visibilidad ante motores de IA (GEO). Usar cuando el usuario quiere mejor visibilidad en buscadores, remediación SEO, marcado schema, trabajo de sitemap/robots, llms.txt o mapeo de palabras clave.
+metadata:
+  origin: Theus
+---
+
+# SEO
+
+Mejorar la visibilidad en buscadores mediante corrección técnica, rendimiento y relevancia del contenido, no trucos.
+
+## Cuándo usarlo
+
+Usa este skill cuando:
+- audites rastreabilidad, indexabilidad, canonicals o redirecciones
+- mejores etiquetas title, meta descriptions y estructura de encabezados
+- añadas o valides datos estructurados
+- mejores los Core Web Vitals
+- hagas investigación de palabras clave y las mapees a URLs
+- planifiques enlazado interno o cambios de sitemap / robots
+- prepares el sitio para motores de respuesta de IA (GEO): llms.txt, directivas de robots para rastreadores de IA, datos citables
+
+## Cómo funciona
+
+### Principios
+
+1. Corrige los bloqueadores técnicos antes de optimizar el contenido.
+2. Una página debe tener una sola intención de búsqueda primaria clara.
+3. Prefiere señales de calidad a largo plazo antes que patrones manipulativos.
+4. Los supuestos mobile-first importan porque la indexación es mobile-first.
+5. Las recomendaciones deben ser específicas por página e implementables.
+6. Los motores de IA también leen tu sitio: los mismos hechos deben ser consistentes en todas las páginas para que las respuestas generadas te citen bien.
+
+### Checklist de SEO técnico
+
+#### Rastreabilidad
+
+- `robots.txt` debe permitir las páginas importantes y bloquear las superficies de bajo valor
+- ninguna página importante debe quedar en `noindex` sin querer
+- las páginas importantes deben ser alcanzables con una profundidad de clics baja
+- evita cadenas de redirección de más de dos saltos
+- las etiquetas canonical deben ser autoconsistentes y sin bucles
+
+#### Indexabilidad
+
+- el formato de URL preferido debe ser consistente
+- las páginas multilingües necesitan hreflang correcto si se usa
+- los sitemaps deben reflejar la superficie pública prevista
+- ninguna URL duplicada debe competir sin control canonical
+
+#### Rendimiento
+
+- LCP < 2.5s
+- INP < 200ms
+- CLS < 0.1
+- correcciones habituales: precargar los assets del hero, reducir el trabajo que bloquea el renderizado, reservar espacio de layout, recortar JS pesado
+
+#### Datos estructurados
+
+- página de inicio: schema de organización o negocio cuando corresponda
+- páginas editoriales: `Article` / `BlogPosting`
+- páginas de producto: `Product` y `Offer`
+- páginas interiores: `BreadcrumbList`
+- secciones de preguntas y respuestas: `FAQPage` solo cuando el contenido realmente coincida
+
+#### GEO — visibilidad ante motores de IA
+
+Los motores de respuesta de IA (buscadores conversacionales, asistentes que citan fuentes) rastrean y sintetizan tu sitio. Trátalos como una superficie de indexación adicional:
+
+- publica un `llms.txt` en la raíz del sitio: un resumen en Markdown de qué es el sitio, sus páginas clave y los hechos canónicos (cifras de producto, precios, propuesta de valor) que quieres que las respuestas generadas reproduzcan
+- decide de forma explícita en `robots.txt` qué rastreadores de asistentes de IA permites o bloqueas — no lo dejes al azar; permitir el rastreo de las páginas públicas de venta suele convenir, bloquear áreas privadas siempre
+- mantén una "cifra canónica" única para cada hecho clave (número de modelos, precios, métricas) y úsala idéntica en todas las páginas, el JSON-LD y el llms.txt; las inconsistencias producen citas erróneas
+- el JSON-LD funciona como verdad legible por máquina: los motores de IA lo usan para desambiguar entidades — cuida `Organization`, `FAQPage` y `Product` especialmente
+- las secciones `FAQPage` con preguntas reales y respuestas directas y autocontenidas son las más fáciles de citar textualmente por un motor de IA
+- completa los metadatos Open Graph (`og:title`, `og:description`, `og:image`) — varios motores de respuesta los usan como resumen de la página
+
+### Reglas on-page
+
+#### Etiquetas title
+
+- apunta a unos 50-60 caracteres
+- coloca la palabra clave o el concepto primario cerca del inicio
+- haz el título legible para humanos, no relleno para bots
+
+#### Meta descriptions
+
+- apunta a unos 120-160 caracteres
+- describe la página con honestidad
+- incluye el tema principal de forma natural
+
+#### Estructura de encabezados
+
+- un solo `H1` claro
+- los `H2` y `H3` deben reflejar la jerarquía real del contenido
+- no te saltes la estructura solo por estilo visual
+
+### Mapeo de palabras clave
+
+1. define la intención de búsqueda
+2. reúne variantes realistas de palabras clave
+3. prioriza por coincidencia de intención, valor probable y competencia
+4. mapea una palabra clave/tema primario a una URL
+5. detecta y evita la canibalización
+
+### Enlazado interno
+
+- enlaza desde páginas fuertes hacia las páginas que quieres posicionar
+- usa texto ancla descriptivo
+- evita anclas genéricas cuando exista una más específica
+- añade retroactivamente enlaces desde las páginas nuevas hacia las existentes relevantes
+
+## Ejemplos
+
+### Fórmula de title
+
+```text
+Tema principal - Modificador específico | Marca
+```
+
+### Fórmula de meta description
+
+```text
+Acción + tema + propuesta de valor + un detalle de apoyo
+```
+
+### Ejemplo de JSON-LD
+
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "Título de la página aquí",
+  "author": {
+    "@type": "Person",
+    "name": "Nombre del autor"
+  },
+  "publisher": {
+    "@type": "Organization",
+    "name": "Nombre de la marca"
+  }
+}
+```
+
+### Forma de salida de una auditoría
+
+```text
+[ALTA] Etiquetas title duplicadas en páginas de producto
+Ubicación: src/routes/products/[slug].tsx
+Problema: los títulos dinámicos colapsan a la misma cadena por defecto, lo que debilita la relevancia y crea señales duplicadas.
+Corrección: generar un title único por producto usando el nombre del producto y su categoría primaria.
+```
+
+## Antipatrones
+
+| Antipatrón | Corrección |
+| --- | --- |
+| relleno de palabras clave (keyword stuffing) | escribe primero para las personas |
+| páginas delgadas casi duplicadas | consolídalas o diferéncialas |
+| schema para contenido que no está realmente presente | haz que el schema coincida con la realidad |
+| consejos de contenido sin revisar la página real | lee primero la página real |
+| salidas genéricas de "mejorar el SEO" | ata cada recomendación a una página o asset |
+| hechos clave distintos según la página | fija una cifra canónica y úsala en todo el sitio y en llms.txt |
+
+## Skills relacionados
+
+- `patrones-frontend`

package/vendor/theus-arsenal/skills/sistema-diseno/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: sistema-diseno
+description: Usa esta skill para generar o auditar sistemas de diseño, verificar consistencia visual y revisar PRs que tocan estilos.
+---
+
+# Sistema de diseño — Generar y auditar sistemas visuales
+
+## Cuándo usarla
+
+- Al iniciar un proyecto nuevo que necesita un sistema de diseño
+- Al auditar un código existente en busca de consistencia visual
+- Antes de un rediseño — para entender lo que ya tienes
+- Cuando la interfaz se ve "rara" pero no puedes señalar por qué
+- Al revisar PRs que tocan estilos
+
+## Cómo funciona
+
+### Modo 1: Generar sistema de diseño
+
+Analiza tu código y genera un sistema de diseño cohesivo:
+
+```
+1. Escanear CSS/Tailwind/styled-components en busca de patrones existentes
+2. Extraer: colores, tipografía, espaciado, border-radius, sombras, breakpoints
+3. Investigar 3 sitios de la competencia como inspiración (vía MCP de navegador)
+4. Proponer un conjunto de design tokens (JSON + propiedades personalizadas de CSS)
+5. Generar DESIGN.md con la justificación de cada decisión
+6. Crear una página HTML de vista previa interactiva (autocontenida, sin dependencias)
+```
+
+Salida: `DESIGN.md` + `design-tokens.json` + `design-preview.html`
+
+### Modo 2: Auditoría visual
+
+Puntúa tu interfaz en 10 dimensiones (0-10 cada una):
+
+```
+1. Consistencia de color — ¿usas tu paleta o valores hex aleatorios?
+2. Jerarquía tipográfica — ¿hay un orden claro h1 > h2 > h3 > cuerpo > leyenda?
+3. Ritmo de espaciado — ¿escala consistente (4px/8px/16px) o valores arbitrarios?
+4. Consistencia de componentes — ¿los elementos similares se ven similares?
+5. Comportamiento responsive — ¿fluido o roto en los breakpoints?
+6. Modo oscuro — ¿completo o a medias?
+7. Animación — ¿con propósito o gratuita?
+8. Accesibilidad — ratios de contraste, estados de foco, áreas táctiles
+9. Densidad de información — ¿saturada o limpia?
+10. Acabado — estados hover, transiciones, estados de carga, estados vacíos
+```
+
+Cada dimensión recibe una puntuación, ejemplos concretos y una corrección con archivo:línea exactos.
+
+### Modo 3: Detección de "diseño genérico de IA"
+
+Identifica patrones de diseño genéricos típicos de generación con IA:
+
+```
+- Degradados gratuitos en todo
+- Paletas morado-a-azul por defecto
+- Tarjetas de "glass morphism" sin propósito
+- Esquinas redondeadas en cosas que no deberían estar redondeadas
+- Animaciones excesivas al hacer scroll
+- Hero genérico con texto centrado sobre un degradado de stock
+- Pila de fuentes sans-serif sin personalidad
+```
+
+## Ejemplos
+
+**Generar para una app SaaS:**
+```
+/sistema-diseno generate --style minimal --palette earth-tones
+```
+
+**Auditar una interfaz existente:**
+```
+/sistema-diseno audit --url http://localhost:3000 --pages / /precios /docs
+```
+
+**Detectar diseño genérico de IA:**
+```
+/sistema-diseno slop-check
+```