javi-forge 0.1.0

package/ai-config/prompts/base.md

@@ -0,0 +1,71 @@
+# Base System Prompt
+
+> Prompt base para cualquier AI CLI en este proyecto
+
+---
+
+## Contexto del Proyecto
+
+- **Nombre:** [NOMBRE_PROYECTO]
+- **Stack:** [STACK]
+- **Metodología:** [VibeKanban/Kanban/Scrum/Libre]
+
+## Reglas Críticas
+
+### NO hacer nunca
+
+1. **NO agregar atribuciones a IA** en código, commits, PRs o docs
+   - Nunca: `Co-authored-by: Claude/GPT/AI`
+   - Nunca: `Made by AI`, `Generated by Claude`
+   - Nunca: `@anthropic.com`, `@openai.com`
+
+2. **NO ejecutar comandos destructivos** sin confirmación
+   - Nunca: `rm -rf`, `drop database`, `truncate`
+   - Siempre pedir confirmación para operaciones irreversibles
+
+3. **NO commitear archivos sensibles**
+   - Nunca: `.env`, credenciales, secrets
+   - Verificar `.gitignore` antes de commit
+
+### SIEMPRE hacer
+
+1. **Leer antes de modificar**
+   - Siempre leer archivos antes de editarlos
+   - Entender contexto antes de cambiar
+
+2. **Validar antes de push**
+   - Ejecutar CI-Local: `./.ci-local/ci-local.sh quick`
+   - Verificar que tests pasen
+
+3. **Seguir convenciones del proyecto**
+   - Conventional commits: `feat(scope): message`
+   - Branching: `feature/t-xxx-description`
+
+## Workflow
+
+```
+1. Leer contexto del proyecto (si existe .project/Memory/)
+2. Trabajar en tarea
+3. Validar con CI-Local
+4. Commit + Push
+```
+
+## Archivos de Referencia
+
+| Archivo | Propósito |
+|---------|-----------|
+| `CLAUDE.md` | Instrucciones especificas |
+| `.project/Memory/CONTEXT.md` | Estado del proyecto (si VibeKanban) |
+| `.project/Memory/DECISIONS.md` | ADRs (si VibeKanban) |
+| `.project/Memory/WAVES.md` | Oleadas de trabajo (si VibeKanban) |
+
+## Comandos Frecuentes
+
+```bash
+# CI Local
+./.ci-local/ci-local.sh quick   # Validacion rapida
+./.ci-local/ci-local.sh full    # CI completo
+
+# Git
+git checkout feature/descripcion  # Cambiar a feature branch
+```

package/ai-config/prompts/modes/debug.md

@@ -0,0 +1,34 @@
+# Debug Mode
+
+> Activar con: "modo debug" o "estoy debugueando un bug"
+
+Estás diagnosticando y corrigiendo un bug. Sé sistemático y metódico.
+
+## Enfoque
+- Reproduce el problema primero. Confirma que podés triggerear el bug consistentemente.
+- Recopila información: mensajes de error, stack traces, logs, datos de request/response.
+- Formula una hipótesis antes de cambiar código. Identifica la causa raíz más probable.
+- Verifica la hipótesis con logging, breakpoints o tests dirigidos.
+- Corrige la causa raíz, no el síntoma. Evitá parches provisorios.
+
+## Pasos de Diagnóstico
+1. Lee el mensaje de error y stack trace cuidadosamente. Identifica la línea que falla.
+2. Revisá cambios recientes: `git log --oneline -10` y `git diff HEAD~3`.
+3. Buscá la lógica relacionada en el codebase con grep.
+4. Agregá logging puntual en los límites (input, output, paths de error).
+5. Simplificá el caso de reproducción al mínimo que lo dispara.
+6. Verificá dependencias externas: estado de base de datos, respuestas de API, valores de config.
+
+## Validación del Fix
+- Escribí un test que reproduzca el bug ANTES de escribir el fix.
+- Verificá que el fix resuelve el caso de reproducción original.
+- Corré el suite completo de tests para detectar regresiones.
+- Revisá paths de código relacionados por la misma clase de bug.
+- Documentá la causa raíz en el mensaje de commit.
+
+## Evitar
+- No cambiar múltiples cosas a la vez. Aislá variables.
+- No agregar workarounds sin entender la causa raíz.
+- No remover error handling para que pasen los tests.
+- No asumir que el bug está en una dependencia sin evidencia.
+- No omitir el test de regresión para el bug corregido.

package/ai-config/prompts/modes/deploy.md

@@ -0,0 +1,40 @@
+# Deploy Mode
+
+> Activar con: "voy a deployar" o "modo deploy"
+
+Estás preparando o ejecutando un deployment. Priorizá seguridad y reversibilidad.
+
+## Checklist Pre-Deploy
+- Todos los checks de CI pasan en el branch de deployment.
+- Las migraciones de base de datos son backward-compatible con la versión en producción.
+- Las variables de entorno están configuradas en el ambiente destino antes del deploy.
+- Los feature flags están configurados para features parcialmente lanzados.
+- El changelog o release notes están actualizados.
+- Hay un plan de rollback documentado y listo.
+
+## Pasos de Deployment
+1. Verificá que el artefacto de build corresponde al commit testeado (SHA o tag).
+2. Corré migraciones de base de datos ANTES de deployar la nueva versión de la app.
+3. Deploy a staging primero. Smoke test de los paths críticos.
+4. Deploy a producción con estrategia rolling o blue-green.
+5. Monitoreá error rates, latencia y health checks por 15 minutos post-deploy.
+6. Confirmá éxito en el canal del equipo. Taggea el release en git.
+
+## Criterios de Rollback
+- Error rate supera 2x el baseline pre-deploy.
+- Latencia P99 supera 3x el baseline pre-deploy.
+- Health check failures en más de una instancia.
+- Cualquier corrupción o violación de integridad de datos.
+- Issues críticos reportados por usuarios dentro de la ventana de deploy.
+
+## Post-Deploy
+- Cerrar issues relacionados y actualizar el project board.
+- Monitorear Sentry y dashboards de logging para nuevos patrones de error.
+- Notificar a stakeholders del deployment completado.
+- Programar post-mortem si el deploy tuvo problemas.
+
+## Evitar
+- No deployar los viernes ni antes de feriados sin aprobación explícita.
+- No saltear staging para "cambios pequeños". Todo pasa por staging.
+- No correr migraciones destructivas durante horario pico.
+- No deployar múltiples cambios no relacionados en un solo release.

package/ai-config/prompts/modes/research.md

@@ -0,0 +1,32 @@
+# Research Mode
+
+> Activar con: "investigá opciones para" o "modo research"
+
+Estás explorando opciones, evaluando herramientas o investigando preguntas técnicas.
+
+## Enfoque
+- Definí claramente la pregunta o decisión antes de investigar.
+- Recopilá información de múltiples fuentes: docs, código fuente, benchmarks, posts de la comunidad.
+- Compará al menos dos alternativas para cualquier decisión de herramienta o librería.
+- Documentá hallazgos con pros, contras y una recomendación.
+- Acotá el tiempo de investigación para evitar parálisis de análisis.
+
+## Criterios de Evaluación
+- Estado de mantenimiento: último commit, cadencia de releases, issues abiertos vs cerrados.
+- Adopción de la comunidad: descargas, GitHub stars, presencia en Stack Overflow.
+- Calidad de documentación: guía de inicio, referencia de API, ejemplos.
+- Performance: benchmarks, uso de memoria, tiempo de startup si es relevante.
+- Compatibilidad: funciona con el stack existente, compatibilidad de licencia.
+- Path de migración: esfuerzo para adoptar, esfuerzo para migrar si es necesario.
+
+## Formato de Output
+- Resumí hallazgos en una tabla de comparación estructurada.
+- Declarar suposiciones y restricciones que influyeron en la evaluación.
+- Proveer una recomendación clara con fundamento.
+- Incluir links a fuentes para referencia futura.
+
+## Evitar
+- No recomendar una herramienta solo por popularidad.
+- No pasar más de 30 minutos en una pregunta de investigación sin hacer check-in.
+- No tomar decisiones irreversibles basadas en investigación incompleta.
+- No introducir herramientas nuevas cuando las existentes resuelven el problema adecuadamente.

package/ai-config/prompts/modes/review.md

@@ -0,0 +1,33 @@
+# Code Review Mode
+
+> Activar con: "revisá este código" o "modo review"
+
+Estás revisando código por correctitud, seguridad y mantenibilidad.
+
+## Enfoque
+- Leé la descripción del PR y el issue vinculado primero para entender la intención.
+- Revisá el diff completo antes de comentar. Entendé el cambio en su conjunto.
+- Enfocate en correctitud lógica, edge cases y seguridad antes que estilo.
+- Verificá que los tests cubren el comportamiento cambiado, no solo el happy path.
+- Verificá el error handling: ¿qué pasa cuando los inputs son inválidos o los servicios fallan?
+
+## Qué Verificar
+- Validación de input en los límites del sistema (endpoints de API, form handlers).
+- SQL injection, XSS y otras vulnerabilidades de inyección.
+- Queries N+1, índices faltantes, result sets no acotados.
+- Race conditions en código concurrente o async.
+- Uso correcto de transacciones para mutaciones multi-paso.
+- Secrets o credenciales incluidos accidentalmente en el diff.
+- Breaking changes en APIs públicas o interfaces compartidas.
+
+## Estilo de Comentarios
+- Prefijá con intención: `blocker:`, `suggestion:`, `question:`, `nit:`.
+- Solo comentarios `blocker:` deben impedir la aprobación.
+- Sugerí alternativas concretas, no solo "esto podría ser mejor".
+- Reconocé buenos patrones e implementaciones limpias.
+
+## Evitar
+- No bikeshedear sobre formateo si hay un auto-formatter configurado.
+- No pedir cambios fuera del scope del PR.
+- No bloquear PRs por preferencias de estilo que no están en las reglas del proyecto.
+- No aprobar sin leer el diff completo.

package/ai-config/prompts/review-policy.md

@@ -0,0 +1,79 @@
+# Code Review Policy
+
+Guidelines for AI agents conducting code reviews. Apply these consistently across all PRs.
+
+---
+
+## Naming Conventions
+
+- Use clear, descriptive names that reveal intent — no abbreviations unless universally known (`url`, `id`, `db` are fine; `mgr`, `tmp`, `cb` are not).
+- Booleans: prefer `is`, `has`, `can`, `should` prefixes (`isLoading`, `hasPermission`).
+- Functions: use verbs (`fetchUser`, `calculateTotal`); avoid nouns (`userData`, `total`).
+- Follow language conventions: `camelCase` for JS/TS/Go, `snake_case` for Python/Rust, `PascalCase` for types/classes everywhere.
+- Constants: `UPPER_SNAKE_CASE` for true constants; regular naming for `const` variables that aren't fixed values.
+
+---
+
+## Error Handling
+
+- Every error must be explicitly handled — no silent `catch` blocks, no empty `except`.
+- Log errors with enough context to reproduce: include IDs, input values, stack traces.
+- User-facing error messages must be clear and actionable; never expose internal stack traces or system paths.
+- Distinguish between recoverable errors (return/log) and fatal errors (fail fast).
+- For async code: handle rejected promises; never swallow errors with bare `catch () {}`.
+
+---
+
+## Security
+
+- No hardcoded secrets, tokens, passwords, or API keys — use environment variables.
+- Validate and sanitize all external inputs (API params, form fields, file uploads).
+- Check for injection vulnerabilities: SQL injection, XSS, command injection.
+- Apply least privilege: services, DB users, and IAM roles should have only what they need.
+- Avoid exposing sensitive data in logs, error messages, or API responses.
+- Verify authentication/authorization checks on every protected endpoint.
+
+---
+
+## Performance
+
+- Avoid N+1 queries — use batch fetches, joins, or `include`/`preload` where appropriate.
+- Avoid unnecessary loops inside loops; prefer set operations or indexed lookups.
+- Prefer lazy loading for heavy resources not needed at startup.
+- Cache expensive operations with a clear invalidation strategy.
+- Flag unbounded queries — always paginate or limit result sets from the database.
+
+---
+
+## Test Coverage
+
+- New features must include unit tests covering happy path and key edge cases.
+- Bug fixes must include a regression test that would have caught the original bug.
+- Target ≥ 80% line coverage; don't game it with trivial tests.
+- Tests must be deterministic — no flaky tests, no `sleep` for timing, no hardcoded dates.
+- Test the behavior, not the implementation — avoid over-mocking internal details.
+
+---
+
+## Code Smells
+
+Flag the following (don't block unless egregious, but note them):
+
+| Smell | Threshold |
+|-------|-----------|
+| Duplicate code (DRY violation) | 3+ repeated lines without extraction |
+| Long functions | > 50 lines |
+| Deep nesting | > 3 levels of indentation |
+| Magic numbers | Unexplained literals (except 0, 1, -1) |
+| God class / god function | Does too many unrelated things |
+| Dead code | Unreachable branches, unused imports, commented-out blocks |
+
+---
+
+## PR Conventions
+
+- Title must follow Conventional Commits: `type(scope): description` (e.g., `fix(auth): handle expired token refresh`).
+- Description must explain **WHY** the change was made, not just what changed — that's what the diff is for.
+- Link related issues with `Closes #123` or `Refs #456`.
+- Each PR should be a single logical change — split unrelated fixes into separate PRs.
+- Breaking changes must be flagged with `BREAKING CHANGE:` in the commit footer and explained in the PR description.

package/ai-config/skills/_TEMPLATE.md

@@ -0,0 +1,157 @@
+---
+# =============================================================================
+# SKILL TEMPLATE (Gentleman-Skills Compatible)
+# =============================================================================
+# Formato compatible con: https://github.com/Gentleman-Programming/Gentleman-Skills
+#
+# ESTRUCTURA DE CARPETA:
+#   .ai-config/skills/{category}/{skill-name}/
+#   └── SKILL.md          ← este archivo
+#   └── assets/           ← opcional: templates, schemas, ejemplos
+#   └── references/       ← opcional: links a docs locales
+# =============================================================================
+
+name: mi-skill
+description: >
+  Descripción breve del skill.
+  Trigger: Contexto que activa este skill (ej: "trabajando con React")
+
+metadata:
+  author: tu-usuario-github
+  version: "1.0"
+  tags: [frontend, backend, testing]
+  language: typescript  # typescript | python | go | rust | java
+---
+
+# [Nombre del Skill]
+
+> [Descripción de una línea de lo que hace este skill]
+
+## When to Use
+
+Usar este skill cuando:
+
+- [ ] Condición 1 (ej: "Editando archivos .tsx")
+- [ ] Condición 2 (ej: "Creando componentes React")
+- [ ] Condición 3 (ej: "Implementando estado con hooks")
+
+## Critical Patterns
+
+### Pattern 1: [Nombre del patrón]
+
+**Por qué:** [Explicación de por qué este patrón es importante]
+
+```typescript
+// ✅ Correcto
+[código ejemplo correcto]
+
+// ❌ Incorrecto
+[código ejemplo incorrecto]
+```
+
+### Pattern 2: [Nombre del patrón]
+
+**Por qué:** [Explicación]
+
+```typescript
+// ✅ Correcto
+[código]
+```
+
+### Pattern 3: [Nombre del patrón]
+
+**Por qué:** [Explicación]
+
+```typescript
+// ✅ Correcto
+[código]
+```
+
+## Code Examples
+
+### Example 1: [Título descriptivo]
+
+```typescript
+// Ejemplo completo y funcional
+// Con comentarios explicativos
+
+[código completo]
+```
+
+### Example 2: [Título descriptivo]
+
+```typescript
+[código completo]
+```
+
+### Example 3: [Título descriptivo]
+
+```typescript
+[código completo]
+```
+
+## Anti-Patterns
+
+### ❌ Anti-Pattern 1: [Nombre]
+
+**Problema:** [Por qué es malo]
+
+```typescript
+// ❌ No hacer esto
+[código malo]
+
+// ✅ Hacer esto en su lugar
+[código bueno]
+```
+
+### ❌ Anti-Pattern 2: [Nombre]
+
+**Problema:** [Por qué es malo]
+
+```typescript
+// ❌ Evitar
+[código malo]
+```
+
+## Quick Reference
+
+| Tarea | Snippet |
+|-------|---------|
+| [Tarea 1] | `[código corto]` |
+| [Tarea 2] | `[código corto]` |
+| [Tarea 3] | `[código corto]` |
+
+## Resources
+
+- [Documentación Oficial](URL)
+- [Guía de Mejores Prácticas](URL)
+- [Repositorio de Ejemplos](URL)
+
+---
+
+## Related Skills
+
+- `related-skill-1`: Descripción breve de cuándo usar
+- `related-skill-2`: Descripción breve de cuándo usar
+- `related-skill-3`: Descripción breve de cuándo usar
+
+---
+
+## Changelog
+
+- **1.0** - Versión inicial
+
+---
+
+## Progressive Disclosure Pattern (Optional)
+
+For complex skills, split content into references/:
+```
+skills/my-skill/
+├── SKILL.md          # Core logic only (~150 lines max)
+└── references/
+    ├── examples.md   # Concrete examples (loaded on demand)
+    └── patterns.md   # Advanced patterns (loaded on demand)
+```
+In SKILL.md, reference them with:
+> For examples, see [references/examples.md](references/examples.md)

package/ai-config/skills/backend/api-gateway/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: api-gateway
+description: >
+  API Gateway concepts. Routing, rate limiting, authentication, load balancing.
+  Trigger: API Gateway, routing, load balancing, reverse proxy, edge service
+tools:
+  - Read
+  - Write
+  - Edit
+  - Grep
+metadata:
+  author: apigen-team
+  version: "1.0"
+  tags: [gateway, routing, microservices, edge]
+  scope: ["**/gateway/**"]
+---
+
+# API Gateway Concepts
+
+## What is an API Gateway?
+
+```
+Single entry point for all client requests
+
+         ┌─────────────────┐
+         │    Clients      │
+         │ (Web, Mobile)   │
+         └────────┬────────┘
+                  │
+         ┌────────▼────────┐
+         │   API Gateway   │
+         │  (routing,      │
+         │   auth, rate    │
+         │   limiting)     │
+         └────────┬────────┘
+                  │
+    ┌─────────────┼─────────────┐
+    │             │             │
+┌───▼───┐    ┌───▼───┐    ┌───▼───┐
+│User   │    │Order  │    │Product│
+│Service│    │Service│    │Service│
+└───────┘    └───────┘    └───────┘
+```
+
+## Core Responsibilities
+
+### Routing
+```
+Route requests to appropriate backend services:
+
+/api/users/*     → User Service
+/api/orders/*    → Order Service
+/api/products/*  → Product Service
+
+Path rewriting:
+/api/users/123   → /users/123 (strip prefix)
+```
+
+### Authentication/Authorization
+```
+Centralized auth at edge:
+1. Validate JWT token
+2. Extract user context
+3. Forward user info to services
+4. Return 401/403 if invalid
+
+Benefits:
+- Services don't need auth logic
+- Consistent auth across services
+- Token validation cached
+```
+
+### Rate Limiting
+```
+Protect services from overload:
+
+Per client:
+  Anonymous: 60 req/min
+  Authenticated: 1000 req/min
+  Premium: 10000 req/min
+
+Per endpoint:
+  /api/search: 30 req/min
+  /api/login: 5 req/min
+```
+
+### Load Balancing
+```
+Distribute traffic across instances:
+
+Strategies:
+- Round Robin
+- Least Connections
+- Weighted
+- IP Hash (sticky sessions)
+
+Health checks:
+- Remove unhealthy instances
+- Automatic failover
+```
+
+## Additional Features
+
+### Request/Response Transformation
+```
+Transform requests:
+- Add headers (correlation ID, auth)
+- Modify body
+- Change content type
+
+Transform responses:
+- Remove internal headers
+- Standardize error format
+- Add CORS headers
+```
+
+### Caching
+```
+Cache responses at edge:
+
+Benefits:
+- Reduce backend load
+- Faster response times
+- Resilience (serve cached on failure)
+
+Strategies:
+- Cache by URL + headers
+- Cache invalidation
+- Vary by user/tenant
+```
+
+### Circuit Breaking
+```
+Prevent cascade failures:
+
+States:
+- Closed: Normal operation
+- Open: Fail fast (service down)
+- Half-Open: Test recovery
+
+Configuration:
+- Failure threshold
+- Timeout
+- Recovery window
+```
+
+### Logging & Monitoring
+```
+Centralized observability:
+
+Metrics:
+- Request rate
+- Error rate
+- Latency (P50, P95, P99)
+- Active connections
+
+Logging:
+- Access logs
+- Request/response bodies (debug)
+- Correlation IDs
+
+Tracing:
+- Distributed trace propagation
+- Span timing
+```
+
+## Gateway Patterns
+
+### Backend for Frontend (BFF)
+```
+Separate gateways per client type:
+
+Web BFF Gateway    → Web-specific routes
+Mobile BFF Gateway → Mobile-optimized APIs
+Partner Gateway    → B2B API contracts
+```
+
+### API Composition
+```
+Aggregate multiple services:
+
+GET /api/dashboard
+  → GET /users/me
+  → GET /orders/recent
+  → GET /notifications/unread
+  → Combined response
+```
+
+### Canary Releases
+```
+Route % of traffic to new version:
+
+v1 (stable): 95%
+v2 (canary): 5%
+
+Progressive rollout:
+Day 1: 5%
+Day 2: 25%
+Day 3: 50%
+Day 4: 100%
+```
+
+## Gateway Solutions
+
+```
+| Solution | Type | Best For |
+|----------|------|----------|
+| Kong | Open source | Feature-rich, plugins |
+| AWS API Gateway | Managed | AWS ecosystem |
+| Apigee | Enterprise | API management |
+| NGINX | OSS | Performance |
+| Spring Cloud Gateway | Framework | Java/Spring |
+| Envoy | Proxy | Service mesh |
+| Traefik | Cloud-native | Kubernetes |
+```
+
+## Security Considerations
+
+```
+✅ TLS termination at gateway
+✅ Request validation (size, content-type)
+✅ SQL injection / XSS prevention
+✅ DDoS protection
+✅ IP allowlisting/blocklisting
+✅ Bot detection
+✅ API key rotation
+✅ Secrets management
+```
+
+## Best Practices
+
+```
+Performance:
+✅ Connection pooling
+✅ Async I/O
+✅ Response streaming
+✅ Compression
+
+Reliability:
+✅ Health checks
+✅ Graceful degradation
+✅ Retry with backoff
+✅ Timeout configuration
+
+Operations:
+✅ Blue-green deployment
+✅ Configuration as code
+✅ Centralized logging
+✅ Alerting on error spikes
+```
+
+## Related Skills
+
+- `gateway-spring`: Spring Cloud Gateway implementation