elsabro 2.1.0 → 2.3.0

package/hooks/post-edit-test.sh

@@ -0,0 +1,189 @@
+#!/bin/bash
+# post-edit-test.sh - ELSABRO Hook: Ejecuta tests automaticamente despues de editar codigo
+# Uso: Este hook se ejecuta automaticamente despues de Write/Edit
+# Soporta: vitest, jest, mocha, npm-test, pytest, cargo, go
+
+set -e
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Prefijo ELSABRO
+PREFIX="[ELSABRO:hook]"
+
+# Detectar el tipo de proyecto y runner de tests
+detect_test_runner() {
+    # Node.js / JavaScript / TypeScript
+    if [ -f "package.json" ]; then
+        if grep -q '"vitest"' package.json 2>/dev/null; then
+            echo "vitest"
+            return
+        fi
+        if grep -q '"jest"' package.json 2>/dev/null; then
+            echo "jest"
+            return
+        fi
+        if grep -q '"mocha"' package.json 2>/dev/null; then
+            echo "mocha"
+            return
+        fi
+        # Check for test script in package.json
+        if grep -q '"test"' package.json 2>/dev/null; then
+            # Verify it's not the default npm test
+            local test_script=$(grep -o '"test":\s*"[^"]*"' package.json | head -1)
+            if [[ ! "$test_script" =~ "Error: no test specified" ]]; then
+                echo "npm-test"
+                return
+            fi
+        fi
+    fi
+
+    # Python
+    if [ -f "pytest.ini" ] || [ -f "pyproject.toml" ] || [ -f "setup.py" ]; then
+        if command -v pytest &>/dev/null; then
+            echo "pytest"
+            return
+        fi
+    fi
+    if [ -d "tests" ] || [ -d "test" ]; then
+        if command -v pytest &>/dev/null; then
+            echo "pytest"
+            return
+        fi
+    fi
+
+    # Rust
+    if [ -f "Cargo.toml" ]; then
+        echo "cargo"
+        return
+    fi
+
+    # Go
+    if [ -f "go.mod" ]; then
+        echo "go"
+        return
+    fi
+
+    # No runner detected
+    echo ""
+}
+
+# Encontrar archivo de test relacionado
+find_related_test() {
+    local file="$1"
+    local basename=$(basename "$file")
+    local dirname=$(dirname "$file")
+    local name_without_ext="${basename%.*}"
+
+    # Patrones comunes de archivos de test
+    local patterns=(
+        "${dirname}/${name_without_ext}.test.ts"
+        "${dirname}/${name_without_ext}.test.js"
+        "${dirname}/${name_without_ext}.spec.ts"
+        "${dirname}/${name_without_ext}.spec.js"
+        "${dirname}/__tests__/${name_without_ext}.test.ts"
+        "${dirname}/__tests__/${name_without_ext}.test.js"
+        "tests/${name_without_ext}_test.py"
+        "test/${name_without_ext}_test.py"
+        "${dirname}/test_${name_without_ext}.py"
+    )
+
+    for pattern in "${patterns[@]}"; do
+        if [ -f "$pattern" ]; then
+            echo "$pattern"
+            return
+        fi
+    done
+
+    echo ""
+}
+
+# Ejecutar tests segun el runner detectado
+run_tests() {
+    local runner="$1"
+    local changed_file="$2"
+    local related_test=$(find_related_test "$changed_file")
+
+    case "$runner" in
+        vitest)
+            if [ -n "$related_test" ]; then
+                echo -e "${BLUE}$PREFIX Running vitest for related test...${NC}"
+                npx vitest run "$related_test" --reporter=dot --passWithNoTests 2>/dev/null
+            else
+                echo -e "${BLUE}$PREFIX Running vitest (all tests)...${NC}"
+                npx vitest run --reporter=dot --passWithNoTests 2>/dev/null
+            fi
+            ;;
+        jest)
+            if [ -n "$related_test" ]; then
+                echo -e "${BLUE}$PREFIX Running jest for related test...${NC}"
+                npx jest "$related_test" --bail --passWithNoTests --silent 2>/dev/null
+            else
+                echo -e "${BLUE}$PREFIX Running jest (all tests)...${NC}"
+                npx jest --bail --passWithNoTests --silent 2>/dev/null
+            fi
+            ;;
+        mocha)
+            echo -e "${BLUE}$PREFIX Running mocha...${NC}"
+            npx mocha --exit 2>/dev/null
+            ;;
+        npm-test)
+            echo -e "${BLUE}$PREFIX Running npm test...${NC}"
+            npm test --silent 2>/dev/null || true
+            ;;
+        pytest)
+            if [ -n "$related_test" ]; then
+                echo -e "${BLUE}$PREFIX Running pytest for related test...${NC}"
+                python -m pytest "$related_test" -x -q 2>/dev/null
+            else
+                echo -e "${BLUE}$PREFIX Running pytest (all tests)...${NC}"
+                python -m pytest -x -q --tb=short 2>/dev/null
+            fi
+            ;;
+        cargo)
+            echo -e "${BLUE}$PREFIX Running cargo test...${NC}"
+            cargo test --quiet 2>/dev/null
+            ;;
+        go)
+            echo -e "${BLUE}$PREFIX Running go test...${NC}"
+            go test ./... -v 2>/dev/null
+            ;;
+        *)
+            # No test runner detected
+            return 0
+            ;;
+    esac
+}
+
+# Main
+main() {
+    # Archivo que fue editado (pasado como argumento por el hook)
+    local changed_file="${1:-}"
+
+    # Detectar runner
+    local runner=$(detect_test_runner)
+
+    if [ -z "$runner" ]; then
+        # No hay test runner, salir silenciosamente
+        echo -e "${YELLOW}$PREFIX No test runner detected, skipping tests${NC}"
+        exit 0
+    fi
+
+    echo -e "${YELLOW}$PREFIX Detected test runner: $runner${NC}"
+
+    # Ejecutar tests
+    if run_tests "$runner" "$changed_file"; then
+        echo -e "${GREEN}$PREFIX Tests passed${NC}"
+        exit 0
+    else
+        echo -e "${RED}$PREFIX Tests failed${NC}"
+        echo -e "${RED}$PREFIX Fix the failing tests before continuing${NC}"
+        exit 1
+    fi
+}
+
+main "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elsabro",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Sistema de desarrollo AI-powered para Claude Code - El mejor asistente para crear apps sin experiencia previa",
   "bin": {
     "elsabro": "bin/install.js"
@@ -13,7 +13,8 @@
     "templates",
     "workflows",
     "references",
-    "hooks/dist"
+    "hooks",
+    "scripts"
   ],
   "keywords": [
     "claude",

package/references/SYSTEM_INDEX.md

@@ -0,0 +1,241 @@
+# ELSABRO System Index
+
+## ARQUITECTURA DEL SISTEMA
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                            ELSABRO SYSTEM                                    │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                              │
+│  ┌──────────────────────────────────────────────────────────────────────┐   │
+│  │                      ENTRY POINT                                      │   │
+│  │                    /elsabro:start                                     │   │
+│  │              (Orquestador Principal)                                  │   │
+│  └────────────────────────────┬─────────────────────────────────────────┘   │
+│                               │                                              │
+│                               ▼                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    CORE WORKFLOW                                        │ │
+│  │  ┌─────────┐  ┌─────────┐  ┌─────────────┐  ┌───────────────┐         │ │
+│  │  │  :new   │→ │  :plan  │→ │  :execute   │→ │ :verify-work  │         │ │
+│  │  │ (setup) │  │(design) │  │(implement)  │  │   (check)     │         │ │
+│  │  └─────────┘  └─────────┘  └─────────────┘  └───────────────┘         │ │
+│  │                    ↑               │                                    │ │
+│  │                    └───── :debug ──┘                                    │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    SHARED STATE                                         │ │
+│  │                 .elsabro/state.json                                     │ │
+│  │              (Sincronización entre comandos)                            │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │                    TASK DISPATCHER                                      │ │
+│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                     │ │
+│  │  │   HAIKU     │  │   SONNET    │  │    OPUS     │                     │ │
+│  │  │ Exploración │  │  Balance    │  │ Implementar │                     │ │
+│  │  │  (rápido)   │  │ (flexible)  │  │  (calidad)  │                     │ │
+│  │  └─────────────┘  └─────────────┘  └─────────────┘                     │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## ARCHIVOS DE REFERENCIA
+
+### 1. `enforcement-rules.md`
+**Propósito**: Reglas NO negociables que todo comando debe seguir
+**Contiene**:
+- Secuencia obligatoria: TaskCreate → TaskUpdate → Task → TaskUpdate
+- Mínimos de agentes por fase
+- Matriz completa de todos los comandos (29 comandos)
+- Políticas de paralelismo
+
+### 2. `state-sync.md`
+**Propósito**: Protocolo de sincronización de estado entre comandos
+**Contiene**:
+- Código de sincronización para copiar a cada comando
+- Fases por comando
+- Contexto que pasa cada comando al siguiente
+- Transiciones válidas entre comandos
+
+### 3. `command-flow.md`
+**Propósito**: Flujo de navegación y estado compartido
+**Contiene**:
+- Diagrama de flujo principal
+- Estructura de `.elsabro/state.json`
+- Checkpoints entre comandos
+- Recuperación de contexto
+
+### 4. `task-dispatcher.md`
+**Propósito**: Selección automática de modelo según tipo de tarea
+**Contiene**:
+- Matriz modelo-tipo de tarea
+- Configuración de agentes por comando
+- Políticas de ejecución paralela
+- Integración con Claude Code Tasks API
+
+### 4.1. `tasks-integration.md` (NUEVO)
+**Propósito**: Integración con Claude Code Tasks API como backend único
+**Contiene**:
+- Arquitectura unificada (ELSABRO commands + Tasks API)
+- Metadata schema para TODOs, phases, milestones
+- Migración de `.planning/TODOS.md` a Tasks API
+- Ejemplos de implementación para cada comando
+
+### 5. `error-handling-instructions.md`
+**Propósito**: Manejo consistente de errores
+**Contiene**:
+- Clasificación (CRITICAL, HIGH, MEDIUM, LOW)
+- Display visual de errores
+- Políticas de retry
+- Actualización de estado después de errores
+
+### 6. `source-hierarchy.md`
+**Propósito**: Prioridad de fuentes de información
+**Contiene**:
+- Context7 > Docs > WebSearch > Training
+- Verificación de versiones
+- Proceso de research
+
+### 7. `token-optimization.md`
+**Propósito**: Uso eficiente del contexto
+**Contiene**:
+- Regla del 50%
+- Lazy loading
+- Wave execution
+
+---
+
+## ESTADO UNIFICADO
+
+**Archivo principal**: `.elsabro/state.json`
+
+```json
+{
+  "version": "1.0.0",
+  "created_at": "ISO timestamp",
+  "updated_at": "ISO timestamp",
+
+  "current_flow": {
+    "command": "string",
+    "phase": "string",
+    "started_at": "ISO timestamp"
+  },
+
+  "context": {
+    "project_type": "greenfield | brownfield | continuation",
+    "tech_stack": ["array"],
+    "current_feature": "string | null"
+  },
+
+  "history": [
+    {
+      "command": "string",
+      "completed_at": "ISO timestamp",
+      "result": "string",
+      "artifact": "path | null"
+    }
+  ],
+
+  "pending_tasks": [],
+  "blocked_on": null,
+  "suggested_next": "string | null",
+
+  "errors": {
+    "count": 0,
+    "lastError": null
+  }
+}
+```
+
+**Archivo legible**: `.elsabro/context.md` (para humanos)
+
+---
+
+## SKILLS PROFESIONALES
+
+| Skill | Stack | Versiones |
+|-------|-------|-----------|
+| `full-stack-app` | Next.js 15 + React 19 + Prisma 6 + PostgreSQL | Específicas |
+| `saas-starter` | Full-stack + Stripe 2024-12-18 | Específicas |
+| `mobile-app` | Expo SDK 52 + React Native | Específicas |
+| `api-microservice` | Fastify + OpenAPI + Docker | Parciales |
+| `chrome-extension` | Manifest V3 + Vite + TypeScript | Parciales |
+
+---
+
+## CHECKLIST DE CONSISTENCIA
+
+Para verificar que el sistema está correctamente configurado:
+
+### Comandos Core
+- [ ] `start.md` tiene sección `<enforcement>` y `<state_sync>`
+- [ ] `plan.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+- [ ] `execute.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+- [ ] `verify-work.md` tiene sección `<state_sync>` y `dispatcher` en frontmatter
+
+### Referencias
+- [ ] Todos los archivos usan `.elsabro/state.json` (NO `.planning/SESSION.md`)
+- [ ] `enforcement-rules.md` tiene matriz para los 29 comandos
+- [ ] `state-sync.md` tiene código de sincronización completo
+
+### Skills
+- [ ] Cada skill tiene `tags` en frontmatter
+- [ ] Cada skill tiene versiones específicas de tecnologías
+- [ ] Cada skill tiene `<verification>` ejecutable
+
+---
+
+## FLUJO DE EJECUCIÓN TÍPICO
+
+```
+1. Usuario ejecuta /elsabro:start
+   └─ Lee .elsabro/state.json (si existe)
+   └─ Lanza 2 HAIKU en paralelo para detectar contexto
+   └─ Muestra opciones según proyecto (greenfield/brownfield/continuation)
+   └─ Actualiza state.json con current_flow
+   └─ Invoca siguiente comando con Skill tool
+
+2. /elsabro:plan toma control
+   └─ Lee state.json (contexto de start)
+   └─ Lanza 3 HAIKU en paralelo para explorar
+   └─ Lanza 1 OPUS para crear RESEARCH.md y PLAN.md
+   └─ Lanza 1 SONNET para validar plan
+   └─ Actualiza state.json (plan_file, ready_for_execution)
+   └─ Sugiere /elsabro:execute
+
+3. /elsabro:execute toma control
+   └─ Lee state.json (plan_file)
+   └─ Lanza 3 HAIKU en paralelo para explorar
+   └─ Lanza 2+ OPUS en paralelo para implementar (por wave)
+   └─ Lanza 3 OPUS en paralelo para verificar
+   └─ Actualiza state.json (changed_files, commits)
+   └─ Sugiere /elsabro:verify-work
+
+4. /elsabro:verify-work finaliza
+   └─ Lee state.json (changed_files)
+   └─ Lanza 3 OPUS en paralelo para verificación exhaustiva
+   └─ Genera VERIFICATION-REPORT.md
+   └─ Actualiza state.json (verification_result)
+   └─ Si PASS: "Listo para merge"
+   └─ Si FAIL: Sugiere /elsabro:execute para fix
+```
+
+---
+
+## REGLAS DE ORO
+
+1. **TaskCreate ANTES de cualquier acción**
+2. **TaskUpdate(in_progress) ANTES de Task()**
+3. **Tasks API como backend único** (NO duplicar con sistemas custom)
+4. **Metadata schema consistente** para type, priority, category
+5. **TaskList para sincronización** (NO archivos .md separados)
+6. **Mínimo 3 agentes HAIKU para exploración**
+7. **OPUS para implementación y verificación**
+8. **Context7 ANTES de escribir código con librerías**
+9. **Paralelismo OBLIGATORIO cuando las tareas son independientes**
+10. **Pasar contexto via Task metadata** al siguiente comando