elsabro 3.8.2 → 4.0.0

package/hooks/skill-discovery.sh

@@ -1,535 +1,562 @@
 #!/bin/bash
-# skill-discovery.sh - ELSABRO Hook para descubrir skills externos antes del planning
+# skill-discovery.sh - ELSABRO Skill Discovery Hook (v4.0.0)
+#
+# Descubre, sugiere e instala skills usando vercel-labs/skills (npx skills)
+# y escaneo local de ELSABRO skills.
 #
 # Uso: bash ./hooks/skill-discovery.sh "descripción de tarea" "complejidad"
-# Output: JSON con skills descubiertos, validados y rankeados
+# Output: JSON con skills descubiertos, instalados y sugeridos
+#
+# Fuentes de descubrimiento:
+# 1. Skills globales instalados (~/.claude/skills/)
+# 2. Skills locales ELSABRO (./skills/*.md)
+# 3. npx skills find <query> (vercel-labs/skills registry)
 #
-# Responsabilidades:
-# 1. Extraer keywords de la descripción
-# 2. Buscar skills en ELSABRO interno
-# 3. Buscar skills en marketplace externo (skills.sh)
-# 4. Validar y rankear resultados
-# 5. Retornar JSON con estructura normalizada
+# Requiere: bash 4+, jq, node/npm (para npx)
 
-set -e
+set -euo pipefail
 
 # ============================================================================
-# CONFIGURACIÓN Y CONSTANTES
+# CONFIGURACIÓN
 # ============================================================================
 
-# Directorios
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
 ELSABRO_SKILLS_DIR="${PROJECT_ROOT}/skills"
-SKILLS_CACHE_FILE="${PROJECT_ROOT}/.cache/skills-discovery-cache.json"
-SKILLS_REGISTRY="${HOME}/.elsabro/skills-registry.json"
+GLOBAL_SKILLS_DIR="${HOME}/.claude/skills"
+CACHE_DIR="${PROJECT_ROOT}/.cache"
+CACHE_FILE="${CACHE_DIR}/skill-discovery-cache.json"
+CACHE_TTL=3600  # 1 hora
 
-# Configuración de descubrimiento
-KEYWORDS_MIN_MATCH=1
-MAX_SKILLS_RETURN=10
-EXTERNAL_API_TIMEOUT=15
-CACHE_TTL_SECONDS=3600
+MAX_RESULTS=10
+NPX_TIMEOUT=30  # segundos
 
-# Colores para stderr (feedback visual)
+# Colores para stderr
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
-CYAN='\033[0;36m'
 NC='\033[0m'
-
-# Prefijo de logs
-PREFIX="[ELSABRO:skill-discovery]"
+PREFIX="[ELSABRO:skills]"
 
 # ============================================================================
-# UTILIDADES
+# LOGGING (todo a stderr, stdout es solo JSON)
 # ============================================================================
 
-log_info() {
-    echo -e "${BLUE}${PREFIX}${NC} $1" >&2
-}
-
-log_success() {
-    echo -e "${GREEN}${PREFIX}${NC} ✓ $1" >&2
-}
+log_info()    { echo -e "${BLUE}${PREFIX}${NC} $1" >&2; }
+log_success() { echo -e "${GREEN}${PREFIX}${NC} ✓ $1" >&2; }
+log_warn()    { echo -e "${YELLOW}${PREFIX}${NC} ⚠ $1" >&2; }
+log_error()   { echo -e "${RED}${PREFIX}${NC} ✗ $1" >&2; }
 
-log_warn() {
-    echo -e "${YELLOW}${PREFIX}${NC} ⚠ $1" >&2
-}
+# ============================================================================
+# UTILIDADES
+# ============================================================================
 
-log_error() {
-    echo -e "${RED}${PREFIX}${NC} ✗ $1" >&2
+ensure_dirs() {
+    mkdir -p "$CACHE_DIR" 2>/dev/null || true
+    mkdir -p "$GLOBAL_SKILLS_DIR" 2>/dev/null || true
 }
 
-# Crear directorios si no existen
-ensure_dirs() {
-    mkdir -p "$(dirname "$SKILLS_CACHE_FILE")" 2>/dev/null || true
+has_command() {
+    command -v "$1" &>/dev/null
 }
 
-# Verificar si caché es válido
+# Verificar si caché es válido (no expirado)
 is_cache_valid() {
-    local cache_file="$1"
-
-    if [ ! -f "$cache_file" ]; then
+    local cache_key="$1"
+    if [ ! -f "$CACHE_FILE" ]; then
         return 1
     fi
-
-    # Verificar edad del caché (en segundos)
-    local file_age=$(($(date +%s) - $(stat -f%m "$cache_file" 2>/dev/null || echo 0)))
-
-    if [ "$file_age" -gt "$CACHE_TTL_SECONDS" ]; then
+    if ! has_command jq; then
         return 1
     fi
+    local cached_at
+    cached_at=$(jq -r --arg key "$cache_key" '.[$key].cached_at // 0' "$CACHE_FILE" 2>/dev/null || echo "0")
+    local now
+    now=$(date +%s)
+    local age=$(( now - cached_at ))
+    [ "$age" -lt "$CACHE_TTL" ]
+}
+
+get_from_cache() {
+    local cache_key="$1"
+    jq --arg key "$cache_key" '.[$key].data' "$CACHE_FILE" 2>/dev/null
+}
 
-    return 0
+save_to_cache() {
+    local cache_key="$1"
+    local data="$2"
+    ensure_dirs
+    local now
+    now=$(date +%s)
+    local tmp_file="${CACHE_FILE}.tmp.$$"
+    if [ -f "$CACHE_FILE" ] && jq empty "$CACHE_FILE" 2>/dev/null; then
+        jq --arg key "$cache_key" --argjson data "$data" --argjson ts "$now" \
+            '.[$key] = {"data": $data, "cached_at": $ts}' \
+            "$CACHE_FILE" > "$tmp_file" && mv "$tmp_file" "$CACHE_FILE"
+    else
+        jq -n --arg key "$cache_key" --argjson data "$data" --argjson ts "$now" \
+            '{($key): {"data": $data, "cached_at": $ts}}' > "$tmp_file" && mv "$tmp_file" "$CACHE_FILE"
+    fi
 }
 
 # ============================================================================
 # 1. EXTRACCIÓN DE KEYWORDS
 # ============================================================================
 
-# Extrae palabras clave de la descripción de tarea
-# Entrada: string (descripción)
-# Salida: JSON array con keywords encontradas
 extract_keywords() {
-    local task_description="$1"
+    local task="$1"
+    local lower
+    lower=$(echo "$task" | tr '[:upper:]' '[:lower:]')
 
-    # Convertir a lowercase para búsqueda insensible
-    local lowercase=$(echo "$task_description" | tr '[:upper:]' '[:lower:]')
-
-    # Definir patrones de keywords por categoría
-    # Formato: categoria|sinónimo1|sinónimo2|sinónimo3
-    local keyword_patterns=(
+    local -a keyword_patterns=(
         "api|api|backend|endpoint|rest|graphql|http|server"
-        "auth|auth|login|signin|oauth|jwt|session|password|signup|credential"
-        "db|database|db|postgres|postgresql|mysql|mongodb|firebase|sql|orm"
-        "payments|payment|stripe|paypal|billing|checkout|commerce|transaction"
-        "mobile|mobile|expo|react-native|ios|android|app|swift|kotlin"
-        "web|website|web|nextjs|react|vue|angular|frontend|ui|ux|html|css"
-        "devops|devops|docker|kubernetes|k8s|ci|cd|github|gitlab|deploy"
-        "testing|test|jest|vitest|mocha|pytest|coverage|unit|e2e|qa"
-        "security|security|encrypt|https|cors|ssl|tls|hash|salt|breach"
-        "monitoring|monitor|sentry|logging|logs|error|analytics|observability"
-        "cli|cli|command|tool|script|automation|terminal|bash|shell"
-        "ai|ai|machine-learning|ml|gpt|claude|llm|nlp|transformer"
+        "auth|auth|login|signin|oauth|jwt|session|password|signup"
+        "db|database|db|postgres|mysql|mongodb|firebase|sql|orm|prisma|drizzle"
+        "payments|payment|stripe|paypal|billing|checkout|commerce"
+        "mobile|mobile|expo|react-native|ios|android|swift|kotlin|flutter"
+        "web|website|web|nextjs|react|vue|angular|frontend|ui|html|css|tailwind"
+        "devops|devops|docker|kubernetes|k8s|ci|cd|github|gitlab|deploy|deploying|deployment|vercel"
+        "testing|test|testing|jest|vitest|mocha|pytest|coverage|e2e|playwright"
+        "security|security|encrypt|https|cors|ssl|tls|vulnerability"
+        "monitoring|monitor|monitoring|sentry|logging|error|analytics|observability"
+        "cli|cli|command|tool|script|terminal|bash|shell"
+        "ai|ai|machine-learning|ml|gpt|claude|llm|nlp|openai|anthropic"
     )
 
-    # Array para guardar keywords encontrados
-    local found_keywords=()
-    local found_categories=()
+    local -a found=()
 
-    # Buscar cada patrón en la descripción
     for pattern in "${keyword_patterns[@]}"; do
-        IFS='|' read -r category synmap <<< "$pattern"
-
-        # Crear regex de sinónimos
-        local regex=$(echo "$synmap" | sed 's/|/\\|/g')
+        local category="${pattern%%|*}"
+        local synonyms="${pattern#*|}"
 
-        # Buscar con grep case-insensitive
-        if echo "$lowercase" | grep -qiE "\b($regex)\b"; then
-            found_keywords+=("\"$category\"")
-            found_categories+=("$category")
+        # -E (extended regex) uses unescaped | for alternation
+        if echo "$lower" | grep -qiE "\b($synonyms)\b"; then
+            found+=("\"$category\"")
         fi
     done
 
-    # Retornar como JSON array
-    # Si no encontró keywords, retornar array vacío
-    if [ ${#found_keywords[@]} -eq 0 ]; then
+    if [ ${#found[@]} -eq 0 ]; then
         echo "[]"
     else
-        printf "["
-        printf "%s" "${found_keywords[0]}"
-        for kw in "${found_keywords[@]:1}"; do
-            printf ",$kw"
+        local result="[${found[0]}"
+        for kw in "${found[@]:1}"; do
+            result+=",$kw"
         done
-        printf "]\n"
+        result+="]"
+        echo "$result"
     fi
 }
 
 # ============================================================================
-# 2. DESCUBRIMIENTO DE SKILLS - FUENTE 1: ELSABRO INTERNO
+# 2. ESCANEO DE SKILLS INSTALADOS GLOBALMENTE
 # ============================================================================
 
-# Busca skills en ./skills/*.md
-# Entrada: JSON array de keywords
-# Salida: JSON array con skills ELSABRO encontrados
-discover_elsabro_skills() {
-    local keywords="$1"
-
-    local skills_found=()
+scan_installed_skills() {
+    local -a skills=()
 
-    # Verificar que directorio existe
-    if [ ! -d "$ELSABRO_SKILLS_DIR" ]; then
+    if [ ! -d "$GLOBAL_SKILLS_DIR" ]; then
         echo "[]"
         return
     fi
 
-    # Iterar sobre cada archivo .md en skills/
-    for skill_file in "$ELSABRO_SKILLS_DIR"/*.md; do
-        [ -f "$skill_file" ] || continue
-
-        local skill_name=$(basename "$skill_file" .md)
-        local skill_content=$(cat "$skill_file")
+    # Buscar SKILL.md en subdirectorios de ~/.claude/skills/
+    for skill_dir in "$GLOBAL_SKILLS_DIR"/*/; do
+        [ -d "$skill_dir" ] || continue
+        local skill_name
+        skill_name=$(basename "$skill_dir")
+        local skill_file="${skill_dir}SKILL.md"
+
+        if [ -f "$skill_file" ]; then
+            local description=""
+            description=$(sed -n '/^[^#]/p' "$skill_file" | head -1 | cut -c1-100)
+
+            # Use jq for safe JSON construction (avoids injection from special chars)
+            local skill_obj
+            skill_obj=$(jq -n --arg id "$skill_name" --arg desc "$description" --arg loc "$skill_dir" \
+                '{id: $id, source: "installed", status: "installed", location: $loc, description: $desc}')
+            skills+=("$skill_obj")
+        fi
+    done
 
-        # ---- Extraer metadata YAML ----
-        # Buscar secciones YAML en el front matter
+    if [ ${#skills[@]} -eq 0 ]; then
+        echo "[]"
+    else
+        printf '%s\n' "${skills[@]}" | jq -s '.'
+    fi
+}
 
-        local description=$(
-            echo "$skill_content" | sed -n '/^description:/s/^description: *//p' | head -1
-        )
-        description="${description:0:80}"  # Limitar a 80 caracteres
+# ============================================================================
+# 3. ESCANEO DE SKILLS LOCALES ELSABRO
+# ============================================================================
 
-        local difficulty=$(
-            echo "$skill_content" | sed -n '/^difficulty:/s/^difficulty: *//p' | head -1
-        )
-        difficulty="${difficulty:-intermediate}"
+scan_elsabro_skills() {
+    local keywords_json="$1"
 
-        local estimated_time=$(
-            echo "$skill_content" | sed -n '/^estimated_time:/s/^estimated_time: *//p' | head -1
-        )
+    if [ ! -d "$ELSABRO_SKILLS_DIR" ]; then
+        echo "[]"
+        return
+    fi
 
-        # Extraer tags (múltiples líneas)
-        local tags=$(
-            echo "$skill_content" |
-            sed -n '/^tags:/,/^[^ -]/p' |
-            grep "^  - " |
-            sed 's/^  - //' |
-            head -10
-        )
+    local -a skills=()
 
-        # ---- Calcular match score ----
-        # Score = cantidad de keywords que coinciden con tags/description
+    for skill_file in "$ELSABRO_SKILLS_DIR"/*.md; do
+        [ -f "$skill_file" ] || continue
 
-        local match_score=0
+        local skill_name
+        skill_name=$(basename "$skill_file" .md)
 
-        # Convertir keywords de JSON array a array bash
-        local kw_array=()
-        if command -v jq &> /dev/null; then
-            while IFS= read -r kw; do
-                kw_array+=("$kw")
-            done < <(echo "$keywords" | jq -r '.[]' 2>/dev/null)
-        fi
+        # Extraer metadata básica
+        local description=""
+        description=$(sed -n '/^description:/s/^description: *//p' "$skill_file" | head -1 | sed 's/"/\\"/g')
+        description="${description:0:100}"
 
-        # Buscar keywords en tags y descripción
-        for keyword in "${kw_array[@]}"; do
-            if echo "$tags" | grep -qi "$keyword"; then
-                ((match_score++))
-            fi
-            if echo "$description" | grep -qi "$keyword"; then
-                ((match_score++))
-            fi
-        done
+        local tags=""
+        tags=$(sed -n '/^tags:/,/^[^ -]/p' "$skill_file" | grep "^  - " | sed 's/^  - //' | head -10 | tr '\n' ',' | sed 's/,$//')
 
-        # Solo incluir si hay al menos un match
-        if [ "$match_score" -ge "$KEYWORDS_MIN_MATCH" ]; then
-            # Construir objeto skill JSON
-            local tags_json=$(echo "$tags" | jq -R -s -c 'split("\n") | map(select(length > 0))')
-
-            local skill_obj=$(cat <<EOF
-{
-  "id": "$skill_name",
-  "source": "elsabro",
-  "status": "available",
-  "match_score": $match_score,
-  "description": "$description",
-  "difficulty": "$difficulty",
-  "estimated_time": "$estimated_time",
-  "tags": $tags_json,
-  "rank": 0
-}
-EOF
-            )
+        # Calcular match score contra keywords
+        local match_score=0
+        if has_command jq; then
+            local kw_list
+            kw_list=$(echo "$keywords_json" | jq -r '.[]' 2>/dev/null)
+            for kw in $kw_list; do
+                if echo "$tags $description $skill_name" | grep -qi "$kw"; then
+                    match_score=$((match_score + 1))
+                fi
+            done
+        fi
 
-            skills_found+=("$skill_obj")
+        if [ "$match_score" -gt 0 ]; then
+            # Use jq for safe JSON construction
+            local skill_obj
+            skill_obj=$(jq -n --arg id "$skill_name" --arg desc "$description" --arg tags "$tags" --argjson score "$match_score" \
+                '{id: $id, source: "elsabro", status: "available", match_score: $score, description: $desc, tags: $tags}')
+            skills+=("$skill_obj")
         fi
     done
 
-    # Retornar como JSON array
-    if [ ${#skills_found[@]} -eq 0 ]; then
+    if [ ${#skills[@]} -eq 0 ]; then
         echo "[]"
     else
-        # Usar jq para construir array válido
-        printf '%s\n' "${skills_found[@]}" | jq -s '.'
+        printf '%s\n' "${skills[@]}" | jq -s 'sort_by(.match_score) | reverse'
     fi
 }
 
 # ============================================================================
-# 3. DESCUBRIMIENTO DE SKILLS - FUENTE 2: MARKETPLACE EXTERNO
+# 4. DESCUBRIMIENTO EXTERNO VIA npx skills find
 # ============================================================================
 
-# Consulta API de skills.sh para encontrar skills externos
-# Entrada: JSON array de keywords
-# Salida: JSON array con skills de marketplace
-discover_external_skills() {
-    local keywords="$1"
+discover_via_npx_skills() {
+    local query="$1"
 
-    # Si no está disponible curl o jq, retornar array vacío
-    if ! command -v curl &> /dev/null || ! command -v jq &> /dev/null; then
-        log_warn "curl o jq no disponible, saltando external skills"
+    if ! has_command npx; then
+        log_warn "npx no disponible, saltando descubrimiento externo"
         echo "[]"
         return
     fi
 
-    # URL de la API
-    local api_url="https://api.skills.sh/v1/discover"
+    log_info "Ejecutando: npx skills find \"$query\""
 
-    # Payload: array de keywords
-    local payload=$(echo "$keywords" | jq -c '.')
+    local raw_output=""
+    # Ejecutar npx skills find con timeout
+    raw_output=$(timeout "$NPX_TIMEOUT" npx -y skills find "$query" 2>/dev/null) || {
+        log_warn "npx skills find falló o timeout"
+        echo "[]"
+        return
+    }
 
-    log_info "Consultando API: $api_url con keywords: $payload"
+    if [ -z "$raw_output" ]; then
+        echo "[]"
+        return
+    fi
 
-    # Hacer petición HTTP con timeout
-    local response=$(
-        timeout "$EXTERNAL_API_TIMEOUT" curl -s \
-            -X POST "$api_url" \
-            -H "Content-Type: application/json" \
-            -d "{\"keywords\": $payload}" \
-            2>/dev/null || echo "[]"
-    )
+    # npx skills find retorna texto formateado, necesitamos parsearlo a JSON
+    # El formato típico es líneas con nombre y descripción
+    # Intentar parsear como JSON primero (por si devuelve JSON)
+    if echo "$raw_output" | jq empty 2>/dev/null; then
+        echo "$raw_output" | jq '[.[] | . + {"source": "skills-registry", "status": "available", "install_cmd": ("npx skills add -g " + .name)}]' 2>/dev/null || echo "[]"
+        return
+    fi
 
-    # Procesar respuesta (asumir estructura: { "skills": [...] })
-    if echo "$response" | jq empty 2>/dev/null; then
-        # Extractar y enriquecer skills
-        echo "$response" | jq -c '
-            .skills[]? // empty |
-            . + {
-              status: "available",
-              rank: 0,
-              install_command: ("curl -s https://skills.sh/install/" + .id + " | bash")
-            }
-        ' | jq -s '.'
-    else
-        log_warn "API response inválido, retornando array vacío"
+    # Si no es JSON, parsear texto línea por línea
+    local -a skills=()
+    while IFS= read -r line; do
+        # Ignorar líneas vacías y headers
+        [ -z "$line" ] && continue
+        echo "$line" | grep -q "^─\|^━\|^=\|^Found\|^Searching\|^No " && continue
+
+        # Extraer nombre del skill (primera palabra que parece un nombre de skill)
+        local name
+        name=$(echo "$line" | grep -oE '[a-z][a-z0-9_-]+' | head -1)
+        [ -z "$name" ] && continue
+
+        local desc
+        desc=$(echo "$line" | sed "s/$name//" | sed 's/^[[:space:]-]*//' | cut -c1-100)
+
+        # Use jq for safe JSON construction
+        local skill_obj
+        skill_obj=$(jq -n --arg id "$name" --arg desc "$desc" --arg cmd "npx skills add -g $name" \
+            '{id: $id, source: "skills-registry", status: "available", description: $desc, install_cmd: $cmd}')
+        skills+=("$skill_obj")
+    done <<< "$raw_output"
+
+    if [ ${#skills[@]} -eq 0 ]; then
         echo "[]"
+    else
+        printf '%s\n' "${skills[@]}" | jq -s '.' 2>/dev/null || echo "[]"
     fi
 }
 
 # ============================================================================
-# 4. VALIDACIÓN Y RANKING
+# 5. CHECK SKILLS ACTUALIZACIONES
 # ============================================================================
 
-# Valida y rankea todos los skills descubiertos
-# Entrada: JSON array de skills
-# Salida: JSON array validado y ordenado por rank
-validate_and_rank_skills() {
-    local all_skills="$1"
+check_skill_updates() {
+    if ! has_command npx; then
+        echo "[]"
+        return
+    fi
+
+    local check_output=""
+    check_output=$(timeout "$NPX_TIMEOUT" npx -y skills check 2>/dev/null) || {
+        echo "[]"
+        return
+    }
 
-    if ! command -v jq &> /dev/null; then
-        log_warn "jq no disponible, retornando skills sin validación"
-        echo "$all_skills"
+    if [ -z "$check_output" ]; then
+        echo "[]"
         return
     fi
 
-    # Validar y rankear con jq
-    echo "$all_skills" | jq -c '
-        # Filtrar skills válidos
-        map(
-            select(
-                .id != null and
-                .source != null and
-                (.status == "available" or .status == "installable")
-            )
-        ) |
-        # Agregar score de ranking
-        map(
-            . + {
-                rank: (
-                    # Base: match_score
-                    (.match_score // 0) * 100 +
-                    # Bonus por dificultad (beginner > advanced)
-                    (if .difficulty == "beginner" then 50 else
-                     if .difficulty == "intermediate" then 30 else
-                     if .difficulty == "advanced" then 10 else 0 end end) +
-                    # Bonus por source (elsabro es más confiable)
-                    (if .source == "elsabro" then 20 else 0 end) +
-                    # Penalty por external que requiere instalación
-                    (if (.install_command != null) then 0 else 5 end)
-                )
-            }
-        ) |
-        # Ordenar por ranking descendente
-        sort_by(.rank) | reverse |
-        # Limitar a top 10
-        .[0:10]
-    '
+    # Si es JSON, retornar directamente
+    if echo "$check_output" | jq empty 2>/dev/null; then
+        echo "$check_output"
+        return
+    fi
+
+    # Parsear texto de updates disponibles
+    local -a updates=()
+    while IFS= read -r line; do
+        [ -z "$line" ] && continue
+        local name
+        name=$(echo "$line" | grep -oE '[a-z][a-z0-9_-]+' | head -1)
+        [ -z "$name" ] && continue
+        updates+=("{\"id\":\"$name\",\"update_available\":true,\"update_cmd\":\"npx skills update $name\"}")
+    done <<< "$check_output"
+
+    if [ ${#updates[@]} -eq 0 ]; then
+        echo "[]"
+    else
+        printf '%s\n' "${updates[@]}" | jq -s '.' 2>/dev/null || echo "[]"
+    fi
 }
 
 # ============================================================================
-# 5. CACHÉ
+# 6. RANKING Y RECOMENDACIONES
 # ============================================================================
 
-# Intenta obtener skills del caché
-# Entrada: keywords (string)
-# Salida: JSON array con skills si caché válido, "null" si no
-get_from_cache() {
-    local keywords="$1"
-    local keywords_hash=$(echo -n "$keywords" | md5 2>/dev/null || echo "$keywords" | md5sum | awk '{print $1}')
+rank_and_recommend() {
+    local installed="$1"
+    local elsabro="$2"
+    local external="$3"
+    local keywords="$4"
 
-    if ! is_cache_valid "$SKILLS_CACHE_FILE"; then
-        return 1
-    fi
-
-    # Buscar en caché con jq
-    if command -v jq &> /dev/null; then
-        local cached=$(
-            jq --arg hash "$keywords_hash" '.cache[$hash]?' "$SKILLS_CACHE_FILE" 2>/dev/null
-        )
-
-        if [ "$cached" != "null" ] && [ -n "$cached" ]; then
-            log_success "Skill cache hit"
-            echo "$cached"
-            return 0
-        fi
+    if ! has_command jq; then
+        echo "$external"
+        return
     fi
 
-    return 1
-}
-
-# Guardar resultado en caché
-save_to_cache() {
-    local keywords="$1"
-    local skills="$2"
-    local keywords_hash=$(echo -n "$keywords" | md5 2>/dev/null || echo "$keywords" | md5sum | awk '{print $1}')
+    # Combinar todas las fuentes, deduplicar por id, y rankear
+    jq -n \
+        --argjson installed "$installed" \
+        --argjson elsabro "$elsabro" \
+        --argjson external "$external" \
+        --argjson keywords "$keywords" \
+    '
+    # Lista de IDs instalados para filtrar
+    ($installed | map(.id)) as $installed_ids |
+
+    # Combinar elsabro + external, excluir ya instalados
+    ($elsabro + $external)
+    | map(select(.id as $id | $installed_ids | index($id) | not))
+
+    # Deduplicar por id (preferir elsabro sobre external)
+    | group_by(.id)
+    | map(
+        sort_by(if .source == "elsabro" then 0 else 1 end)
+        | first
+    )
 
-    ensure_dirs
+    # Rankear
+    | map(. + {
+        rank: (
+            ((.match_score // 0) * 100) +
+            (if .source == "elsabro" then 20 else 0 end) +
+            (if .source == "skills-registry" then 10 else 0 end)
+        )
+    })
 
-    # Crear o actualizar caché
-    if [ -f "$SKILLS_CACHE_FILE" ]; then
-        jq --arg hash "$keywords_hash" --argjson skills "$skills" \
-            '.cache[$hash] = $skills' "$SKILLS_CACHE_FILE" > "$SKILLS_CACHE_FILE.tmp"
-        mv "$SKILLS_CACHE_FILE.tmp" "$SKILLS_CACHE_FILE"
-    else
-        # Crear caché nuevo
-        jq -n --arg hash "$keywords_hash" --argjson skills "$skills" \
-            '{cache: {($hash): $skills}}' > "$SKILLS_CACHE_FILE"
-    fi
+    # Ordenar por rank descendente y limitar
+    | sort_by(.rank) | reverse
+    | .[0:'"$MAX_RESULTS"']
+    '
 }
 
 # ============================================================================
-# 6. OUTPUT Y FORMATEO
+# 7. GENERAR OUTPUT JSON
 # ============================================================================
 
-# Formatea output final como JSON normalizado
-# Entrada: keywords, skills de cada fuente, skills rankeados
-# Salida: JSON con estructura completa
-format_discovery_output() {
+generate_output() {
     local keywords="$1"
-    local elsabro_skills="$2"
-    local external_skills="$3"
-    local ranked_skills="$4"
-
-    if ! command -v jq &> /dev/null; then
-        # Fallback si jq no está disponible
-        cat <<EOF
-{
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "status": "error",
-  "message": "jq not available"
-}
-EOF
+    local installed="$2"
+    local elsabro="$3"
+    local external="$4"
+    local recommended="$5"
+    local updates="$6"
+
+    if ! has_command jq; then
+        cat <<NOJQ
+{"status":"error","message":"jq not available","timestamp":"$(date -u +%Y-%m-%dT%H:%M:%SZ)"}
+NOJQ
         return 1
     fi
 
-    # Contar elementos
-    local elsabro_count=$(echo "$elsabro_skills" | jq 'length')
-    local external_count=$(echo "$external_skills" | jq 'length')
-    local ranked_count=$(echo "$ranked_skills" | jq 'length')
-
-    # Extraer top 3 recomendaciones
-    local recommendations=$(
-        echo "$ranked_skills" | jq -r '.[0:3] | map(.id) | .[]' | jq -Rs 'split("\n") | map(select(length > 0))'
-    )
-
-    # Construir output final
-    cat <<EOF | jq -c '.'
-{
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
-  "keywords_detected": $keywords,
-  "discovery": {
-    "elsabro": {
-      "count": $elsabro_count,
-      "skills": $elsabro_skills
-    },
-    "external": {
-      "count": $external_count,
-      "skills": $external_skills
-    }
-  },
-  "ranked": {
-    "count": $ranked_count,
-    "skills": $ranked_skills,
-    "recommendations": $recommendations
-  },
-  "status": "success"
-}
-EOF
+    jq -n \
+        --argjson keywords "$keywords" \
+        --argjson installed "$installed" \
+        --argjson elsabro "$elsabro" \
+        --argjson external "$external" \
+        --argjson recommended "$recommended" \
+        --argjson updates "$updates" \
+    '{
+        timestamp: (now | strftime("%Y-%m-%dT%H:%M:%SZ")),
+        status: "success",
+        keywords: $keywords,
+        installed: {
+            count: ($installed | length),
+            skills: $installed
+        },
+        discovered: {
+            elsabro: {
+                count: ($elsabro | length),
+                skills: $elsabro
+            },
+            registry: {
+                count: ($external | length),
+                skills: $external
+            }
+        },
+        recommended: {
+            count: ($recommended | length),
+            skills: $recommended,
+            install_commands: [
+                $recommended[]
+                | select(.install_cmd != null)
+                | {name: .id, command: .install_cmd}
+            ]
+        },
+        updates: {
+            count: ($updates | length),
+            available: $updates
+        },
+        actions: {
+            install_all: (
+                if ($recommended | length) > 0
+                then "npx skills add -g " + ([$recommended[].id] | join(" "))
+                else null
+                end
+            ),
+            update_all: (
+                if ($updates | length) > 0
+                then "npx skills update"
+                else null
+                end
+            )
+        }
+    }'
 }
 
 # ============================================================================
-# 7. FUNCIÓN PRINCIPAL
+# 8. MAIN
 # ============================================================================
 
 main() {
-    local task_description="${1:-}"
+    local task="${1:-}"
     local complexity="${2:-medium}"
 
-    # Validación de entrada
-    if [ -z "$task_description" ]; then
-        cat <<EOF | jq -c '.'
-{
-  "status": "error",
-  "message": "Task description required",
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-}
-EOF
+    # Validate complexity
+    case "$complexity" in
+        low|medium|high) ;;
+        *) complexity="medium" ;;
+    esac
+
+    if [ -z "$task" ]; then
+        jq -n '{"status":"error","message":"Task description required","timestamp":(now | strftime("%Y-%m-%dT%H:%M:%SZ"))}'
         exit 1
     fi
 
-    log_info "Analizando: $task_description (complejidad: $complexity)"
+    ensure_dirs
+    log_info "Skill Discovery para: $task (complejidad: $complexity)"
 
-    # ---- FASE 1: Extraer keywords ----
+    # --- Fase 1: Keywords ---
     log_info "Extrayendo keywords..."
-    local keywords=$(extract_keywords "$task_description")
-    log_success "Keywords: $(echo $keywords | jq -r 'join(", ")')"
+    local keywords
+    keywords=$(extract_keywords "$task")
+    log_success "Keywords: $(echo "$keywords" | jq -r 'join(", ")' 2>/dev/null || echo "$keywords")"
 
-    # ---- FASE 2: Buscar skills (con caché) ----
-    local keywords_str=$(echo "$keywords" | jq -r 'join(",")')
-    local cached_result=""
+    # --- Fase 2: Cache check ---
+    local cache_key
+    cache_key=$(echo -n "${task}|${complexity}" | md5 2>/dev/null || echo -n "${task}|${complexity}" | md5sum 2>/dev/null | awk '{print $1}' || echo "nocache")
 
-    if cached_result=$(get_from_cache "$keywords_str"); then
-        log_success "Usando resultados del caché"
-        # Output y exit
-        echo "$cached_result"
+    if is_cache_valid "$cache_key"; then
+        log_success "Cache hit"
+        get_from_cache "$cache_key"
         exit 0
     fi
 
-    # ---- FASE 3: Descubrir skills de múltiples fuentes ----
-    log_info "Descubriendo skills internos (ELSABRO)..."
-    local elsabro_skills=$(discover_elsabro_skills "$keywords")
-    log_success "ELSABRO skills encontrados: $(echo $elsabro_skills | jq 'length')"
-
-    log_info "Descubriendo skills externos (skills.sh)..."
-    local external_skills=$(discover_external_skills "$keywords")
-    log_success "External skills encontrados: $(echo $external_skills | jq 'length')"
-
-    # ---- FASE 4: Combinar y rankear ----
-    log_info "Combinando y rankeando skills..."
-    local all_skills=$(echo "[$elsabro_skills, $external_skills]" | jq -s 'add // []')
-    local ranked=$(validate_and_rank_skills "$all_skills")
-    log_success "Skills rankeados: $(echo $ranked | jq 'length')"
-
-    # ---- FASE 5: Formatear output ----
-    log_info "Formateando output..."
-    local output=$(format_discovery_output "$keywords" "$elsabro_skills" "$external_skills" "$ranked")
-
-    # Guardar en caché
-    save_to_cache "$keywords_str" "$output"
-
-    # Output final (STDOUT) - esto es lo que captura el Flow Engine
+    # --- Fase 3: Escanear skills instalados ---
+    log_info "Escaneando skills instalados..."
+    local installed
+    installed=$(scan_installed_skills)
+    log_success "Instalados: $(echo "$installed" | jq 'length' 2>/dev/null || echo 0)"
+
+    # --- Fase 4: Escanear skills ELSABRO locales ---
+    log_info "Escaneando skills ELSABRO..."
+    local elsabro
+    elsabro=$(scan_elsabro_skills "$keywords")
+    log_success "ELSABRO: $(echo "$elsabro" | jq 'length' 2>/dev/null || echo 0)"
+
+    # --- Fase 5: Descubrir skills externos ---
+    log_info "Buscando en skills registry..."
+    local query_str
+    query_str=$(echo "$keywords" | jq -r 'join(" ")' 2>/dev/null || echo "$task")
+    local external
+    external=$(discover_via_npx_skills "$query_str")
+    log_success "Registry: $(echo "$external" | jq 'length' 2>/dev/null || echo 0)"
+
+    # --- Fase 6: Check updates ---
+    log_info "Verificando actualizaciones..."
+    local updates
+    updates=$(check_skill_updates)
+    log_success "Updates: $(echo "$updates" | jq 'length' 2>/dev/null || echo 0)"
+
+    # --- Fase 7: Ranking ---
+    log_info "Rankeando recomendaciones..."
+    local recommended
+    recommended=$(rank_and_recommend "$installed" "$elsabro" "$external" "$keywords")
+    log_success "Recomendados: $(echo "$recommended" | jq 'length' 2>/dev/null || echo 0)"
+
+    # --- Fase 8: Output ---
+    local output
+    output=$(generate_output "$keywords" "$installed" "$elsabro" "$external" "$recommended" "$updates")
+
+    # Guardar en cache
+    save_to_cache "$cache_key" "$output" 2>/dev/null || true
+
+    # Output final a STDOUT (esto captura el Flow Engine)
     echo "$output"
 
-    log_success "Discovery completado"
-    exit 0
+    log_success "Skill Discovery completado"
 }
 
 # ============================================================================