javi-forge 0.1.0

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

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

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