javi-forge 1.2.0 → 1.4.0

package/ai-config/agents/specialized/solo-dev-planner-modular/WORKFLOW-DIAGRAM.md

@@ -1,355 +0,0 @@
----
-name: solo-dev-planner-workflow
-description: "Diagrama de flujo del Solo Dev Planner"
----
-
-# 🎯 Flujo de Uso del Skill Modular
-
-## 📁 Estructura de Archivos
-
-```
-📂 .claude/agents/specialized/solo-dev-planner/
-│
-├── 📄 solo-dev-planner.md          👈 LOADER (este es el "skill")
-│   │
-│   ├─ Frontmatter YAML:
-│   │  name: solo-dev-planner
-│   │  tools: Read, Write, ...
-│   │
-│   └─ Lógica de router:
-│      "¿Usuario pregunta X? → Lee módulo Y"
-│
-├── 📘 00-INDEX.md                  (Guía de navegación)
-├── 📗 01-CORE.md                   (Filosofía + Workflow)
-├── 📙 02-SELF-CORRECTION.md        (Auto-fix)
-├── 📕 03-PROGRESSIVE-SETUP.md      (MVP/Alpha/Beta)
-├── 📔 04-DEPLOYMENT.md             (Koyeb/Railway/Coolify)
-├── 📓 05-TESTING.md                (Strategy + Testcontainers)
-└── 📒 06-OPERATIONS.md             (DB/Secrets/Monitoring)
-```
-
----
-
-## 🔄 Flujo de Ejecución
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ 1. USUARIO INVOCA SKILL                                     │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-    @solo-dev-planner quiero deployar a Koyeb
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 2. CLAUDE LEE: solo-dev-planner.md (loader)                 │
-│    ↳ Identifica: "deploy" + "Koyeb" → Necesita módulo 04   │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 3. CLAUDE USA TOOL: read                                    │
-│    ↳ Lee archivo: 04-DEPLOYMENT.md (completo)              │
-│    ↳ 2,500 líneas sobre deployment                         │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 4. CLAUDE PROCESA CONTENIDO DEL MÓDULO                     │
-│    ↳ Encuentra sección de Koyeb                            │
-│    ↳ Extrae setup, configs, comandos                       │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ 5. CLAUDE RESPONDE CON INFORMACIÓN DEL MÓDULO              │
-│    ↳ "Perfecto, Koyeb es ideal porque..."                  │
-│    ↳ Pasos de setup                                        │
-│    ↳ Comandos concretos                                    │
-└─────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 🎮 Ejemplos Prácticos
-
-### Ejemplo 1: Nuevo Proyecto
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│ Usuario en chat:                                             │
-│ @solo-dev-planner necesito empezar un proyecto TypeScript   │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Loader (solo-dev-planner.md):                                │
-│ • Detecta: "empezar proyecto" + "TypeScript"                 │
-│ • Decision: Necesita 01-CORE + 03-PROGRESSIVE-SETUP         │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Claude ejecuta (internamente):                               │
-│ read("solo-dev-planner/01-CORE.md")                         │
-│ read("solo-dev-planner/03-PROGRESSIVE-SETUP.md")            │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Claude responde:                                              │
-│                                                               │
-│ "¡Perfecto! Vamos a usar Progressive Setup para empezar     │
-│  rápido. Puedes estar codeando en 15 minutos.               │
-│                                                               │
-│  FASE 1: MVP (5-15 minutos)                                  │
-│  ================================                             │
-│                                                               │
-│  1. Instalar Mise:                                           │
-│     brew install mise                                        │
-│                                                               │
-│  2. Setup del proyecto:                                      │
-│     mise run setup:mvp                                       │
-│                                                               │
-│  3. Esto configura:                                          │
-│     ✓ Node 20 con Bun                                        │
-│     ✓ SQLite local (sin Docker)                             │
-│     ✓ Git hooks                                              │
-│     ✓ .env básico                                            │
-│                                                               │
-│  4. Iniciar desarrollo:                                      │
-│     mise run dev                                             │
-│                                                               │
-│  ¿Listo para empezar?"                                       │
-└──────────────────────────────────────────────────────────────┘
-```
-
-### Ejemplo 2: Troubleshooting
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│ Usuario:                                                      │
-│ @solo-dev-planner los tests fallan y no sé por qué          │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Loader:                                                       │
-│ • Detecta: "tests fallan"                                    │
-│ • Decision: Necesita 02-SELF-CORRECTION                     │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Claude ejecuta:                                               │
-│ read("solo-dev-planner/02-SELF-CORRECTION.md")              │
-└──────────────────────────────────────────────────────────────┘
-                            ▼
-┌──────────────────────────────────────────────────────────────┐
-│ Claude responde:                                              │
-│                                                               │
-│ "Vamos a usar el protocolo de auto-corrección. El skill     │
-│  tiene un sistema que intenta arreglar errores común         │
-│  automáticamente (hasta 3 intentos).                         │
-│                                                               │
-│  Ejecuta esto:                                               │
-│  mise run fix:auto                                           │
-│                                                               │
-│  Esto hará:                                                  │
-│  1. Detectar tipo de error (tests)                          │
-│  2. Limpiar cache (.pytest_cache, coverage)                 │
-│  3. Resetear test database                                   │
-│  4. Re-ejecutar tests                                        │
-│                                                               │
-│  Si falla después de 3 intentos, el script te mostrará:     │
-│  ⛔ BLOCKED: Solicito intervención humana                    │
-│                                                               │
-│  Y podremos ver el error específico para debuggearlo.       │
-│  ¿Ejecuto el comando?"                                       │
-└──────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 🧠 Lógica del Loader
-
-El archivo `solo-dev-planner.md` funciona como un **router inteligente**:
-
-```typescript
-// Pseudocódigo de cómo funciona
-
-function handleUserQuery(query: string) {
-  // 1. Analizar query
-  const intent = analyzeIntent(query);
-  
-  // 2. Mapear a módulo(s)
-  const modules = mapToModules(intent);
-  
-  // 3. Leer módulo(s)
-  const content = modules.map(m => readFile(m));
-  
-  // 4. Responder
-  return generateResponse(content, query);
-}
-
-// Ejemplos de mapeo:
-const moduleMap = {
-  "nuevo proyecto": ["01-CORE", "03-PROGRESSIVE-SETUP"],
-  "tests fallan": ["02-SELF-CORRECTION"],
-  "deployar": ["04-DEPLOYMENT"],
-  "configurar DB": ["06-OPERATIONS"],
-  "setup rápido": ["03-PROGRESSIVE-SETUP"],
-};
-```
-
----
-
-## 📊 Comparación: Antes vs Ahora
-
-### ANTES (Skill Monolítico)
-
-```
-.claude/agents/specialized/solo-dev-planner.md
-│
-└── 13,241 líneas
-    │
-    └── Claude lee TODO cada vez (40k tokens)
-        ↓
-        ⚠️ Lento (10 segundos)
-        ⚠️ Costoso en tokens
-        ⚠️ Difícil de navegar
-```
-
-### AHORA (Skill Modular)
-
-```
-.claude/agents/specialized/solo-dev-planner/
-│
-├── solo-dev-planner.md (loader - 200 líneas)
-│   │
-│   └── Lee SOLO módulo(s) necesario(s)
-│       ↓
-│       ✅ Rápido (2 segundos)
-│       ✅ Eficiente (5k-10k tokens)
-│       ✅ Especializado
-│
-├── 01-CORE.md (3,500 líneas)
-├── 02-SELF-CORRECTION.md (1,800 líneas)
-├── 03-PROGRESSIVE-SETUP.md (2,000 líneas)
-├── 04-DEPLOYMENT.md (2,500 líneas)
-├── 05-TESTING.md (2,200 líneas)
-└── 06-OPERATIONS.md (2,800 líneas)
-```
-
----
-
-## 🎯 Ventajas del Sistema Modular
-
-### Para el Usuario
-
-```
-✅ Mismo comando: @solo-dev-planner
-✅ Respuestas más rápidas
-✅ Más precisas (carga solo lo relevante)
-✅ Fácil actualizar módulos individuales
-```
-
-### Para Claude
-
-```
-✅ Menos tokens por query (-75%)
-✅ Carga más rápida (-80%)
-✅ Respuestas más precisas
-✅ Context window optimizado
-```
-
-### Para Mantenimiento
-
-```
-✅ Actualizar 1 módulo sin tocar otros
-✅ Agregar nuevos módulos fácilmente
-✅ Debug más simple
-✅ Versionado por módulo
-```
-
----
-
-## 🔍 Cómo Claude Identifica el Módulo
-
-```typescript
-// Keywords → Módulos
-const keywordMap = {
-  // Nuevo proyecto / Setup
-  "nuevo proyecto": ["01-CORE", "03-PROGRESSIVE-SETUP"],
-  "empezar": ["01-CORE", "03-PROGRESSIVE-SETUP"],
-  "setup": ["03-PROGRESSIVE-SETUP"],
-  "mvp": ["03-PROGRESSIVE-SETUP"],
-  
-  // Errores / Troubleshooting
-  "error": ["02-SELF-CORRECTION"],
-  "falla": ["02-SELF-CORRECTION"],
-  "no funciona": ["02-SELF-CORRECTION"],
-  "bug": ["02-SELF-CORRECTION"],
-  
-  // Tests
-  "test": ["05-TESTING"],
-  "testcontainers": ["05-TESTING"],
-  "coverage": ["05-TESTING"],
-  
-  // Deploy
-  "deploy": ["04-DEPLOYMENT"],
-  "koyeb": ["04-DEPLOYMENT"],
-  "railway": ["04-DEPLOYMENT"],
-  "coolify": ["04-DEPLOYMENT"],
-  "producción": ["04-DEPLOYMENT"],
-  
-  // Operations
-  "database": ["06-OPERATIONS"],
-  "secrets": ["06-OPERATIONS"],
-  "monitoring": ["06-OPERATIONS"],
-  "migraciones": ["06-OPERATIONS"],
-  
-  // Filosofía
-  "filosofía": ["01-CORE"],
-  "workflow": ["01-CORE"],
-  "atomic sequential": ["01-CORE"],
-};
-```
-
----
-
-## 🚀 Resumen Visual
-
-```
-┌─────────────────────────────────────────────────────┐
-│                                                     │
-│  Tú escribes:                                       │
-│  @solo-dev-planner <cualquier pregunta>            │
-│                                                     │
-└─────────────────────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────┐
-│                                                     │
-│  Claude (automáticamente):                          │
-│  1. Lee loader (200 líneas)                        │
-│  2. Identifica módulo(s) necesario(s)              │
-│  3. Lee SOLO ese módulo (1,800-3,500 líneas)      │
-│  4. Responde basándose en el módulo                │
-│                                                     │
-└─────────────────────────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────┐
-│                                                     │
-│  Resultado:                                         │
-│  ✅ Respuesta precisa y detallada                  │
-│  ✅ En 2 segundos (vs 10 antes)                    │
-│  ✅ Usando 5k-10k tokens (vs 40k antes)            │
-│  ✅ 100% basado en contenido del skill             │
-│                                                     │
-└─────────────────────────────────────────────────────┘
-```
-
----
-
-## 🎉 ¡Es Transparente para el Usuario!
-
-**No cambia nada en tu workflow:**
-
-```
-Antes:  @solo-dev-planner quiero deployar
-Ahora:  @solo-dev-planner quiero deployar
-
-Mismo comando, mejores resultados ✅
-```
-
-**La modularización es interna, invisible para ti, pero hace todo más eficiente.**

package/ai-config/agents/specialized/solo-dev-planner-modular/solo-dev-planner.md

@@ -1,279 +0,0 @@
----
-name: solo-dev-planner
-description: Agente modular para solo developers. Carga módulos según necesidad. Setup en 15 min, deploy global, auto-fix de errores.
-trigger: >
-  solo dev, solo developer, indie developer, one-person team, modular planning,
-  quick setup, self-correction, auto-fix, developer productivity
-category: specialized
-color: cyan
-tools: Write, Read, MultiEdit, Bash, Grep, Glob, GitHub_MCP
-config:
-  model: opus
-mcp_servers:
-  - github
-metadata:
-  version: "2.0"
-  updated: "2026-02"
----
-
-# 🚀 Solo Dev Planner - Skill Modular (Loader)
-
-Este es el **skill principal** que carga módulos según necesidad.
-
-## 📋 **Instrucciones para Claude**
-
-**IMPORTANTE:** Este skill es modular. Los módulos completos están en archivos separados en esta misma carpeta.
-
-### **Cuando el usuario pida ayuda, sigue este proceso:**
-
-1. **Identifica qué necesita el usuario**
-2. **Lee el(los) módulo(s) relevante(s)**
-3. **Responde basándote en el módulo**
-
----
-
-## 📚 **Módulos Disponibles**
-
-Todos los módulos están en: `.claude/agents/specialized/solo-dev-planner/`
-
-```
-📁 solo-dev-planner/
-├── solo-dev-planner.md           ← Estás aquí (loader)
-├── 00-INDEX.md                   ← Guía de navegación
-├── 01-CORE.md                    ← Filosofía + Workflow
-├── 02-SELF-CORRECTION.md         ← Auto-fix protocol
-├── 03-PROGRESSIVE-SETUP.md       ← Setup MVP/Alpha/Beta
-├── 04-DEPLOYMENT.md              ← Koyeb/Railway/Coolify
-├── 05-TESTING.md                 ← Strategy + Testcontainers
-└── 06-OPERATIONS.md              ← DB/Secrets/Monitoring
-```
-
----
-
-## 🎯 **Mapa de Decisión: ¿Qué Módulo Leer?**
-
-### **Usuario pregunta sobre:**
-
-**"Quiero empezar un proyecto nuevo"**
-→ Lee: `01-CORE.md` + `03-PROGRESSIVE-SETUP.md`
-
-**"Tengo errores que no puedo resolver"**
-→ Lee: `02-SELF-CORRECTION.md`
-
-**"Necesito configurar tests"**
-→ Lee: `05-TESTING.md`
-
-**"Cómo deployar a producción"**
-→ Lee: `04-DEPLOYMENT.md`
-
-**"Configurar base de datos / secrets / monitoring"**
-→ Lee: `06-OPERATIONS.md`
-
-**"Explicar la filosofía del workflow"**
-→ Lee: `01-CORE.md` (sección Filosofía)
-
-**"Setup rápido en 15 minutos"**
-→ Lee: `03-PROGRESSIVE-SETUP.md` (FASE 1: MVP)
-
-**"Qué módulo necesito para X"**
-→ Lee: `00-INDEX.md`
-
----
-
-## 🔄 **Protocolo de Carga de Módulos**
-
-```typescript
-interface ModuleLoader {
-  async loadModule(moduleName: string): Promise<Content> {
-    // 1. Identificar módulo necesario
-    const module = this.identifyModule(userQuery);
-    
-    // 2. Leer archivo del módulo
-    const content = await readFile(`solo-dev-planner/${module}.md`);
-    
-    // 3. Procesar y responder
-    return this.processAndRespond(content, userQuery);
-  }
-}
-```
-
-**SIEMPRE lee el módulo completo antes de responder.**
-
----
-
-## 📖 **Contenido Base (Mini-Resumen)**
-
-Mientras cargas el módulo completo, aquí tienes un resumen ultra-rápido:
-
-### **Filosofía Core**
-
-```
-✓ Solo developer workflow
-✓ Atomic Sequential Merges (1 rama → merge rápido)
-✓ WIP Limit = 1 (máximo foco)
-✓ CI como único reviewer
-✓ Setup en 15 minutos (MVP)
-```
-
-### **Stack Moderno por Defecto**
-
-| Lenguaje | Tool | Por qué |
-|----------|------|---------|
-| **TypeScript** | Bun + Biome | 10x más rápido |
-| **Python** | uv | 100x más rápido que pip |
-| **Go** | Go 1.25+ | Generics, mejor performance |
-| **Java** | Gradle + Kotlin | Build moderno |
-
-### **Workflow Diario**
-
-```bash
-# 1. Crear rama
-git checkout develop
-git pull
-git checkout -b feat/01-user-auth
-
-# 2. Desarrollar + commits frecuentes
-git add .
-git commit -m "add: User model"
-
-# 3. Push + PR
-git push -u origin feat/01-user-auth
-gh pr create --fill
-
-# 4. CI pasa → Auto-merge
-# (GitHub auto-merge cuando CI verde)
-
-# 5. Siguiente paso
-git checkout develop
-git pull
-git checkout -b feat/02-user-login
-```
-
-### **Setup Rápido**
-
-```bash
-# MVP (15 minutos)
-mise run setup:mvp
-mise run dev
-
-# Alpha (cuando estés listo)
-mise run setup:alpha
-
-# Beta (pre-producción)
-mise run setup:beta
-```
-
----
-
-## 🚨 **IMPORTANTE: Siempre Lee el Módulo Completo**
-
-**NO respondas solo con este resumen.** Este es solo contexto base.
-
-**SIEMPRE:**
-1. Identifica qué módulo(s) necesita el usuario
-2. Lee el archivo completo del módulo
-3. Responde basándote en el contenido del módulo
-
-**Ejemplo:**
-
-```
-Usuario: "Cómo configuro Testcontainers?"
-
-Proceso correcto:
-1. Identificar: Necesita módulo 05-TESTING.md
-2. Leer: todo el archivo 05-TESTING.md
-3. Responder: basándote en la sección de Testcontainers
-
-Proceso INCORRECTO:
-❌ Responder solo con conocimiento general
-❌ No leer el módulo
-❌ Inventar información
-```
-
----
-
-## 🎮 **Comandos Rápidos para el Usuario**
-
-```bash
-# Setup inicial
-mise run setup              # Wizard interactivo
-mise run setup:mvp          # Solo MVP (15 min)
-mise run setup:alpha        # Upgrade a Alpha
-mise run setup:beta         # Upgrade a Beta
-
-# Desarrollo
-mise run dev                # Iniciar app
-mise run test               # Tests
-mise run lint               # Linter
-
-# Auto-fix (cuando algo falla)
-mise run fix:auto           # Auto-detecta y arregla
-
-# Deploy
-mise run deploy             # Deploy a plataforma configurada
-mise run logs               # Ver logs de producción
-
-# Context (para Claude Code)
-mise run context            # Estado del proyecto en JSON
-```
-
----
-
-## 📊 **Troubleshooting Rápido**
-
-**Problema:** Tests fallan
-→ **Lee:** `02-SELF-CORRECTION.md` → auto-fix tests
-→ **Ejecuta:** `mise run fix:auto`
-
-**Problema:** Lint errors
-→ **Lee:** `02-SELF-CORRECTION.md` → auto-fix lint
-→ **Ejecuta:** `bash scripts/auto-fix.sh lint`
-
-**Problema:** Database connection failed
-→ **Lee:** `02-SELF-CORRECTION.md` → auto-fix database
-→ **Ejecuta:** `mise run fix:database`
-
-**Problema:** No sé qué módulo necesito
-→ **Lee:** `00-INDEX.md`
-
----
-
-## 🎯 **Checklist Pre-Respuesta**
-
-Antes de responder al usuario:
-
-```
-☑ ¿Identifiqué el módulo correcto?
-☑ ¿Leí el archivo completo del módulo?
-☑ ¿Mi respuesta se basa en el contenido del módulo?
-☑ ¿Necesito leer módulos adicionales?
-☑ ¿Puedo dar ejemplos concretos del módulo?
-```
-
----
-
-## 📁 **Estructura de Archivos (Recordatorio)**
-
-```
-.claude/agents/specialized/solo-dev-planner/
-├── solo-dev-planner.md           ← Loader (este archivo)
-├── 00-INDEX.md                   ← Guía navegación
-├── 01-CORE.md                    ← 3,500 líneas
-├── 02-SELF-CORRECTION.md         ← 1,800 líneas
-├── 03-PROGRESSIVE-SETUP.md       ← 2,000 líneas
-├── 04-DEPLOYMENT.md              ← 2,500 líneas
-├── 05-TESTING.md                 ← 2,200 líneas
-└── 06-OPERATIONS.md              ← 2,800 líneas
-```
-
----
-
-## 🚀 **¡Listo para Usar!**
-
-**Proceso:**
-1. Usuario hace pregunta
-2. Identificas módulo(s) necesario(s)
-3. Lees el módulo completo
-4. Respondes con información del módulo
-
-**Recuerda:** Los módulos tienen la información completa y detallada. Este archivo es solo un loader/router.