elsabro 2.1.0 → 2.3.0

package/commands/elsabro/verify-work.md

@@ -3,6 +3,7 @@ name: verify-work
 description: Verificación completa del trabajo realizado usando agentes paralelos con Tasks
 allowed-tools:
   - Read
+  - Write
   - Bash
   - Glob
   - Grep
@@ -11,12 +12,127 @@ allowed-tools:
   - TaskUpdate
   - TaskList
   - TaskGet
+  - AskUserQuestion
+sync:
+  reads: [".elsabro/state.json"]
+  writes: [".elsabro/state.json", ".elsabro/context.md", ".planning/VERIFICATION-REPORT.md"]
+  phases: ["initializing", "verifying", "aggregating", "done"]
+  passes_context_to: ["execute (si gaps)", "done"]
+dispatcher:
+  verification:
+    agents: [pr-review-toolkit:code-reviewer, pr-review-toolkit:silent-failure-hunter, pr-review-toolkit:pr-test-analyzer]
+    model: opus
+    parallel: true
+    min_agents: 3
 ---
 
 # /elsabro:verify-work
 
 <command-name>verify-work</command-name>
 
+<state_sync>
+## SINCRONIZACIÓN DE ESTADO (OBLIGATORIO)
+
+**IMPORTAR**: Este comando DEBE seguir `/references/state-sync.md` y `/references/enforcement-rules.md`.
+
+### Al Iniciar (ANTES de cualquier operación)
+
+```javascript
+// 1. Crear task de inicialización
+TaskCreate({
+  subject: "Initialize verify-work command",
+  description: "Leer estado y preparar verificación",
+  activeForm: "Inicializando..."
+})
+TaskUpdate(id, status: "in_progress")
+
+// 2. Leer estado existente
+const state = Read(".elsabro/state.json") || createInitialState();
+
+// 3. Verificar contexto de execute (archivos a verificar)
+if (state.context.changed_files && state.context.changed_files.length > 0) {
+  console.log("Archivos a verificar:", state.context.changed_files);
+  console.log("Commits a revisar:", state.context.commits);
+} else {
+  // No hay contexto de execute - verificar todo
+  console.log("Sin contexto de execute - verificación completa");
+}
+
+// 4. Actualizar estado
+state.current_flow = { command: "verify-work", phase: "initializing", started_at: new Date().toISOString() };
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// 5. Completar task de inicialización
+TaskUpdate(id, status: "completed")
+```
+
+### Al Cambiar de Fase
+
+```javascript
+// Antes de verificación
+state.current_flow.phase = "verifying";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de agregación
+state.current_flow.phase = "aggregating";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+### Al Completar
+
+```javascript
+// Registrar en historial
+state.history.push({
+  command: "verify-work",
+  completed_at: new Date().toISOString(),
+  result: verificationResult,  // "PASS" | "FAIL" | "PARTIAL"
+  artifact: ".planning/VERIFICATION-REPORT.md"
+});
+
+// Actualizar contexto
+state.context.verification_result = verificationResult;
+state.context.ready_for_merge = verificationResult === "PASS";
+
+// Limpiar flujo y sugerir siguiente
+state.current_flow = null;
+state.suggested_next = verificationResult === "PASS" ? null : "execute"; // null = done
+
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Actualizar context.md legible
+Write(".elsabro/context.md", generateHumanReadableContext(state));
+```
+</state_sync>
+
+<review_integration>
+## Integración con Code Review
+
+**IMPORTAR**: Este comando puede invocar `/elsabro:review` para verificación detallada.
+
+### Opción: Review Profundo
+
+Si el usuario solicita verificación exhaustiva, invocar:
+
+```javascript
+// Verificación con code review profesional
+Task({
+  subagent_type: "skill:review",
+  prompt: `
+    /elsabro:review --staged --save
+
+    Guarda el resultado en .planning/REVIEW.md
+  `
+})
+```
+
+### Checklist de Verificación Extendido
+
+Además de los checks estándar, verificar contra:
+- `.planning/mistakes.md` - ¿Se cometieron errores conocidos?
+- `.planning/patterns.md` - ¿Se siguieron los patrones preferidos?
+- `.planning/CLAUDE.md` - ¿Se respetaron las reglas del proyecto?
+</review_integration>
+
 ## Propósito
 
 Verificar que el trabajo completado cumple con los requirements, pasa todos los tests, y está listo para merge/deploy.
@@ -196,7 +312,9 @@ Para verificación, usamos `policy: fail_fast` porque todos los checks son crít
 └────────────────────────────────────────────────┘
 ```
 
-### Lanzamiento de Agentes con Tasks
+### Lanzamiento de Agentes OPUS x3 con Tasks
+
+**OBLIGATORIO:** Usar 3 agentes OPUS especializados para verificación profunda.
 
 ```javascript
 // 1. Marcar todos como in_progress
@@ -204,10 +322,25 @@ TaskUpdate({ taskId: "functional-id", status: "in_progress" })
 TaskUpdate({ taskId: "quality-id", status: "in_progress" })
 TaskUpdate({ taskId: "security-id", status: "in_progress" })
 
-// 2. Lanzar agentes EN UN SOLO MENSAJE (paralelo real)
-Task(elsabro-verifier, model: "opus"): Verify functional requirements |
-Task(elsabro-verifier, model: "opus"): Verify quality metrics |
-Task(elsabro-verifier, model: "opus"): Verify security and edge cases
+// 2. Lanzar 3 agentes OPUS EN UN SOLO MENSAJE (paralelo real)
+Task({
+  subagent_type: "pr-review-toolkit:code-reviewer",
+  model: "opus",  // ← OPUS para análisis profundo
+  description: "Code review completo",
+  prompt: "Revisa los cambios buscando bugs, code smells, mejores prácticas, seguridad..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:silent-failure-hunter",
+  model: "opus",  // ← OPUS para edge cases
+  description: "Buscar errores ocultos",
+  prompt: "Busca errores silenciosos, try/catch que ocultan errores, fallbacks problemáticos..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:pr-test-analyzer",
+  model: "opus",  // ← OPUS para análisis de tests
+  description: "Analizar cobertura de tests",
+  prompt: "Verifica que los tests cubren los cambios, busca casos críticos sin test..."
+})
 
 // 3. Al completar cada uno, marcar completed
 TaskUpdate({

package/hooks/confirm-destructive.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# confirm-destructive.sh - ELSABRO Hook: Confirmar antes de operaciones destructivas
+# Uso: Este hook se ejecuta antes de comandos Bash que coinciden con patrones destructivos
+# Patrones: rm -rf, git reset --hard, git clean -fd, git push --force, drop table, truncate
+
+# Colores
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+# Prefijo ELSABRO
+PREFIX="[ELSABRO:hook]"
+
+# Comando que se va a ejecutar (pasado como argumento)
+COMMAND="${1:-}"
+
+# Patrones destructivos y su descripcion
+declare -A DESTRUCTIVE_PATTERNS=(
+    ["rm -rf"]="Eliminacion recursiva forzada de archivos/directorios"
+    ["rm -r"]="Eliminacion recursiva de archivos/directorios"
+    ["git reset --hard"]="Descarta TODOS los cambios locales sin posibilidad de recuperacion"
+    ["git clean -fd"]="Elimina archivos no rastreados y directorios"
+    ["git clean -f"]="Elimina archivos no rastreados"
+    ["git push --force"]="Sobreescribe historial remoto (puede perder commits de otros)"
+    ["git push -f"]="Sobreescribe historial remoto (puede perder commits de otros)"
+    ["DROP TABLE"]="Elimina tabla de base de datos permanentemente"
+    ["drop table"]="Elimina tabla de base de datos permanentemente"
+    ["TRUNCATE"]="Elimina todos los datos de una tabla"
+    ["truncate"]="Elimina todos los datos de una tabla"
+    ["DELETE FROM"]="Elimina registros de base de datos"
+    ["delete from"]="Elimina registros de base de datos"
+    ["> /dev/null"]="Redirige output (potencialmente peligroso si mal usado)"
+    ["chmod 777"]="Permisos inseguros - todos pueden leer/escribir/ejecutar"
+    ["chmod -R"]="Cambio recursivo de permisos"
+    ["dd if="]="Operacion de disco de bajo nivel"
+    ["mkfs"]="Formateo de sistema de archivos"
+    [":(){ :|:& };:"]="Fork bomb - puede crashear el sistema"
+)
+
+# Detectar patron destructivo
+detect_destructive_pattern() {
+    local cmd="$1"
+
+    for pattern in "${!DESTRUCTIVE_PATTERNS[@]}"; do
+        if [[ "$cmd" == *"$pattern"* ]]; then
+            echo "$pattern"
+            return 0
+        fi
+    done
+
+    echo ""
+    return 1
+}
+
+# Mostrar advertencia
+show_warning() {
+    local pattern="$1"
+    local description="${DESTRUCTIVE_PATTERNS[$pattern]}"
+
+    echo ""
+    echo -e "${RED}${BOLD}========================================${NC}"
+    echo -e "${RED}${BOLD}  ADVERTENCIA: OPERACION DESTRUCTIVA${NC}"
+    echo -e "${RED}${BOLD}========================================${NC}"
+    echo ""
+    echo -e "${YELLOW}$PREFIX Comando detectado:${NC}"
+    echo -e "${BLUE}  $COMMAND${NC}"
+    echo ""
+    echo -e "${YELLOW}$PREFIX Patron peligroso:${NC} ${RED}$pattern${NC}"
+    echo -e "${YELLOW}$PREFIX Riesgo:${NC} $description"
+    echo ""
+    echo -e "${RED}${BOLD}Este comando puede causar perdida de datos irreversible.${NC}"
+    echo ""
+}
+
+# Solicitar confirmacion
+request_confirmation() {
+    # En modo no interactivo (CI/CD), rechazar automaticamente
+    if [ ! -t 0 ]; then
+        echo -e "${RED}$PREFIX Modo no interactivo detectado - rechazando comando destructivo${NC}"
+        echo -e "${YELLOW}$PREFIX Para ejecutar en CI, desactiva el hook 'confirm-destructive'${NC}"
+        return 1
+    fi
+
+    echo -e "${YELLOW}Para confirmar, escribe exactamente: ${BOLD}SI CONFIRMO${NC}"
+    echo -n "> "
+    read -r confirmation
+
+    if [ "$confirmation" = "SI CONFIRMO" ]; then
+        echo -e "${GREEN}$PREFIX Confirmado. Procediendo con el comando...${NC}"
+        return 0
+    else
+        echo -e "${RED}$PREFIX Cancelado. El comando NO se ejecutara.${NC}"
+        return 1
+    fi
+}
+
+# Registrar en log
+log_destructive_attempt() {
+    local pattern="$1"
+    local confirmed="$2"
+    local log_dir=".planning/logs"
+    local log_file="$log_dir/destructive-commands.log"
+
+    # Crear directorio si no existe
+    mkdir -p "$log_dir" 2>/dev/null || true
+
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    local status="REJECTED"
+    [ "$confirmed" = "true" ] && status="CONFIRMED"
+
+    echo "[$timestamp] $status | Pattern: $pattern | Command: $COMMAND" >> "$log_file" 2>/dev/null || true
+}
+
+# Main
+main() {
+    if [ -z "$COMMAND" ]; then
+        # Sin comando, permitir (no hay nada que verificar)
+        exit 0
+    fi
+
+    # Detectar si es destructivo
+    local pattern=$(detect_destructive_pattern "$COMMAND")
+
+    if [ -z "$pattern" ]; then
+        # No es destructivo, permitir
+        exit 0
+    fi
+
+    # Es destructivo - mostrar advertencia
+    show_warning "$pattern"
+
+    # Solicitar confirmacion
+    if request_confirmation; then
+        log_destructive_attempt "$pattern" "true"
+        exit 0  # Permitir ejecucion
+    else
+        log_destructive_attempt "$pattern" "false"
+        exit 1  # Bloquear ejecucion
+    fi
+}
+
+main "$@"

package/hooks/hooks-config.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "ELSABRO Hooks Configuration - Sistema de hooks automaticos para flujos de trabajo",
+  "version": "1.0.0",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "name": "auto-test-on-edit",
+        "description": "Ejecuta tests automaticamente despues de editar codigo",
+        "matcher": "Write|Edit",
+        "command": "./hooks/post-edit-test.sh",
+        "timeout": 30000,
+        "enabled": true
+      },
+      {
+        "name": "lint-on-save",
+        "description": "Ejecuta linter automaticamente despues de escribir",
+        "matcher": "Write",
+        "command": "./hooks/lint-check.sh",
+        "timeout": 10000,
+        "enabled": true
+      }
+    ],
+    "PreToolUse": [
+      {
+        "name": "confirm-destructive",
+        "description": "Confirmar antes de operaciones destructivas",
+        "matcher": "Bash",
+        "pattern": "rm -rf|git reset --hard|git clean -fd|git push --force|drop table|truncate",
+        "command": "./hooks/confirm-destructive.sh",
+        "timeout": 60000,
+        "enabled": true
+      }
+    ],
+    "Notification": [
+      {
+        "name": "task-complete-notify",
+        "description": "Notifica cuando una tarea larga termina",
+        "command": "./hooks/notify-complete.sh",
+        "enabled": false
+      }
+    ]
+  },
+  "profiles": {
+    "development": {
+      "description": "Perfil balanceado para desarrollo diario",
+      "auto-test-on-edit": true,
+      "lint-on-save": true,
+      "confirm-destructive": true
+    },
+    "fast": {
+      "description": "Perfil rapido sin verificaciones automaticas",
+      "auto-test-on-edit": false,
+      "lint-on-save": false,
+      "confirm-destructive": false
+    },
+    "careful": {
+      "description": "Perfil estricto con todas las verificaciones",
+      "auto-test-on-edit": true,
+      "lint-on-save": true,
+      "confirm-destructive": true
+    },
+    "ci": {
+      "description": "Perfil para integracion continua",
+      "auto-test-on-edit": true,
+      "lint-on-save": true,
+      "confirm-destructive": false
+    }
+  },
+  "settings": {
+    "defaultProfile": "development",
+    "logHookExecution": true,
+    "continueOnHookFailure": false,
+    "parallelHooks": false
+  },
+  "installation": {
+    "instructions": "Copia este archivo a ~/.claude/hooks/ o referencia desde settings.json",
+    "settingsPath": "~/.claude/settings.json",
+    "elsabroPath": ".planning/hooks/"
+  }
+}

package/hooks/lint-check.sh

@@ -0,0 +1,238 @@
+#!/bin/bash
+# lint-check.sh - ELSABRO Hook: Ejecuta linter automaticamente despues de escribir
+# Uso: Este hook se ejecuta automaticamente despues de Write
+# Soporta: eslint, biome, prettier, ruff, flake8, black, clippy, gofmt
+
+set -e
+
+# Colores
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Prefijo ELSABRO
+PREFIX="[ELSABRO:hook]"
+
+# Detectar linter disponible
+detect_linter() {
+    # Node.js / JavaScript / TypeScript
+    if [ -f "package.json" ]; then
+        # Biome (mas rapido, preferido si disponible)
+        if grep -q '"@biomejs/biome"' package.json 2>/dev/null || grep -q '"biome"' package.json 2>/dev/null; then
+            echo "biome"
+            return
+        fi
+        # ESLint
+        if grep -q '"eslint"' package.json 2>/dev/null; then
+            echo "eslint"
+            return
+        fi
+        # Prettier (solo formato, no lint)
+        if grep -q '"prettier"' package.json 2>/dev/null; then
+            echo "prettier"
+            return
+        fi
+    fi
+
+    # Biome config file
+    if [ -f "biome.json" ] || [ -f "biome.jsonc" ]; then
+        echo "biome"
+        return
+    fi
+
+    # Python
+    if [ -f "pyproject.toml" ]; then
+        # Ruff (mas rapido, preferido)
+        if grep -q '\[tool.ruff\]' pyproject.toml 2>/dev/null || grep -q 'ruff' pyproject.toml 2>/dev/null; then
+            if command -v ruff &>/dev/null; then
+                echo "ruff"
+                return
+            fi
+        fi
+        # Black (formatter)
+        if grep -q '\[tool.black\]' pyproject.toml 2>/dev/null; then
+            if command -v black &>/dev/null; then
+                echo "black"
+                return
+            fi
+        fi
+        # Flake8
+        if grep -q 'flake8' pyproject.toml 2>/dev/null; then
+            if command -v flake8 &>/dev/null; then
+                echo "flake8"
+                return
+            fi
+        fi
+    fi
+
+    # Python setup.cfg
+    if [ -f "setup.cfg" ]; then
+        if grep -q '\[flake8\]' setup.cfg 2>/dev/null; then
+            if command -v flake8 &>/dev/null; then
+                echo "flake8"
+                return
+            fi
+        fi
+    fi
+
+    # Ruff config file
+    if [ -f "ruff.toml" ] || [ -f ".ruff.toml" ]; then
+        if command -v ruff &>/dev/null; then
+            echo "ruff"
+            return
+        fi
+    fi
+
+    # Rust
+    if [ -f "Cargo.toml" ]; then
+        echo "clippy"
+        return
+    fi
+
+    # Go
+    if [ -f "go.mod" ]; then
+        echo "gofmt"
+        return
+    fi
+
+    # No linter detected
+    echo ""
+}
+
+# Determinar extension del archivo
+get_file_extension() {
+    local file="$1"
+    echo "${file##*.}"
+}
+
+# Verificar si archivo debe ser linteado
+should_lint_file() {
+    local file="$1"
+    local linter="$2"
+    local ext=$(get_file_extension "$file")
+
+    case "$linter" in
+        eslint|biome|prettier)
+            [[ "$ext" =~ ^(js|jsx|ts|tsx|mjs|cjs|json)$ ]]
+            ;;
+        ruff|black|flake8)
+            [[ "$ext" == "py" ]]
+            ;;
+        clippy)
+            [[ "$ext" == "rs" ]]
+            ;;
+        gofmt)
+            [[ "$ext" == "go" ]]
+            ;;
+        *)
+            return 0
+            ;;
+    esac
+}
+
+# Ejecutar linter
+run_linter() {
+    local linter="$1"
+    local file="$2"
+
+    case "$linter" in
+        eslint)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running eslint on $file...${NC}"
+                npx eslint "$file" --fix 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running eslint (project)...${NC}"
+                npx eslint . --fix --ext .js,.jsx,.ts,.tsx 2>/dev/null || true
+            fi
+            ;;
+        biome)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running biome on $file...${NC}"
+                npx @biomejs/biome check --write "$file" 2>/dev/null || npx biome check --apply "$file" 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running biome (project)...${NC}"
+                npx @biomejs/biome check --write . 2>/dev/null || npx biome check --apply 2>/dev/null || true
+            fi
+            ;;
+        prettier)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running prettier on $file...${NC}"
+                npx prettier --write "$file" 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running prettier (project)...${NC}"
+                npx prettier --write . 2>/dev/null || true
+            fi
+            ;;
+        ruff)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running ruff on $file...${NC}"
+                ruff check --fix "$file" 2>/dev/null || true
+                ruff format "$file" 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running ruff (project)...${NC}"
+                ruff check --fix . 2>/dev/null || true
+                ruff format . 2>/dev/null || true
+            fi
+            ;;
+        black)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running black on $file...${NC}"
+                black "$file" 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running black (project)...${NC}"
+                black . 2>/dev/null || true
+            fi
+            ;;
+        flake8)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running flake8 on $file...${NC}"
+                flake8 "$file" 2>/dev/null
+            else
+                echo -e "${BLUE}$PREFIX Running flake8 (project)...${NC}"
+                flake8 . 2>/dev/null
+            fi
+            ;;
+        clippy)
+            echo -e "${BLUE}$PREFIX Running cargo clippy...${NC}"
+            cargo clippy --fix --allow-dirty --allow-staged 2>/dev/null || true
+            ;;
+        gofmt)
+            if [ -n "$file" ] && should_lint_file "$file" "$linter"; then
+                echo -e "${BLUE}$PREFIX Running gofmt on $file...${NC}"
+                gofmt -w "$file" 2>/dev/null || true
+            else
+                echo -e "${BLUE}$PREFIX Running gofmt (project)...${NC}"
+                gofmt -w . 2>/dev/null || true
+            fi
+            ;;
+        *)
+            return 0
+            ;;
+    esac
+}
+
+main() {
+    local changed_file="${1:-}"
+    local linter=$(detect_linter)
+
+    if [ -z "$linter" ]; then
+        echo -e "${YELLOW}$PREFIX No linter detected, skipping lint check${NC}"
+        exit 0
+    fi
+
+    echo -e "${YELLOW}$PREFIX Detected linter: $linter${NC}"
+
+    if run_linter "$linter" "$changed_file"; then
+        echo -e "${GREEN}$PREFIX Linting passed${NC}"
+        exit 0
+    else
+        echo -e "${RED}$PREFIX Linting found issues${NC}"
+        # No exit 1 para no bloquear el flujo
+        # Los linters con --fix ya arreglaron lo que pudieron
+        exit 0
+    fi
+}
+
+main "$@"