ide_manager.sh

#!/bin/bash

# =============================================================================
# IDE Extensions Manager - Script Maestro
# =============================================================================
# Propósito: Punto de acceso unificado para todas las herramientas de extensiones
# Autor: Generado por Warp AI
# Fecha: 2025-12-24
# =============================================================================

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
MAGENTA='\033[0;35m'
NC='\033[0m'

# Directorio base (directorio del script)
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Función para mostrar banner principal
show_main_banner() {
    echo -e "${MAGENTA}"
    echo "=================================================================="
    echo "             🎯 IDE Extensions Manager Suite"
    echo "=================================================================="
    echo -e "${NC}"
    echo -e "${CYAN}Herramientas para gestión completa de extensiones IDE${NC}"
    echo -e "${YELLOW}Ubicación: $SCRIPT_DIR${NC}"
    echo ""
}

# Función para mostrar menú principal
show_main_menu() {
    echo -e "${BLUE}📋 HERRAMIENTAS DISPONIBLES:${NC}"
    echo ""
    echo -e "${GREEN}1.${NC} 🧹 Limpiar VSCode (cleanup_vscode_extensions.sh)"
    echo -e "   ${CYAN}Elimina extensiones duplicadas y redundantes${NC}"
    echo ""
    echo -e "${GREEN}2.${NC} 🔄 Sincronizar VSCode → Antigravity (sync_extensions_to_antigravity.sh)"
    echo -e "   ${CYAN}Migra extensiones de VSCode a Antigravity${NC}"
    echo ""
    echo -e "${GREEN}3.${NC} 🛠️  Gestor Multi-Editor (extension_manager.sh)"
    echo -e "   ${CYAN}Backup, comparar y sincronizar entre cualquier IDE${NC}"
    echo ""
    echo -e "${GREEN}4.${NC} 📋 Perfiles de Extensiones (profiles_manager.sh)"
    echo -e "   ${CYAN}Aplicar perfiles predefinidos (Frontend, Backend, AI, etc.)${NC}"
    echo ""
    echo -e "${GREEN}5.${NC} ⏰ Sincronización Automática (auto_sync.sh)"
    echo -e "   ${CYAN}Programar sincronización automática con cron/launchd${NC}"
    echo ""
    echo -e "${GREEN}6.${NC} 🔗 Integración Dotfiles (dotfiles_integration.sh)"
    echo -e "   ${CYAN}Integrar con Chezmoi, dotfiles tradicionales, Brewfile${NC}"
    echo ""
    echo -e "${GREEN}7.${NC} 🤖 Configuraciones IDEs AI (ai_ides_config.sh)"
    echo -e "   ${CYAN}Gestionar configuraciones de Trae, Windsurf, Kiro AI${NC}"
    echo ""
    echo -e "${GREEN}8.${NC} 🧠 Integración Agentes AI (ai_agents_integration.sh)"
    echo -e "   ${CYAN}Hooks e integraciones con agentes AI nativos${NC}"
    echo ""
    echo -e "${GREEN}9.${NC} 📱 Interfaz Gráfica (GUI)"
    echo -e "   ${CYAN}Abrir interfaz gráfica con AppleScript${NC}"
    echo ""
    echo -e "${GREEN}10.${NC} 📄 Ver Lista Original de Extensiones"
    echo -e "   ${CYAN}Consultar extensiones detectadas inicialmente${NC}"
    echo ""
    echo -e "${GREEN}11.${NC} 📖 Ver Documentación Completa"
    echo -e "   ${CYAN}README con todas las instrucciones${NC}"
    echo ""
    echo -e "${GREEN}12.${NC} 🔍 Verificar Estado de IDEs"
    echo -e "   ${CYAN}Comprobar qué editores están instalados${NC}"
    echo ""
    echo -e "${GREEN}13.${NC} 🛠️ Herramientas de Diagnóstico"
    echo -e "   ${CYAN}Monitor de sincronización y scripts de recuperación${NC}"
    echo ""
    echo -e "${GREEN}0.${NC} ❌ Salir"
    echo ""
}

# Función para verificar herramientas disponibles
check_tools() {
    echo -e "${BLUE}🔍 Verificando herramientas disponibles...${NC}\n"
    
    # Verificar VSCode
    if command -v code &> /dev/null; then
        local vscode_count=$(code --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ VSCode CLI:${NC} Disponible ($vscode_count extensiones)"
    else
        echo -e "${RED}❌ VSCode CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: VSCode → Cmd+Shift+P → 'Shell Command: Install code command'${NC}"
    fi
    
    # Verificar VSCode Insider
    if command -v code-insiders &> /dev/null; then
        local insider_count=$(code-insiders --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ VSCode Insider CLI:${NC} Disponible ($insider_count extensiones)"
    else
        echo -e "${RED}❌ VSCode Insider CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: VSCode Insider → Cmd+Shift+P → 'Shell Command: Install code-insiders command'${NC}"
    fi
    
    # Verificar Antigravity
    if command -v antigravity &> /dev/null; then
        local ag_count=$(antigravity --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ Antigravity CLI:${NC} Disponible ($ag_count extensiones)"
    else
        echo -e "${RED}❌ Antigravity CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: Antigravity → Preferences → Install Shell Command${NC}"
    fi
    
    # Verificar Cursor
    if command -v cursor &> /dev/null; then
        local cursor_count=$(cursor --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ Cursor CLI:${NC} Disponible ($cursor_count extensiones)"
    else
        echo -e "${RED}❌ Cursor CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: Cursor → Cmd+Shift+P → 'Shell Command: Install cursor command'${NC}"
    fi
    
    # Verificar Trae AI
    if command -v trae &> /dev/null; then
        local trae_count=$(trae --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ Trae AI CLI:${NC} Disponible ($trae_count extensiones)"
    else
        echo -e "${RED}❌ Trae AI CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: Descargar Trae AI + Shell Command (Cmd+Shift+P)${NC}"
    fi
    
    # Verificar Windsurf
    if command -v windsurf &> /dev/null; then
        local windsurf_count=$(windsurf --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ Windsurf CLI:${NC} Disponible ($windsurf_count extensiones)"
    else
        echo -e "${RED}❌ Windsurf CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: Windsurf → configurar CLI desde IDE${NC}"
    fi
    
    # Verificar Kiro AI
    if command -v kiro &> /dev/null; then
        local kiro_count=$(kiro --list-extensions 2>/dev/null | wc -l || echo "0")
        echo -e "${GREEN}✅ Kiro AI CLI:${NC} Disponible ($kiro_count extensiones)"
    else
        echo -e "${RED}❌ Kiro AI CLI:${NC} No encontrado"
        echo -e "   ${YELLOW}Instalar: curl -fsSL https://kiro.dev/install | sh + configurar CLI${NC}"
    fi
    
    echo ""
}

# Función para ejecutar script con manejo de errores
run_script() {
    local script_name="$1"
    local script_path="$SCRIPT_DIR/$script_name"
    
    if [ ! -f "$script_path" ]; then
        echo -e "${RED}❌ Error: Script no encontrado: $script_path${NC}"
        return 1
    fi
    
    if [ ! -x "$script_path" ]; then
        echo -e "${YELLOW}⚠️  Haciendo script ejecutable...${NC}"
        chmod +x "$script_path"
    fi
    
    echo -e "${CYAN}🚀 Ejecutando: $script_name${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    
    "$script_path" "${@:2}"
    local exit_code=$?
    
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    
    if [ $exit_code -eq 0 ]; then
        echo -e "${GREEN}✅ Script completado exitosamente${NC}"
    else
        echo -e "${RED}❌ Script terminó con errores (código: $exit_code)${NC}"
    fi
    
    echo ""
    read -p "Presiona Enter para continuar..." -r
    return $exit_code
}

# Función para mostrar archivo
show_file() {
    local file_name="$1"
    local file_path="$SCRIPT_DIR/$file_name"
    
    if [ ! -f "$file_path" ]; then
        echo -e "${RED}❌ Error: Archivo no encontrado: $file_path${NC}"
        return 1
    fi
    
    echo -e "${CYAN}📄 Mostrando: $file_name${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    
    if command -v bat &> /dev/null; then
        bat "$file_path"
    elif command -v less &> /dev/null; then
        less "$file_path"
    else
        cat "$file_path" | head -50
        echo ""
        echo -e "${YELLOW}... (mostrando primeras 50 líneas)${NC}"
        echo -e "${CYAN}Para ver completo: cat '$file_path' | less${NC}"
    fi
    
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo ""
    read -p "Presiona Enter para continuar..." -r
}

# Función para mostrar submenu de perfiles
show_profiles_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}📋 PERFILES DE EXTENSIONES${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 📋 Listar perfiles disponibles"
        echo -e "${GREEN}2.${NC} 👁️  Ver contenido de un perfil"
        echo -e "${GREEN}3.${NC} ⚡ Aplicar perfil frontend"
        echo -e "${GREEN}4.${NC} 🔧 Aplicar perfil backend"
        echo -e "${GREEN}5.${NC} 🚀 Aplicar perfil fullstack"
        echo -e "${GREEN}6.${NC} 🤖 Aplicar perfil AI"
        echo -e "${GREEN}7.${NC} 🛠️ Aplicar perfil personalizado"
        echo -e "${GREEN}8.${NC} ➕ Crear perfil personalizado"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-8]: " -r choice
        
        case $choice in
            1)
                run_script "profiles_manager.sh" "list"
                ;;
            2)
                run_script "profiles_manager.sh" "list"
                echo -e "${CYAN}Perfiles: frontend, backend, fullstack, datascience, devops, ai, mobile, minimal${NC}"
                read -p "Nombre del perfil a mostrar: " -r profile_name
                run_script "profiles_manager.sh" "show" "$profile_name"
                ;;
            3)
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor de destino: " -r target_editor
                run_script "profiles_manager.sh" "apply" "frontend" "$target_editor"
                ;;
            4)
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor de destino: " -r target_editor
                run_script "profiles_manager.sh" "apply" "backend" "$target_editor"
                ;;
            5)
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor de destino: " -r target_editor
                run_script "profiles_manager.sh" "apply" "fullstack" "$target_editor"
                ;;
            6)
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor de destino: " -r target_editor
                run_script "profiles_manager.sh" "apply" "ai" "$target_editor"
                ;;
            7)
                echo -e "${CYAN}Perfiles disponibles: frontend, backend, fullstack, datascience, devops, ai, mobile, minimal${NC}"
                read -p "Nombre del perfil: " -r profile_name
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor de destino: " -r target_editor
                run_script "profiles_manager.sh" "apply" "$profile_name" "$target_editor"
                ;;
            8)
                echo -e "${CYAN}¿Crear perfil desde editor existente o vacío?${NC}"
                echo -e "${GREEN}1.${NC} Desde editor existente"
                echo -e "${GREEN}2.${NC} Vacío (para editar manualmente)"
                read -p "Selecciona [1-2]: " -r create_option
                read -p "Nombre del nuevo perfil: " -r profile_name
                
                if [ "$create_option" = "1" ]; then
                    echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                    read -p "Editor fuente: " -r source_editor
                    run_script "profiles_manager.sh" "create" "$profile_name" "$source_editor"
                else
                    run_script "profiles_manager.sh" "create" "$profile_name"
                fi
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenu de auto sync
show_auto_sync_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}⏰ SINCRONIZACIÓN AUTOMÁTICA${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 📊 Ver estado actual"
        echo -e "${GREEN}2.${NC} ⚙️  Configurar sincronización"
        echo -e "${GREEN}3.${NC} ▶️  Habilitar sincronización automática"
        echo -e "${GREEN}4.${NC} ⏸️  Deshabilitar sincronización"
        echo -e "${GREEN}5.${NC} 🚀 Ejecutar sincronización manual"
        echo -e "${GREEN}6.${NC} 🧪 Probar configuración"
        echo -e "${GREEN}7.${NC} 📄 Ver log de sincronizaciones"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-7]: " -r choice
        
        case $choice in
            1)
                run_script "auto_sync.sh" "status"
                ;;
            2)
                run_script "auto_sync.sh" "configure"
                ;;
            3)
                run_script "auto_sync.sh" "enable"
                ;;
            4)
                run_script "auto_sync.sh" "disable"
                ;;
            5)
                run_script "auto_sync.sh" "run"
                ;;
            6)
                run_script "auto_sync.sh" "test"
                ;;
            7)
                run_script "auto_sync.sh" "log"
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenu de dotfiles
show_dotfiles_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}🔗 INTEGRACIÓN DOTFILES${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 📊 Ver estado de integración"
        echo -e "${GREEN}2.${NC} 🔍 Detectar sistemas dotfiles instalados"
        echo -e "${GREEN}3.${NC} ⚙️  Configurar integración dotfiles"
        echo -e "${GREEN}4.${NC} 📦 Crear backup de configuraciones"
        echo -e "${GREEN}5.${NC} 🔄 Sincronizar con dotfiles"
        echo -e "${GREEN}6.${NC} 🎩 Integrar con Chezmoi"
        echo -e "${GREEN}7.${NC} 📁 Integrar con dotfiles tradicionales"
        echo -e "${GREEN}8.${NC} 🍺 Generar Brewfile con IDEs"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-8]: " -r choice
        
        case $choice in
            1)
                run_script "dotfiles_integration.sh" "status"
                ;;
            2)
                run_script "dotfiles_integration.sh" "detect"
                ;;
            3)
                run_script "dotfiles_integration.sh" "configure"
                ;;
            4)
                run_script "dotfiles_integration.sh" "backup"
                ;;
            5)
                run_script "dotfiles_integration.sh" "sync"
                ;;
            6)
                run_script "dotfiles_integration.sh" "chezmoi"
                ;;
            7)
                run_script "dotfiles_integration.sh" "traditional"
                ;;
            8)
                echo -e "${CYAN}Ruta del Brewfile (Enter para $HOME/Brewfile):${NC}"
                read -p "Ruta: " -r brewfile_path
                if [[ -n "$brewfile_path" ]]; then
                    run_script "dotfiles_integration.sh" "brewfile" "$brewfile_path"
                else
                    run_script "dotfiles_integration.sh" "brewfile"
                fi
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenu de AI IDEs
show_ai_ides_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}🤖 CONFIGURACIONES IDES AI${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 🔍 Detectar IDEs AI instalados"
        echo -e "${GREEN}2.${NC} 📊 Ver estado de configuraciones AI"
        echo -e "${GREEN}3.${NC} 📦 Crear backup de configuraciones"
        echo -e "${GREEN}4.${NC} 🎨 Crear plantillas predefinidas"
        echo -e "${GREEN}5.${NC} 🔄 Sincronizar configuraciones entre proyectos"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-5]: " -r choice
        
        case $choice in
            1)
                run_script "ai_ides_config.sh" "detect"
                ;;
            2)
                run_script "ai_ides_config.sh" "status"
                ;;
            3)
                run_script "ai_ides_config.sh" "backup"
                ;;
            4)
                run_script "ai_ides_config.sh" "templates"
                ;;
            5)
                echo -e "${CYAN}Proyecto origen:${NC}"
                read -p "Ruta: " -r source_project
                echo -e "${CYAN}Proyecto destino:${NC}"
                read -p "Ruta: " -r target_project
                if [[ -n "$source_project" && -n "$target_project" ]]; then
                    run_script "ai_ides_config.sh" "sync" "$source_project" "$target_project"
                else
                    run_script "ai_ides_config.sh" "sync"
                fi
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenu de agentes AI
show_ai_agents_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}🧠 INTEGRACIÓN AGENTES AI${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 🔍 Detectar agentes AI activos"
        echo -e "${GREEN}2.${NC} 📊 Ver estado de integración"
        echo -e "${GREEN}3.${NC} ⚙️  Configurar integración con agentes"
        echo -e "${GREEN}4.${NC} 🔗 Crear hooks para IDEs AI"
        echo -e "${GREEN}5.${NC} 🔌 Probar conectividad con agentes"
        echo -e "${GREEN}6.${NC} 🚀 Invocar agente AI"
        echo -e "${GREEN}7.${NC} 📺 Monitorear agentes en tiempo real"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-7]: " -r choice
        
        case $choice in
            1)
                run_script "ai_agents_integration.sh" "detect"
                ;;
            2)
                run_script "ai_agents_integration.sh" "status"
                ;;
            3)
                run_script "ai_agents_integration.sh" "configure"
                ;;
            4)
                run_script "ai_agents_integration.sh" "create-hooks"
                ;;
            5)
                run_script "ai_agents_integration.sh" "test-connectivity"
                ;;
            6)
                echo -e "${CYAN}IDE (trae, windsurf, kiro):${NC}"
                read -p "IDE: " -r target_ide
                echo -e "${CYAN}Tarea a ejecutar:${NC}"
                read -p "Tarea: " -r task
                echo -e "${CYAN}Contexto (opcional):${NC}"
                read -p "Contexto: " -r context
                if [[ -n "$target_ide" && -n "$task" ]]; then
                    if [[ -n "$context" ]]; then
                        run_script "ai_agents_integration.sh" "invoke" "$target_ide" "$task" "$context"
                    else
                        run_script "ai_agents_integration.sh" "invoke" "$target_ide" "$task"
                    fi
                else
                    echo -e "${RED}❌ IDE y tarea son requeridos${NC}"
                    sleep 2
                fi
                ;;
            7)
                run_script "ai_agents_integration.sh" "monitor"
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenu de gestor multi-editor
show_extension_manager_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}🛠️  GESTOR MULTI-EDITOR${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 📦 Hacer backup de extensiones"
        echo -e "${GREEN}2.${NC} 📊 Comparar extensiones entre editores"
        echo -e "${GREEN}3.${NC} 🔄 Sincronizar VSCode → Antigravity"
        echo -e "${GREEN}4.${NC} 🔄 Sincronizar VSCode → Cursor"
        echo -e "${GREEN}5.${NC} 🔄 Sincronizar Antigravity → Cursor"
        echo -e "${GREEN}6.${NC} 🔄 Sincronización personalizada"
        echo -e "${GREEN}7.${NC} 📋 Listar editores disponibles"
        echo -e "${GREEN}8.${NC} 🔧 Comando personalizado"
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-8]: " -r choice
        
        case $choice in
            1)
                run_script "extension_manager.sh" "backup"
                ;;
            2)
                run_script "extension_manager.sh" "compare"
                ;;
            3)
                run_script "extension_manager.sh" "sync" "vscode" "antigravity"
                ;;
            4)
                run_script "extension_manager.sh" "sync" "vscode" "cursor"
                ;;
            5)
                run_script "extension_manager.sh" "sync" "antigravity" "cursor"
                ;;
            6)
                echo -e "${CYAN}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                read -p "Editor origen: " -r source_editor
                read -p "Editor destino: " -r target_editor
                run_script "extension_manager.sh" "sync" "$source_editor" "$target_editor"
                ;;
            7)
                run_script "extension_manager.sh" "list"
                ;;
            8)
                echo -e "${CYAN}Comandos disponibles: backup, compare, sync, install, list${NC}"
                echo -e "${YELLOW}Ejemplo: sync vscode cursor${NC}"
                read -p "Comando: " -r custom_command
                run_script "extension_manager.sh" $custom_command
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar submenú de herramientas de diagnóstico
show_diagnostic_tools_menu() {
    while true; do
        clear
        echo -e "${MAGENTA}🛠️ HERRAMIENTAS DE DIAGNÓSTICO${NC}"
        echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        echo -e "${GREEN}1.${NC} 📊 Monitor de Sincronización en Tiempo Real"
        echo -e "   ${CYAN}Supervisar progreso de sincronizaciones activas${NC}"
        echo ""
        echo -e "${GREEN}2.${NC} 🔄 Reanudar Sincronización Interrumpida"
        echo -e "   ${CYAN}Continuar sincronización con manejo de timeouts${NC}"
        echo ""
        echo -e "${GREEN}3.${NC} 🔍 Diagnóstico de Procesos Atascados"
        echo -e "   ${CYAN}Detectar y terminar procesos de instalación colgados${NC}"
        echo ""
        echo -e "${GREEN}4.${NC} 📈 Comparar Estados de Extensiones"
        echo -e "   ${CYAN}Ver diferencias actuales entre editores${NC}"
        echo ""
        echo -e "${GREEN}5.${NC} 🧹 Limpiar Procesos de Instalación"
        echo -e "   ${CYAN}Terminar todos los procesos atascados${NC}"
        echo ""
        echo -e "${GREEN}6.${NC} 📋 Estado Detallado de Sincronización"
        echo -e "   ${CYAN}Análisis completo de extensiones por editor${NC}"
        echo ""
        echo -e "${GREEN}0.${NC} ← Volver al menú principal"
        echo ""
        
        read -p "Selecciona una opción [0-6]: " -r choice
        
        case $choice in
            1)
                echo -e "${CYAN}🔍 Iniciando monitor de sincronización...${NC}"
                echo "Para salir del monitor, presiona Ctrl+C"
                echo ""
                read -p "Presiona Enter para continuar o Ctrl+C para cancelar" -r
                if [[ -f "monitor_sync.sh" ]]; then
                    ./monitor_sync.sh
                else
                    echo -e "${RED}❌ No se encontró monitor_sync.sh${NC}"
                fi
                read -p "Presiona Enter para continuar..." -r
                ;;
            2)
                echo -e "${CYAN}🔄 Seleccionar editores para reanudar sincronización:${NC}"
                echo -e "${YELLOW}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                echo ""
                read -p "Editor origen: " -r source_editor
                read -p "Editor destino: " -r target_editor
                echo ""
                echo -e "${YELLOW}⚠️  Esto terminará procesos atascados y continuará la sincronización${NC}"
                read -p "¿Continuar? (s/N): " -r confirm
                if [[ "$confirm" =~ ^[Ss]$ ]]; then
                    if [[ -f "resume_sync.sh" ]]; then
                        # Mapear nombres de editores a comandos CLI
                        case $source_editor in
                            "vscode") source_cmd="code" ;;
                            "vscode-insiders") source_cmd="code-insiders" ;;
                            "antigravity") source_cmd="antigravity" ;;
                            "cursor") source_cmd="cursor" ;;
                            "trae") source_cmd="trae" ;;
                            "windsurf") source_cmd="windsurf" ;;
                            "kiro") source_cmd="kiro" ;;
                            *) source_cmd="$source_editor" ;;
                        esac
                        
                        case $target_editor in
                            "vscode") target_cmd="code" ;;
                            "vscode-insiders") target_cmd="code-insiders" ;;
                            "antigravity") target_cmd="antigravity" ;;
                            "cursor") target_cmd="cursor" ;;
                            "trae") target_cmd="trae" ;;
                            "windsurf") target_cmd="windsurf" ;;
                            "kiro") target_cmd="kiro" ;;
                            *) target_cmd="$target_editor" ;;
                        esac
                        
                        # Crear script temporal personalizado para los editores seleccionados
                        temp_script=$(mktemp)
                        sed "s/code --list-extensions/$source_cmd --list-extensions/g; s/kiro --list-extensions/$target_cmd --list-extensions/g; s/kiro --install-extension/$target_cmd --install-extension/g" resume_sync.sh > "$temp_script"
                        chmod +x "$temp_script"
                        "$temp_script"
                        rm -f "$temp_script"
                    else
                        echo -e "${RED}❌ No se encontró resume_sync.sh${NC}"
                    fi
                else
                    echo "Operación cancelada"
                fi
                read -p "Presiona Enter para continuar..." -r
                ;;
            3)
                echo -e "${CYAN}🔍 Diagnosticando procesos atascados...${NC}"
                echo ""
                echo -e "${BLUE}Procesos de sincronización activos:${NC}"
                ps aux | grep -E "(extension_manager\.sh|sync)" | grep -v grep || echo "  Ninguno encontrado"
                echo ""
                echo -e "${BLUE}Procesos de instalación de extensiones:${NC}"
                ps aux | grep -E "(install-extension|--install-extension)" | grep -v grep || echo "  Ninguno encontrado"
                echo ""
                echo -e "${YELLOW}¿Terminar procesos atascados? (s/N):${NC}"
                read -p "Respuesta: " -r kill_confirm
                if [[ "$kill_confirm" =~ ^[Ss]$ ]]; then
                    echo "Terminando procesos..."
                    pkill -f "extension_manager.sh" 2>/dev/null && echo "  ✅ Procesos de extension_manager terminados"
                    pkill -f "install-extension" 2>/dev/null && echo "  ✅ Procesos de instalación terminados"
                    echo "Procesos terminados"
                else
                    echo "No se terminaron procesos"
                fi
                read -p "Presiona Enter para continuar..." -r
                ;;
            4)
                echo -e "${CYAN}📈 Comparando estados de extensiones...${NC}"
                echo -e "${YELLOW}Editores disponibles: vscode, vscode-insiders, antigravity, cursor, trae, windsurf, kiro${NC}"
                echo ""
                read -p "Editor 1: " -r editor1
                read -p "Editor 2: " -r editor2
                echo ""
                echo -e "${BLUE}📊 Análisis de diferencias:${NC}"
                
                # Verificar que los comandos existen
                if command -v "$editor1" >/dev/null && command -v "$editor2" >/dev/null; then
                    count1=$("$editor1" --list-extensions 2>/dev/null | wc -l | xargs)
                    count2=$("$editor2" --list-extensions 2>/dev/null | wc -l | xargs)
                    echo "  $editor1: $count1 extensiones"
                    echo "  $editor2: $count2 extensiones"
                    echo ""
                    
                    # Crear archivos temporales para comparación
                    temp1=$(mktemp)
                    temp2=$(mktemp)
                    "$editor1" --list-extensions > "$temp1" 2>/dev/null
                    "$editor2" --list-extensions > "$temp2" 2>/dev/null
                    
                    missing_in_2=$(grep -v -F -f "$temp2" "$temp1" | wc -l | xargs)
                    missing_in_1=$(grep -v -F -f "$temp1" "$temp2" | wc -l | xargs)
                    
                    echo -e "${GREEN}Resultado:${NC}"
                    echo "  Extensiones en $editor1 que faltan en $editor2: $missing_in_2"
                    echo "  Extensiones en $editor2 que faltan en $editor1: $missing_in_1"
                    
                    if [ "$missing_in_2" -gt 0 ]; then
                        echo ""
                        echo -e "${YELLOW}¿Mostrar las extensiones que faltan en $editor2? (s/N):${NC}"
                        read -p "Respuesta: " -r show_missing
                        if [[ "$show_missing" =~ ^[Ss]$ ]]; then
                            echo -e "${CYAN}Extensiones que faltan en $editor2:${NC}"
                            grep -v -F -f "$temp2" "$temp1" | head -20
                            if [ "$missing_in_2" -gt 20 ]; then
                                echo "  ... y $((missing_in_2 - 20)) más"
                            fi
                        fi
                    fi
                    
                    rm -f "$temp1" "$temp2"
                else
                    echo -e "${RED}❌ Uno o ambos editores no están disponibles${NC}"
                fi
                read -p "Presiona Enter para continuar..." -r
                ;;
            5)
                echo -e "${CYAN}🧹 Limpiando procesos de instalación...${NC}"
                echo ""
                echo -e "${YELLOW}⚠️  Esto terminará TODOS los procesos de instalación de extensiones${NC}"
                read -p "¿Continuar? (s/N): " -r clean_confirm
                if [[ "$clean_confirm" =~ ^[Ss]$ ]]; then
                    echo "Terminando procesos de extensiones..."
                    
                    # Terminar procesos de diferentes editores
                    pkill -f "vscode.*install-extension" 2>/dev/null && echo "  ✅ VSCode"
                    pkill -f "code.*install-extension" 2>/dev/null && echo "  ✅ VSCode CLI"
                    pkill -f "cursor.*install-extension" 2>/dev/null && echo "  ✅ Cursor"
                    pkill -f "antigravity.*install-extension" 2>/dev/null && echo "  ✅ Antigravity"
                    pkill -f "trae.*install-extension" 2>/dev/null && echo "  ✅ Trae AI"
                    pkill -f "windsurf.*install-extension" 2>/dev/null && echo "  ✅ Windsurf"
                    pkill -f "kiro.*install-extension" 2>/dev/null && echo "  ✅ Kiro AI"
                    
                    # También terminar scripts de gestión
                    pkill -f "extension_manager" 2>/dev/null && echo "  ✅ Extension managers"
                    pkill -f "sync.*extensions" 2>/dev/null && echo "  ✅ Sync scripts"
                    
                    echo -e "${GREEN}✅ Limpieza completada${NC}"
                else
                    echo "Limpieza cancelada"
                fi
                read -p "Presiona Enter para continuar..." -r
                ;;
            6)
                echo -e "${CYAN}📋 Estado detallado de sincronización...${NC}"
                echo ""
                echo -e "${BLUE}📊 Conteo de extensiones por editor:${NC}"
                
                # Verificar cada editor
                for editor in vscode vscode-insiders antigravity cursor trae windsurf kiro; do
                    if command -v "$editor" >/dev/null 2>&1 || command -v "code" >/dev/null 2>&1; then
                        case $editor in
                            "vscode")
                                if command -v code >/dev/null; then
                                    count=$(code --list-extensions 2>/dev/null | wc -l | xargs)
                                    echo -e "  ${GREEN}✅ VSCode:${NC} $count extensiones"
                                else
                                    echo -e "  ${RED}❌ VSCode CLI no disponible${NC}"
                                fi
                                ;;
                            "vscode-insiders")
                                if command -v code-insiders >/dev/null; then
                                    count=$(code-insiders --list-extensions 2>/dev/null | wc -l | xargs)
                                    echo -e "  ${GREEN}✅ VSCode Insiders:${NC} $count extensiones"
                                else
                                    echo -e "  ${RED}❌ VSCode Insiders no disponible${NC}"
                                fi
                                ;;
                            *)
                                if command -v "$editor" >/dev/null; then
                                    count=$("$editor" --list-extensions 2>/dev/null | wc -l | xargs)
                                    echo -e "  ${GREEN}✅ $(echo $editor | sed 's/^./\U&/')${NC}: $count extensiones"
                                else
                                    echo -e "  ${RED}❌ $(echo $editor | sed 's/^./\U&/') no disponible${NC}"
                                fi
                                ;;
                        esac
                    fi
                done
                
                echo ""
                echo -e "${BLUE}🔄 Procesos activos:${NC}"
                active_syncs=$(ps aux | grep -E "(extension_manager|sync.*extensions)" | grep -v grep | wc -l)
                active_installs=$(ps aux | grep "install-extension" | grep -v grep | wc -l)
                echo "  Sincronizaciones activas: $active_syncs"
                echo "  Instalaciones activas: $active_installs"
                
                if [ "$active_installs" -gt 0 ]; then
                    echo ""
                    echo -e "${YELLOW}Instalaciones en progreso:${NC}"
                    ps aux | grep "install-extension" | grep -v grep | awk '{print "  →", $11, $12, $13}' | head -5
                fi
                
                read -p "Presiona Enter para continuar..." -r
                ;;
            0)
                break
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función principal del menú interactivo
interactive_menu() {
    while true; do
        clear
        show_main_banner
        check_tools
        show_main_menu
        
        read -p "Selecciona una opción [0-13]: " -r choice
        
        case $choice in
            1)
                run_script "cleanup_vscode_extensions.sh"
                ;;
            2)
                echo -e "${CYAN}Opciones de sincronización:${NC}"
                echo -e "${GREEN}1.${NC} Sincronización normal (solo extensiones faltantes)"
                echo -e "${GREEN}2.${NC} Solo verificar (no instalar)"
                echo -e "${GREEN}3.${NC} Forzar reinstalación completa"
                echo ""
                read -p "Selecciona [1-3]: " -r sync_option
                
                case $sync_option in
                    1)
                        run_script "sync_extensions_to_antigravity.sh"
                        ;;
                    2)
                        run_script "sync_extensions_to_antigravity.sh" "--verify"
                        ;;
                    3)
                        run_script "sync_extensions_to_antigravity.sh" "--force"
                        ;;
                    *)
                        echo -e "${RED}❌ Opción inválida${NC}"
                        sleep 1
                        ;;
                esac
                ;;
            3)
                show_extension_manager_menu
                ;;
            4)
                show_profiles_menu
                ;;
            5)
                show_auto_sync_menu
                ;;
            6)
                show_dotfiles_menu
                ;;
            7)
                show_ai_ides_menu
                ;;
            8)
                show_ai_agents_menu
                ;;
            9)
                echo "Abriendo Interfaz Gráfica..."
                if [[ -f "launch_gui.sh" ]]; then
                    ./launch_gui.sh
                else
                    echo -e "${RED}❌ No se encontró launch_gui.sh${NC}"
                    read -p "Presiona Enter para continuar..." -r
                fi
                ;;
            10)
                show_file "original_extensions_list.md"
                ;;
            11)
                show_file "README.md"
                ;;
            12)
                check_tools
                read -p "Presiona Enter para continuar..." -r
                ;;
            13)
                show_diagnostic_tools_menu
                ;;
            0)
                echo -e "${GREEN}¡Hasta luego! 👋${NC}"
                exit 0
                ;;
            *)
                echo -e "${RED}❌ Opción inválida${NC}"
                sleep 1
                ;;
        esac
    done
}

# Función para mostrar ayuda rápida
show_quick_help() {
    echo "IDE Extensions Manager Suite"
    echo ""
    echo "Uso: $0 [comando] [opciones]"
    echo ""
    echo "Comandos directos:"
    echo "  cleanup               Ejecutar limpieza de VSCode"
    echo "  sync [--verify|--force] Sincronizar VSCode → Antigravity"
    echo "  manager <cmd>         Ejecutar comando del gestor multi-editor"
    echo "  profiles <cmd>        Gestionar perfiles de extensiones"
    echo "  auto-sync <cmd>       Configurar sincronización automática"
    echo "  dotfiles <cmd>        Integrar con sistemas dotfiles"
    echo "  ai-ides <cmd>         Gestionar configuraciones IDEs AI"
    echo "  ai-agents <cmd>       Integración con agentes AI nativos"
    echo "  gui                   Abrir interfaz gráfica (AppleScript)"
    echo "  diagnostic            Herramientas de diagnóstico y recuperación"
    echo "  monitor               Monitor de sincronización en tiempo real"
    echo "  resume <src> <dst>    Reanudar sincronización con timeouts"
    echo "  clean-processes       Limpiar procesos de instalación atascados"
    echo "  menu                  Abrir menú interactivo (por defecto)"
    echo ""
    echo "Ejemplos:"
    echo "  $0                    # Menú interactivo"
    echo "  $0 cleanup            # Limpiar VSCode"
    echo "  $0 sync               # Sincronizar a Antigravity"
    echo "  $0 sync --verify      # Solo verificar sincronización"
    echo "  $0 manager backup     # Hacer backup de extensiones"
    echo "  $0 manager compare    # Comparar entre editores"
    echo "  $0 profiles list      # Listar perfiles disponibles"
    echo "  $0 profiles apply ai vscode # Aplicar perfil AI a VSCode"
    echo "  $0 auto-sync status   # Ver estado de sincronización automática"
    echo "  $0 auto-sync enable   # Habilitar sincronización automática"
    echo "  $0 dotfiles detect    # Detectar sistemas dotfiles"
    echo "  $0 dotfiles sync      # Sincronizar con dotfiles"
    echo "  $0 ai-ides detect     # Detectar IDEs AI instalados"
    echo "  $0 ai-ides templates  # Crear plantillas AI"
    echo "  $0 ai-agents detect   # Detectar agentes AI activos"
    echo "  $0 ai-agents invoke trae 'create component' # Invocar agente"
    echo "  $0 diagnostic         # Abrir menú de herramientas de diagnóstico"
    echo "  $0 monitor            # Monitor de sincronización en tiempo real"
    echo "  $0 resume vscode kiro # Reanudar sincronización con timeouts"
    echo "  $0 clean-processes    # Limpiar procesos atascados"
    echo ""
}

# Función principal
main() {
    # Si no hay argumentos, mostrar menú interactivo
    if [ $# -eq 0 ]; then
        interactive_menu
        return 0
    fi
    
    # Procesar comandos directos
    case $1 in
        "cleanup")
            run_script "cleanup_vscode_extensions.sh"
            ;;
        "sync")
            if [ "$2" = "--verify" ]; then
                run_script "sync_extensions_to_antigravity.sh" "--verify"
            elif [ "$2" = "--force" ]; then
                run_script "sync_extensions_to_antigravity.sh" "--force"
            else
                run_script "sync_extensions_to_antigravity.sh"
            fi
            ;;
        "manager")
            run_script "extension_manager.sh" "${@:2}"
            ;;
        "profiles")
            run_script "profiles_manager.sh" "${@:2}"
            ;;
        "auto-sync")
            run_script "auto_sync.sh" "${@:2}"
            ;;
        "dotfiles")
            run_script "dotfiles_integration.sh" "${@:2}"
            ;;
        "ai-ides")
            run_script "ai_ides_config.sh" "${@:2}"
            ;;
        "ai-agents")
            run_script "ai_agents_integration.sh" "${@:2}"
            ;;
        "gui")
            if [[ -f "launch_gui.sh" ]]; then
                ./launch_gui.sh
            else
                echo -e "${RED}❌ No se encontró launch_gui.sh${NC}"
                exit 1
            fi
            ;;
        "diagnostic")
            show_diagnostic_tools_menu
            ;;
        "monitor")
            if [[ -f "monitor_sync.sh" ]]; then
                ./monitor_sync.sh
            else
                echo -e "${RED}❌ No se encontró monitor_sync.sh${NC}"
                exit 1
            fi
            ;;
        "resume")
            if [ $# -lt 3 ]; then
                echo -e "${RED}❌ Uso: $0 resume <editor_origen> <editor_destino>${NC}"
                echo "Ejemplo: $0 resume vscode kiro"
                exit 1
            fi
            source_editor="$2"
            target_editor="$3"
            echo -e "${CYAN}🔄 Reanudando sincronización: $source_editor → $target_editor${NC}"
            if [[ -f "resume_sync.sh" ]]; then
                # Mapear nombres de editores a comandos CLI
                case $source_editor in
                    "vscode") source_cmd="code" ;;
                    "vscode-insiders") source_cmd="code-insiders" ;;
                    "antigravity") source_cmd="antigravity" ;;
                    "cursor") source_cmd="cursor" ;;
                    "trae") source_cmd="trae" ;;
                    "windsurf") source_cmd="windsurf" ;;
                    "kiro") source_cmd="kiro" ;;
                    *) source_cmd="$source_editor" ;;
                esac
                
                case $target_editor in
                    "vscode") target_cmd="code" ;;
                    "vscode-insiders") target_cmd="code-insiders" ;;
                    "antigravity") target_cmd="antigravity" ;;
                    "cursor") target_cmd="cursor" ;;
                    "trae") target_cmd="trae" ;;
                    "windsurf") target_cmd="windsurf" ;;
                    "kiro") target_cmd="kiro" ;;
                    *) target_cmd="$target_editor" ;;
                esac
                
                # Crear script temporal personalizado
                temp_script=$(mktemp)
                sed "s/code --list-extensions/$source_cmd --list-extensions/g; s/kiro --list-extensions/$target_cmd --list-extensions/g; s/kiro --install-extension/$target_cmd --install-extension/g" resume_sync.sh > "$temp_script"
                chmod +x "$temp_script"
                "$temp_script"
                rm -f "$temp_script"
            else
                echo -e "${RED}❌ No se encontró resume_sync.sh${NC}"
                exit 1
            fi
            ;;
        "clean-processes")
            echo -e "${YELLOW}🧹 Limpiando procesos de instalación atascados...${NC}"
            pkill -f "install-extension" 2>/dev/null && echo "✅ Procesos de instalación terminados"
            pkill -f "extension_manager" 2>/dev/null && echo "✅ Scripts de gestión terminados"
            echo -e "${GREEN}✅ Limpieza completada${NC}"
            ;;
        "menu")
            interactive_menu
            ;;
        "-h"|"--help"|"help")
            show_quick_help
            ;;
        *)
            echo -e "${RED}❌ Comando desconocido: $1${NC}"
            echo ""
            show_quick_help
            exit 1
            ;;
    esac
}

# Ejecutar función principal con todos los argumentos
main "$@"