@mammals-at-work/yacs 0.8.8 → 0.9.0

package/agents/README.an.md

@@ -0,0 +1,196 @@
+# Agentes YACS
+
+Agentes especializaos pa Claude Code. Caá agente tié conosimientu profundu de su dominio e implementa buenya prátigas e su área.
+
+## ¿Qué son los agentes?
+
+Los agentes son personas expertas persistentes que:
+- Aprendie la estructura de tu proiecto e la primera invocasión
+- Mantiene experiencia e conversaciones dientro de una sesión
+- Pueen ser invocaos explícitamente o activaos automáticamente por Claude Code
+- Proporcionan recomendaciones anchadas en tu código real
+- Implementan principios y patrones específicos del dominio
+
+A diferensia de las skills (comanuos puntuales), los agentes son conscientes del contexto y con estau.
+
+## Agentes
+
+### 🏢 Experto en Backend (`backend-expert/`)
+Se espeshializa en arquitektura del serviador: APIs, servishios, modelos de datos, autentifikashión y rendemiento.
+
+**Cuandu usalo:**
+- Revisar diseño de API o contratos de endpoints
+- Diseñar esquemas de base de datos o patrones de acceso a datos
+- Implementar autentifikashión, autorizashión o middleware de seguriau
+- Optimizar queries, estratejias de caché o patrones asincronos
+- Investigar bugs en servishios o repositorios
+
+**Prinsipios clave:**
+- Sin lógica de negosio en kontroladores; toa la lógica en servishios
+- Valibashión en el límite (valibashión de entrá antes de servishios)
+- Sin queries raw cuando hay ORM disponible
+- Secretos nunca hardkodeaos; siempre xestionaos vía variables de entorno
+
+### 🎨 Experto en Frontend (`frontend-expert/`)
+Se espeshializa en UI: komponentes, xestión de estau, enrutamiento, estilos, aksesibiliau y rendemiento.
+
+**Cuandu usalo:**
+- Diseñar jerarquías de komponentes o APIs de props
+- Implementar formularios con valibashión y estados de erro
+- Konfigurar xestión de estau (Context, Redux, Zustand, etá.)
+- Optimizar el rendemiento (lazy loading, memoizashión, code splitting)
+- Asegurar estándares de aksesibiliau (a11y)
+- Revisar enfoque de estilos y diseño responsivo
+
+**Prinsipios clave:**
+- Los komponentes renderizan UI y manexan la interaksión; lógica de negosio en hooks/stores
+- Sin prop drilling máis allá de 2 niveles; usar context o stores en su lugá
+- Toa búsquea de datos requiere estados de loading, error y success
+- La aksesibiliau es innegoshiable; navegashión por teclau y soporte pa lectoris de pantalla requirío
+- Patrones konstantes en toa la base de código
+
+### 🔐 Experto en Seguriau (`security-expert/`)
+Audita vulnerabilidades, konfigurashiones inkorrecktas y antipatrones de seguriau en toas las capas.
+
+**Cuandu usalo:**
+- Revisiones de seguriau pre-merge
+- Antes de releases o deployments
+- Cuandu implementar autentifikashión, autorizashión o kriptografía
+- Revisar dependenshias de terseros o kadena de subministración
+- Modelaje de amenazas antes de una nueya karakterística
+- Investigashión de inshidentes
+
+**Prinsipios clave:**
+- Secretos nunka en código, logs o respuestas de erro
+- Los chequeos de autorizashión niegan por defektu (deny > allow)
+- Toa entrá valiá en los límites del sistema
+- Usa solo kriptografía verifiká (sin krear la tuya propria)
+- Los errores fallen de forma segura sin exponer internals
+- Defensa en profundíu: sin punto único de fallo
+
+### ☁️ Experto en Infraestructura (`infra-expert/`)
+Se espeshializa en despliegue, CI/CD, kontainerización, IaC, recursos cloud y operashiones.
+
+**Cuandu usalo:**
+- Diseñar o revisar pipelines de CI/CD
+- Konstruir Dockerfiles y setups de compose
+- Escribir Terraform, Pulumi u otra IaC
+- Konfigurar manifests de Kubernetes
+- Konfigurar observabiliau (logging, métricas, tracing)
+- Xestionar konfiguración de entorno y secretos
+- Diseñar pa konfiabiliau, eskalabiliau y reuperashión de desastres
+
+**Prinsipios clave:**
+- Secretos xestionaos vía secret managers; nunka en imaxenes o código
+- Infraestrutura inmutable: sustituir en lugá de mutar
+- Los entornos deben ser reprodusibles dende código
+- Health checks (liveness y readiness) son obligatorios
+- Prinsipiu de menó privilexiu en IAM, kontas de servishiu y políticas de reu
+- Los pipelines fallen rápido: lint y tests unitarios antes de pasos kostosos
+
+### 🧪 Experto en QA (`qa-expert/`)
+Se espeshializa en estratejia de testing, análisis de kobertura, kaliau de tests e investigashión de bugs.
+
+**Cuandu usalo:**
+- Diseñar estratejias de testing (qué testeá en caá nivel)
+- Analizar buecos de kobertura
+- Investigar fallos de test o flakiness
+- Revisar código de test por kaliau y mantenibiliau
+- Diseñar tests pa una nueya karakterística
+- Analizar causas raíz de bugs reportaos
+
+**Prinsipios clave:**
+- Los tests verifikan komportamiento, no detalles de implementashión
+- Caá test tié una razón pa fallar
+- Pirámide de testing: unit >> integration >> E2E
+- Mocks pa sistemas externos, no tu propio código
+- Too bug arrangao obtié un test de regreshión
+- La kobertura es un piso, no una meta (100% tests malos < 80% tests buenos)
+
+## Instalasiń
+
+### Opshión 1: Kopiar a tu proiecto
+
+Kopie agentes individuales o toos a `.claude/agents/`:
+
+```bash
+# Kopiar un agente
+cp -r YACS/agents/backend-expert ~/.claude/agents/
+
+# Kopiar toos los agentes
+cp -r YACS/agents/* ~/.claude/agents/
+```
+
+### Opshión 2: Referenciar dende el repositorio YACS
+
+Si tié YACS klonao lokalmente, puea referenciar caminos de agentes direktamente en Claude Code sin kopiar.
+
+## Usandu Agentes
+
+### Invokashión explíshita
+
+Pídale a Claude Code que use un agente específiko:
+
+```
+@backend-expert revisa el servishiu de usuario por queries N+1
+Usa infra-expert pa analizar este Dockerfile
+security-expert, audita este flujo de autentifikashión
+qa-expert, ¿qué tests faltan pa esta karakterística?
+```
+
+### Aktivashión proaktiva
+
+Claude Code puea aktivar automáticamente agentes relevantes basaos en el kontexto. Por ejemplo:
+- Preguntá sobre diseño de API puea aktivar `backend-expert`
+- Diskutir arquitektura de komponentes puea aktivar `frontend-expert`
+- Revisar un fichero Kubernetes puea aktivar `infra-expert`
+- Una preokupashión de seguriau puea aktivar `security-expert`
+- Diskutir tests puea aktivar `qa-expert`
+
+## Estrutura del Agente
+
+Caá agente es un único fichero `AGENT.md` con:
+
+```yaml
+---
+name: <agent-name>
+description: <qué aktivá este agente>
+---
+
+## Onboarding
+[kómo el agente aprendia tu proiecto]
+
+## Expertise
+[qué kubreá el agente]
+
+## How to respond
+[direktrises de respuesta]
+
+## Principles
+[prinsipios específicos del dominio a implementá]
+```
+
+El kampu `description` dile a Claude Code kuandu konsidar aktivá el agente.
+
+## Kreandu Agentes Personalizaos
+
+Puea kreá agentes específicos del proiecto en su direktorio `.claude/agents/`. Siga el mesmo formato `AGENT.md`:
+
+1. Kree `~/.claude/agents/<agent-name>/AGENT.md`
+2. Use frontmatter YAML con `name`, `description`
+3. Inluya onboarding, expertise, direktrises de respuesta y prinsipios
+4. Claude Code destkubrirá y oferecerá el agente automáticamente
+
+Ejemplo: Un `database-expert` pa tu kapa de datos específika del proiecto, o un `team-conventions-agent` que implemente la guía de estilo de tu equipo.
+
+## Notas
+
+- Toas las definishiones de agentes están en ficheros `.md` con frontmatter YAML
+- Los agentes son konshientes del proiecto: leen tu base de código antes de akonsehar
+- Caá agente tié triggers específikos definios en su `description`
+- Los agentes trabajan al lau del razonamiento integrao de Claude Code
+- Mesture agentes de YACS con agentes personalizaos específicos del proiecto según seya neséario
+
+---
+
+¿Preguntas o quía kontribuir agentes? Abra una issue o PR en [GitHub](https://github.com/munchkin09/YACS).

package/agents/README.ca.md

@@ -0,0 +1,196 @@
+# Agents YACS
+
+Agents especialitzats per a Claude Code. Cada agent té un coneixement profund del seu domini i implementa bones pràctiques dins de la seva àrea.
+
+## Què són els agents?
+
+Els agents són personas expertes persistents que:
+- Aprenen l'estructura del vostre projecte en la primera invocació
+- Mantenen la seva expertesa durant conversations dins d'una sessió
+- Poden ser invocats explícitament o activats automàticament per Claude Code
+- Proporcionen recomanacions ancorades al vostre codi real
+- Implementen principis i patrons específics del domini
+
+A diferència de les skills (comandos puntuals), els agents són conscients del context i amb estat.
+
+## Agents
+
+### 🏢 Expert en Backend (`backend-expert/`)
+S'especialitza en arquitectura del servidor: APIs, serveis, models de dades, autenticació i rendiment.
+
+**Quan usar-lo:**
+- Revisar el disseny d'API o els contractes d'endpoints
+- Dissenyar esquemes de base de dades o patrons d'accés a dades
+- Implementar autenticació, autorització o middleware de seguretat
+- Optimitzar queries, estratègies de caché o patrons asincronats
+- Investigar bugs en serveis o repositoris
+
+**Principis clau:**
+- Cap lògica de negoci en controladors; tota la lògica en serveis
+- Validació en el límit (validació d'entrada abans de serveis)
+- Cap query raw quan hi ha ORM disponible
+- Secrets mai hardcodeados; sempre gestionats per variables d'entorn
+
+### 🎨 Expert en Frontend (`frontend-expert/`)
+S'especialitza en UI: components, gestió d'estat, enrutament, estils, accessibilitat i rendiment.
+
+**Quan usar-lo:**
+- Dissenyar jerarquies de components o APIs de props
+- Implementar formularis amb validació i estats d'error
+- Configurar gestió d'estat (Context, Redux, Zustand, etc.)
+- Optimitzar el rendiment (lazy loading, memoització, code splitting)
+- Assegurar estàndards d'accessibilitat (a11y)
+- Revisar enfocaments d'estils i disseny responsiu
+
+**Principis clau:**
+- Els components renderizan UI i gestionen la interacció; la lògica de negoci està en hooks/stores
+- Cap prop drilling més allà de 2 nivells; usar context o stores en lloc d'això
+- Tota cerca de dades requereix estats de loading, error i success
+- L'accessibilitat és innegociable; navegació per teclat i suport per lectors de pantalla requerits
+- Patrons consistents en tota la base de codi
+
+### 🔐 Expert en Seguretat (`security-expert/`)
+Audita vulnerabilitats, configuracions incorrectes i antipatrons de seguretat a totes les capes.
+
+**Quan usar-lo:**
+- Revisions de seguretat pre-merge
+- Abans de releases o deployments
+- Quan implementar autenticació, autorització o criptografia
+- Revisar dependències de tercers o cadena de subministrament
+- Modelat de amenaces abans d'una nova característica
+- Investigació d'incidents
+
+**Principis clau:**
+- Secrets mai en codi, logs o respostes d'error
+- Les verificacions d'autorització denyen per defecte (deny > allow)
+- Tota entrada validada als límits del sistema
+- Usa només criptografia verificada (sense crear la vostra pròpia)
+- Els errors fallen de forma segura sense exposar internals
+- Defensa en profunditat: cap punt únic de fallada
+
+### ☁️ Expert en Infraestructura (`infra-expert/`)
+S'especialitza en desplegament, CI/CD, containerització, IaC, recursos cloud i operacions.
+
+**Quan usar-lo:**
+- Dissenyar o revisar pipelines de CI/CD
+- Construir Dockerfiles i setups de compose
+- Escriure Terraform, Pulumi o altre IaC
+- Configurar manifests de Kubernetes
+- Configurar observabilitat (logging, mètriques, tracing)
+- Gestionar configuració d'entorn i secrets
+- Dissenyar per a confiabilitat, escalabilitat i recuperació de desastres
+
+**Principis clau:**
+- Secrets gestionats via secret managers; mai en imatges o codi
+- Infraestructura immutable: reemplaçar en lloc de mutar
+- Els entorns han de ser reproducibles a partir de codi
+- Health checks (liveness i readiness) són obligatoris
+- Principi de menor privilegi en IAM, comptes de servei i polítiques de xarxa
+- Els pipelines fallen ràpidament: lint i tests unitaris abans de pasos costosos
+
+### 🧪 Expert en QA (`qa-expert/`)
+S'especialitza en estratègia de testing, anàlisi de cobertura, qualitat de tests i investigació de bugs.
+
+**Quan usar-lo:**
+- Dissenyar estratègies de testing (què testejar en cada nivell)
+- Analitzar buits de cobertura
+- Investigar falles de test o flakiness
+- Revisar codi de test per qualitat i mantenibilitat
+- Dissenyar tests per a una nova característica
+- Analitzar causes arrel de bugs reportats
+
+**Principis clau:**
+- Els tests verifiquen comportament, no detalls d'implementació
+- Cada test té una raó per fallar
+- Piràmide de testing: unit >> integration >> E2E
+- Mocks per a sistemes externs, no el vostre propi codi
+- Tot bug arreglat obté un test de regressió
+- La cobertura és un pis, no una meta (100% tests dolents < 80% tests bons)
+
+## Instal·lació
+
+### Opció 1: Copiar al vostre projecte
+
+Copieu agents individuals o tots a `.claude/agents/`:
+
+```bash
+# Copiar un agent
+cp -r YACS/agents/backend-expert ~/.claude/agents/
+
+# Copiar tots els agents
+cp -r YACS/agents/* ~/.claude/agents/
+```
+
+### Opció 2: Referenciar des del repositori YACS
+
+Si teniu YACS clonat localment, podeu referenciar camins d'agents directament a Claude Code sense copiar.
+
+## Usant Agents
+
+### Invocació explícita
+
+Demaneu a Claude Code que usi un agent específic:
+
+```
+@backend-expert revisa el servei d'usuari per queries N+1
+Usa infra-expert per analitzar aquest Dockerfile
+security-expert, audita aquest flux d'autenticació
+qa-expert, quins tests falten per a aquesta característica?
+```
+
+### Activació proactiva
+
+Claude Code pot activar automàticament agents rellevants basats en el context. Per exemple:
+- Preguntar sobre disseny d'API pot activar `backend-expert`
+- Discutir arquitectura de components pot activar `frontend-expert`
+- Revisar un fitxer Kubernetes pot activar `infra-expert`
+- Una preocupació de seguretat pot activar `security-expert`
+- Discutir tests pot activar `qa-expert`
+
+## Estructura del Agent
+
+Cada agent és un únic fitxer `AGENT.md` amb:
+
+```yaml
+---
+name: <agent-name>
+description: <què activa aquest agent>
+---
+
+## Onboarding
+[com l'agent aprèn el vostre projecte]
+
+## Expertise
+[què cobreix l'agent]
+
+## How to respond
+[directrius de resposta]
+
+## Principles
+[principis específics del domini a implementar]
+```
+
+El camp `description` diu a Claude Code quan considerar activar l'agent.
+
+## Creant Agents Personalitzats
+
+Podeu crear agents específics del projecte al vostre directori `.claude/agents/`. Seguiu el mateix format `AGENT.md`:
+
+1. Creeu `~/.claude/agents/<agent-name>/AGENT.md`
+2. Useu frontmatter YAML amb `name`, `description`
+3. Incloeu onboarding, expertise, directrius de resposta i principis
+4. Claude Code descobrirà i oferirà l'agent automàticament
+
+Exemple: Un `database-expert` per a la vostra capa de dades específica del projecte, o un `team-conventions-agent` que implementi la guia d'estil del vostre equip.
+
+## Notes
+
+- Totes les definicions d'agents estan en fitxers `.md` amb frontmatter YAML
+- Els agents són conscients del projecte: llegeixen la vostra base de codi abans de aconsellar
+- Cada agent té triggers específics definits en la seva `description`
+- Els agents treballen juntament amb el raonament integrat de Claude Code
+- Barrejeu agents de YACS amb agents personalitzats específics del projecte segons sigui necessari
+
+---
+
+Preguntes o voleu contribuir agents? Obriu una issue o PR a [GitHub](https://github.com/munchkin09/YACS).

package/agents/README.es.md

@@ -0,0 +1,196 @@
+# Agentes YACS
+
+Agentes especializados para Claude Code. Cada agente tiene conocimiento profundo del dominio e implementa buenas prácticas dentro de su área.
+
+## ¿Qué son los agentes?
+
+Los agentes son personas expertas persistentes que:
+- Aprenden la estructura de tu proyecto en la primera invocación
+- Mantienen experiencia en conversaciones dentro de una sesión
+- Pueden ser invocados explícitamente o activados automáticamente por Claude Code
+- Proporcionan recomendaciones ancladas en tu código real
+- Implementan principios y patrones específicos del dominio
+
+A diferencia de las skills (comandos puntuales), los agentes son contextuales y con estado.
+
+## Agentes
+
+### 🏢 Experto Backend (`backend-expert/`)
+Se especializa en arquitectura del servidor: APIs, servicios, modelos de datos, autenticación y performance.
+
+**Cuándo usarlo:**
+- Revisar diseño de API o contratos de endpoints
+- Diseñar esquemas de base de datos o patrones de acceso a datos
+- Implementar autenticación, autorización o middleware de seguridad
+- Optimizar queries, estrategias de caché o patrones asincronos
+- Investigar bugs en servicios o repositorios
+
+**Principios clave:**
+- Sin lógica de negocio en controladores; toda la lógica en servicios
+- Validación en el límite (validación de entrada antes de servicios)
+- Sin queries raw cuando hay ORM disponible
+- Secretos nunca hardcodeados; siempre gestionados vía variables de entorno
+
+### 🎨 Experto Frontend (`frontend-expert/`)
+Se especializa en UI: componentes, gestión de estado, enrutamiento, estilos, accesibilidad y performance.
+
+**Cuándo usarlo:**
+- Diseñar jerarquías de componentes o APIs de props
+- Implementar formularios con validación y estados de error
+- Configurar gestión de estado (Context, Redux, Zustand, etc.)
+- Optimizar performance (lazy loading, memoización, code splitting)
+- Asegurar estándares de accesibilidad (a11y)
+- Revisar enfoques de estilos y diseño responsivo
+
+**Principios clave:**
+- Componentes renderizan UI e manejan interacción; lógica de negocio en hooks/stores
+- Sin prop drilling más allá de 2 niveles; usar context o stores en su lugar
+- Toda búsqueda de datos requiere estados loading, error y success
+- Accesibilidad es innegociable; navegación por teclado y soporte para lectores de pantalla requerido
+- Patrones consistentes en toda la base de código
+
+### 🔐 Experto Seguridad (`security-expert/`)
+Audita vulnerabilidades, configuraciones erróneas y antipatrones de seguridad en todas las capas.
+
+**Cuándo usarlo:**
+- Revisiones de seguridad pre-merge
+- Antes de releases o despliegues
+- Cuando implementas autenticación, autorización o criptografía
+- Revisar dependencias de terceros o cadena de suministro
+- Modelado de amenazas antes de una nueva feature
+- Investigación de incidentes
+
+**Principios clave:**
+- Secretos nunca en código, logs o respuestas de error
+- Chequeos de autorización niegan por defecto (deny > allow)
+- Toda entrada validada en límites del sistema
+- Usa solo criptografía verificada (sin crear tu propia)
+- Errores fallan de forma segura sin exponer internals
+- Defensa en profundidad: sin punto único de fallo
+
+### ☁️ Experto Infraestructura (`infra-expert/`)
+Se especializa en despliegue, CI/CD, contenedorización, IaC, recursos cloud y operaciones.
+
+**Cuándo usarlo:**
+- Diseñar o revisar pipelines de CI/CD
+- Construir Dockerfiles y setups de compose
+- Escribir Terraform, Pulumi u otra IaC
+- Configurar manifiestos de Kubernetes
+- Configurar observabilidad (logging, métricas, tracing)
+- Gestionar configuración de entorno y secretos
+- Diseñar para confiabilidad, escalado y recuperación ante desastres
+
+**Principios clave:**
+- Secretos gestionados vía secret managers; nunca en imágenes o código
+- Infraestructura inmutable: reemplazar en lugar de mutar
+- Entornos deben ser reproducibles desde código
+- Health checks (liveness y readiness) son obligatorios
+- Principio de menor privilegio en IAM, service accounts y políticas de red
+- Pipelines fallan rápido: lint y unit tests antes de pasos costosos
+
+### 🧪 Experto QA (`qa-expert/`)
+Se especializa en estrategia de testing, análisis de cobertura, calidad de tests e investigación de bugs.
+
+**Cuándo usarlo:**
+- Diseñar estrategias de testing (qué testear en cada nivel)
+- Analizar gaps de cobertura
+- Investigar fallos de tests o flakiness
+- Revisar código de tests por calidad y mantenibilidad
+- Diseñar tests para una nueva feature
+- Analizar causas raíz de bugs reportados
+
+**Principios clave:**
+- Tests verifican comportamiento, no detalles de implementación
+- Cada test tiene una razón para fallar
+- Pirámide de testing: unit >> integration >> E2E
+- Mocks para sistemas externos, no tu propio código
+- Todo bug arreglado obtiene un test de regresión
+- Cobertura es un piso, no una meta (100% tests malos < 80% tests buenos)
+
+## Instalación
+
+### Opción 1: Copiar a tu proyecto
+
+Copia agentes individuales o todos a `.claude/agents/`:
+
+```bash
+# Copiar un agente
+cp -r YACS/agents/backend-expert ~/.claude/agents/
+
+# Copiar todos los agentes
+cp -r YACS/agents/* ~/.claude/agents/
+```
+
+### Opción 2: Referenciar desde repositorio YACS
+
+Si tienes YACS clonado localmente, puedes referenciar rutas de agentes directamente en Claude Code sin copiar.
+
+## Usando Agentes
+
+### Invocación explícita
+
+Pídele a Claude Code que use un agente específico:
+
+```
+@backend-expert revisa el servicio de usuario por queries N+1
+Usa infra-expert para analizar este Dockerfile
+security-expert, audita este flujo de autenticación
+qa-expert, qué tests faltan para esta feature?
+```
+
+### Activación proactiva
+
+Claude Code puede activar automáticamente agentes relevantes basado en contexto. Por ejemplo:
+- Preguntar sobre diseño de API puede activar `backend-expert`
+- Discutir arquitectura de componentes puede activar `frontend-expert`
+- Revisar un archivo de Kubernetes puede activar `infra-expert`
+- Una preocupación de seguridad puede activar `security-expert`
+- Discutir tests puede activar `qa-expert`
+
+## Estructura del Agente
+
+Cada agente es un único archivo `AGENT.md` con:
+
+```yaml
+---
+name: <agent-name>
+description: <qué activa este agente>
+---
+
+## Onboarding
+[cómo el agente aprende tu proyecto]
+
+## Expertise
+[qué cubre el agente]
+
+## How to respond
+[guías de respuesta]
+
+## Principles
+[principios específicos del dominio a implementar]
+```
+
+El campo `description` le dice a Claude Code cuándo considerar activar el agente.
+
+## Creando Agentes Personalizados
+
+Puedes crear agentes específicos del proyecto en tu directorio `.claude/agents/`. Sigue el mismo formato `AGENT.md`:
+
+1. Crea `~/.claude/agents/<agent-name>/AGENT.md`
+2. Usa frontmatter YAML con `name`, `description`
+3. Incluye onboarding, expertise, guías de respuesta, y principios
+4. Claude Code descubrirá y ofrecerá el agente automáticamente
+
+Ejemplo: Un `database-expert` para tu data layer específica del proyecto, o un `team-conventions-agent` que implemente la guía de estilo de tu equipo.
+
+## Notas
+
+- Todas las definiciones de agentes están en archivos `.md` con frontmatter YAML
+- Los agentes son project-aware: leen tu base de código antes de aconsejar
+- Cada agente tiene triggers específicos definidos en su `description`
+- Los agentes trabajan junto con el razonamiento integrado de Claude Code
+- Mezcla agentes de YACS con agentes personalizados específicos del proyecto según sea necesario
+
+---
+
+¿Preguntas o quieres contribuir agentes? Abre un issue o PR en [GitHub](https://github.com/munchkin09/YACS).