SuperClaude/setup/cli/commands/uninstall.py

"""
SuperClaude Uninstall Operation Module
Refactored from uninstall.py for unified CLI hub
"""

import sys
import time
from pathlib import Path
from ...utils.paths import get_home_directory
from typing import List, Optional, Dict, Any
import argparse

from ...core.registry import ComponentRegistry
from ...services.settings import SettingsService
from ...services.files import FileService
from ...utils.ui import (
    display_header, display_info, display_success, display_error, 
    display_warning, Menu, confirm, ProgressBar, Colors
)
from ...utils.environment import get_superclaude_environment_variables, cleanup_environment_variables
from ...utils.logger import get_logger
from ... import DEFAULT_INSTALL_DIR, PROJECT_ROOT
from . import OperationBase


def verify_superclaude_file(file_path: Path, component: str) -> bool:
    """
    Verify this is a SuperClaude file before removal
    
    Args:
        file_path: Path to the file to verify
        component: Component name this file belongs to
        
    Returns:
        True if safe to remove, False if uncertain (preserve by default)
    """
    try:
        # Known SuperClaude file patterns by component
        superclaude_patterns = {
            'core': [
                'CLAUDE.md', 'FLAGS.md', 'PRINCIPLES.md', 'RULES.md', 
                'ORCHESTRATOR.md', 'SESSION_LIFECYCLE.md'
            ],
            'commands': [
                # Commands are only in sc/ subdirectory
            ],
            'agents': [
                'backend-engineer.md', 'brainstorm-PRD.md', 'code-educator.md',
                'code-refactorer.md', 'devops-engineer.md', 'frontend-specialist.md',
                'performance-optimizer.md', 'python-ultimate-expert.md', 'qa-specialist.md',
                'root-cause-analyzer.md', 'security-auditor.md', 'system-architect.md',
                'technical-writer.md'
            ],
            'modes': [
                'MODE_Brainstorming.md', 'MODE_Introspection.md', 
                'MODE_Task_Management.md', 'MODE_Token_Efficiency.md'
            ],
            'mcp_docs': [
                'MCP_Context7.md', 'MCP_Sequential.md', 'MCP_Magic.md',
                'MCP_Playwright.md', 'MCP_Morphllm.md', 'MCP_Serena.md'
            ]
        }
        
        # For commands component, verify it's in the sc/ subdirectory
        if component == 'commands':
            return 'commands/sc/' in str(file_path)
        
        # For other components, check against known file lists
        if component in superclaude_patterns:
            filename = file_path.name
            return filename in superclaude_patterns[component]
        
        # For MCP component, it doesn't remove files but modifies .claude.json
        if component == 'mcp':
            return True  # MCP component has its own safety logic
        
        # Default to preserve if uncertain
        return False
        
    except Exception:
        # If any error occurs in verification, preserve the file
        return False


def verify_directory_safety(directory: Path, component: str) -> bool:
    """
    Verify it's safe to remove a directory
    
    Args:
        directory: Directory path to verify
        component: Component name
        
    Returns:
        True if safe to remove (only if empty or only contains SuperClaude files)
    """
    try:
        if not directory.exists():
            return True
        
        # Check if directory is empty
        contents = list(directory.iterdir())
        if not contents:
            return True
        
        # Check if all contents are SuperClaude files for this component
        for item in contents:
            if item.is_file():
                if not verify_superclaude_file(item, component):
                    return False
            elif item.is_dir():
                # Don't remove directories that contain non-SuperClaude subdirectories
                return False
        
        return True
        
    except Exception:
        # If any error occurs, preserve the directory
        return False


class UninstallOperation(OperationBase):
    """Uninstall operation implementation"""
    
    def __init__(self):
        super().__init__("uninstall")


def register_parser(subparsers, global_parser=None) -> argparse.ArgumentParser:
    """Register uninstall CLI arguments"""
    parents = [global_parser] if global_parser else []
    
    parser = subparsers.add_parser(
        "uninstall",
        help="Remove SuperClaude framework installation",
        description="Uninstall SuperClaude Framework components",
        epilog="""
Examples:
  SuperClaude uninstall                    # Interactive uninstall
  SuperClaude uninstall --components core  # Remove specific components
  SuperClaude uninstall --complete --force # Complete removal (forced)
  SuperClaude uninstall --keep-backups     # Keep backup files
        """,
        formatter_class=argparse.RawDescriptionHelpFormatter,
        parents=parents
    )
    
    # Uninstall mode options
    parser.add_argument(
        "--components",
        type=str,
        nargs="+",
        help="Specific components to uninstall"
    )
    
    parser.add_argument(
        "--complete",
        action="store_true",
        help="Complete uninstall (remove all files and directories)"
    )
    
    # Data preservation options
    parser.add_argument(
        "--keep-backups",
        action="store_true",
        help="Keep backup files during uninstall"
    )
    
    parser.add_argument(
        "--keep-logs",
        action="store_true",
        help="Keep log files during uninstall"
    )
    
    parser.add_argument(
        "--keep-settings",
        action="store_true",
        help="Keep user settings during uninstall"
    )
    
    # Safety options
    parser.add_argument(
        "--no-confirm",
        action="store_true",
        help="Skip confirmation prompts (use with caution)"
    )
    
    # Environment cleanup options
    parser.add_argument(
        "--cleanup-env",
        action="store_true",
        help="Remove SuperClaude environment variables"
    )
    
    parser.add_argument(
        "--no-restore-script",
        action="store_true",
        help="Skip creating environment variable restore script"
    )
    
    return parser

def get_installed_components(install_dir: Path) -> Dict[str, Dict[str, Any]]:
    """Get currently installed components and their versions"""
    try:
        settings_manager = SettingsService(install_dir)
        return settings_manager.get_installed_components()
    except Exception:
        return {}


def get_installation_info(install_dir: Path) -> Dict[str, Any]:
    """Get detailed installation information"""
    info = {
        "install_dir": install_dir,
        "exists": False,
        "components": {},
        "directories": [],
        "files": [],
        "total_size": 0
    }
    
    if not install_dir.exists():
        return info
    
    info["exists"] = True
    info["components"] = get_installed_components(install_dir)
    
    # Scan installation directory
    try:
        for item in install_dir.rglob("*"):
            if item.is_file():
                info["files"].append(item)
                info["total_size"] += item.stat().st_size
            elif item.is_dir():
                info["directories"].append(item)
    except Exception:
        pass
    
    return info


def display_environment_info() -> Dict[str, str]:
    """Display SuperClaude environment variables and return them"""
    env_vars = get_superclaude_environment_variables()
    
    if env_vars:
        print(f"\n{Colors.CYAN}{Colors.BRIGHT}Environment Variables{Colors.RESET}")
        print("=" * 50)
        print(f"{Colors.BLUE}SuperClaude API key environment variables found:{Colors.RESET}")
        for env_var, value in env_vars.items():
            # Show only first few and last few characters for security
            masked_value = f"{value[:4]}...{value[-4:]}" if len(value) > 8 else "***"
            print(f"  {env_var}: {masked_value}")
        
        print(f"\n{Colors.YELLOW}Note: These environment variables will remain unless you use --cleanup-env{Colors.RESET}")
    else:
        print(f"\n{Colors.GREEN}No SuperClaude environment variables found{Colors.RESET}")
    
    return env_vars


def display_uninstall_info(info: Dict[str, Any]) -> None:
    """Display installation information before uninstall"""
    print(f"\n{Colors.CYAN}{Colors.BRIGHT}Current Installation{Colors.RESET}")
    print("=" * 50)
    
    if not info["exists"]:
        print(f"{Colors.YELLOW}No SuperClaude installation found{Colors.RESET}")
        return
    
    print(f"{Colors.BLUE}Installation Directory:{Colors.RESET} {info['install_dir']}")
    
    if info["components"]:
        print(f"{Colors.BLUE}Installed Components:{Colors.RESET}")
        for component, version in info["components"].items():
            print(f"  {component}: v{version}")
    
    print(f"{Colors.BLUE}Files:{Colors.RESET} {len(info['files'])}")
    print(f"{Colors.BLUE}Directories:{Colors.RESET} {len(info['directories'])}")
    
    if info["total_size"] > 0:
        from ...utils.ui import format_size
        print(f"{Colors.BLUE}Total Size:{Colors.RESET} {format_size(info['total_size'])}")
    
    print()


def get_components_to_uninstall(args: argparse.Namespace, installed_components: Dict[str, str]) -> Optional[List[str]]:
    """Determine which components to uninstall"""
    logger = get_logger()
    
    # Complete uninstall
    if args.complete:
        return list(installed_components.keys())
    
    # Explicit components specified
    if args.components:
        # Validate that specified components are installed
        invalid_components = [c for c in args.components if c not in installed_components]
        if invalid_components:
            logger.error(f"Components not installed: {invalid_components}")
            return None
        return args.components
    
    # Interactive selection
    return interactive_uninstall_selection(installed_components)


def interactive_component_selection(installed_components: Dict[str, str], env_vars: Dict[str, str]) -> Optional[tuple]:
    """
    Enhanced interactive selection with granular component options
    
    Returns:
        Tuple of (components_to_remove, cleanup_options) or None if cancelled
    """
    if not installed_components:
        return []
    
    print(f"\n{Colors.CYAN}{Colors.BRIGHT}SuperClaude Uninstall Options{Colors.RESET}")
    print("=" * 60)
    
    # Main uninstall type selection
    main_options = [
        "Complete Uninstall (remove all SuperClaude components)",
        "Custom Uninstall (choose specific components)",
        "Cancel Uninstall"
    ]
    
    print(f"\n{Colors.BLUE}Choose uninstall type:{Colors.RESET}")
    main_menu = Menu("Select option:", main_options)
    main_choice = main_menu.display()
    
    if main_choice == -1 or main_choice == 2:  # Cancelled
        return None
    elif main_choice == 0:  # Complete uninstall
        # Complete uninstall - include all components and optional cleanup
        cleanup_options = _ask_complete_uninstall_options(env_vars)
        return list(installed_components.keys()), cleanup_options
    elif main_choice == 1:  # Custom uninstall
        return _custom_component_selection(installed_components, env_vars)
    
    return None


def _ask_complete_uninstall_options(env_vars: Dict[str, str]) -> Dict[str, bool]:
    """Ask for complete uninstall options"""
    cleanup_options = {
        'remove_mcp_configs': True,
        'cleanup_env_vars': False,
        'create_restore_script': True
    }
    
    print(f"\n{Colors.YELLOW}{Colors.BRIGHT}Complete Uninstall Options{Colors.RESET}")
    print("This will remove ALL SuperClaude components.")
    
    if env_vars:
        print(f"\n{Colors.BLUE}Environment variables found:{Colors.RESET}")
        for env_var, value in env_vars.items():
            masked_value = f"{value[:4]}...{value[-4:]}" if len(value) > 8 else "***"
            print(f"  {env_var}: {masked_value}")
        
        cleanup_env = confirm("Also remove API key environment variables?", default=False)
        cleanup_options['cleanup_env_vars'] = cleanup_env
        
        if cleanup_env:
            create_script = confirm("Create restore script for environment variables?", default=True)
            cleanup_options['create_restore_script'] = create_script
    
    return cleanup_options


def _custom_component_selection(installed_components: Dict[str, str], env_vars: Dict[str, str]) -> Optional[tuple]:
    """Handle custom component selection with granular options"""
    print(f"\n{Colors.CYAN}{Colors.BRIGHT}Custom Uninstall - Choose Components{Colors.RESET}")
    print("Select which SuperClaude components to remove:")
    
    # Build component options with descriptions
    component_options = []
    component_keys = []
    
    component_descriptions = {
        'core': 'Core Framework Files (CLAUDE.md, FLAGS.md, PRINCIPLES.md, etc.)',
        'commands': 'SuperClaude Commands (commands/sc/*.md)',
        'agents': 'Specialized Agents (agents/*.md)',
        'mcp': 'MCP Server Configurations',
        'mcp_docs': 'MCP Documentation',
        'modes': 'SuperClaude Modes'
    }
    
    for component, version in installed_components.items():
        description = component_descriptions.get(component, f"{component} component")
        component_options.append(f"{description}")
        component_keys.append(component)
    
    print(f"\n{Colors.BLUE}Select components to remove:{Colors.RESET}")
    component_menu = Menu("Components:", component_options, multi_select=True)
    selections = component_menu.display()
    
    if not selections:
        return None
    
    selected_components = [component_keys[i] for i in selections]
    
    # If MCP component is selected, ask about related cleanup options
    cleanup_options = {
        'remove_mcp_configs': 'mcp' in selected_components,
        'cleanup_env_vars': False,
        'create_restore_script': True
    }
    
    if 'mcp' in selected_components:
        cleanup_options.update(_ask_mcp_cleanup_options(env_vars))
    elif env_vars:
        # Even if MCP not selected, ask about env vars if they exist
        cleanup_env = confirm(f"Remove {len(env_vars)} API key environment variables?", default=False)
        cleanup_options['cleanup_env_vars'] = cleanup_env
        if cleanup_env:
            create_script = confirm("Create restore script for environment variables?", default=True)
            cleanup_options['create_restore_script'] = create_script
    
    return selected_components, cleanup_options


def _ask_mcp_cleanup_options(env_vars: Dict[str, str]) -> Dict[str, bool]:
    """Ask for MCP-related cleanup options"""
    print(f"\n{Colors.YELLOW}{Colors.BRIGHT}MCP Cleanup Options{Colors.RESET}")
    print("Since you're removing the MCP component:")
    
    cleanup_options = {}
    
    # Ask about MCP server configurations
    remove_configs = confirm("Remove MCP server configurations from .claude.json?", default=True)
    cleanup_options['remove_mcp_configs'] = remove_configs
    
    # Ask about API key environment variables
    if env_vars:
        print(f"\n{Colors.BLUE}Related API key environment variables found:{Colors.RESET}")
        for env_var, value in env_vars.items():
            masked_value = f"{value[:4]}...{value[-4:]}" if len(value) > 8 else "***"
            print(f"  {env_var}: {masked_value}")
        
        cleanup_env = confirm(f"Remove {len(env_vars)} API key environment variables?", default=False)
        cleanup_options['cleanup_env_vars'] = cleanup_env
        
        if cleanup_env:
            create_script = confirm("Create restore script for environment variables?", default=True)
            cleanup_options['create_restore_script'] = create_script
        else:
            cleanup_options['create_restore_script'] = True
    else:
        cleanup_options['cleanup_env_vars'] = False
        cleanup_options['create_restore_script'] = True
    
    return cleanup_options


def interactive_uninstall_selection(installed_components: Dict[str, str]) -> Optional[List[str]]:
    """Legacy function - redirects to enhanced selection"""
    env_vars = get_superclaude_environment_variables()
    result = interactive_component_selection(installed_components, env_vars)
    
    if result is None:
        return None
    
    # For backwards compatibility, return only component list
    components, cleanup_options = result
    return components


def display_preservation_info() -> None:
    """Show what will NOT be removed (user's custom files)"""
    print(f"\n{Colors.GREEN}{Colors.BRIGHT}Files that will be preserved:{Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom commands (not in commands/sc/){Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom agents (not SuperClaude agents){Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom .claude.json configurations{Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom files in shared directories{Colors.RESET}")
    print(f"{Colors.GREEN}+ Claude Code settings and other tools' configurations{Colors.RESET}")


def display_component_details(component: str, info: Dict[str, Any]) -> Dict[str, Any]:
    """Get detailed information about what will be removed for a component"""
    details = {
        'files': [],
        'directories': [],
        'size': 0,
        'description': ''
    }
    
    install_dir = info['install_dir']
    
    component_paths = {
        'core': {
            'files': ['CLAUDE.md', 'FLAGS.md', 'PRINCIPLES.md', 'RULES.md', 'ORCHESTRATOR.md', 'SESSION_LIFECYCLE.md'],
            'description': 'Core framework files in ~/.claude/'
        },
        'commands': {
            'files': 'commands/sc/*.md',
            'description': 'SuperClaude commands in ~/.claude/commands/sc/'
        },
        'agents': {
            'files': 'agents/*.md',
            'description': 'Specialized AI agents in ~/.claude/agents/'
        },
        'mcp': {
            'files': 'MCP server configurations in .claude.json',
            'description': 'MCP server configurations'
        },
        'mcp_docs': {
            'files': 'MCP/*.md',
            'description': 'MCP documentation files'
        },
        'modes': {
            'files': 'MODE_*.md',
            'description': 'SuperClaude operational modes'
        }
    }
    
    if component in component_paths:
        details['description'] = component_paths[component]['description']
        
        # Get actual file count from metadata if available
        component_metadata = info["components"].get(component, {})
        if isinstance(component_metadata, dict):
            if 'files_count' in component_metadata:
                details['file_count'] = component_metadata['files_count']
            elif 'agents_count' in component_metadata:
                details['file_count'] = component_metadata['agents_count']
            elif 'servers_configured' in component_metadata:
                details['file_count'] = component_metadata['servers_configured']
    
    return details


def display_uninstall_plan(components: List[str], args: argparse.Namespace, info: Dict[str, Any], env_vars: Dict[str, str]) -> None:
    """Display detailed uninstall plan"""
    print(f"\n{Colors.CYAN}{Colors.BRIGHT}Uninstall Plan{Colors.RESET}")
    print("=" * 60)
    
    print(f"{Colors.BLUE}Installation Directory:{Colors.RESET} {info['install_dir']}")
    
    if components:
        print(f"\n{Colors.BLUE}Components to remove:{Colors.RESET}")
        total_files = 0
        
        for i, component_name in enumerate(components, 1):
            details = display_component_details(component_name, info)
            version = info["components"].get(component_name, "unknown")
            
            if isinstance(version, dict):
                version_str = version.get('version', 'unknown')
                file_count = details.get('file_count', version.get('files_count', version.get('agents_count', version.get('servers_configured', '?'))))
            else:
                version_str = str(version)
                file_count = details.get('file_count', '?')
            
            print(f"  {i}. {component_name} (v{version_str}) - {file_count} files")
            print(f"     {details['description']}")
            
            if isinstance(file_count, int):
                total_files += file_count
        
        print(f"\n{Colors.YELLOW}Total estimated files to remove: {total_files}{Colors.RESET}")
    
    # Show detailed preservation information
    print(f"\n{Colors.GREEN}{Colors.BRIGHT}Safety Guarantees - Will Preserve:{Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom commands (not in commands/sc/){Colors.RESET}")
    print(f"{Colors.GREEN}+ User's custom agents (not SuperClaude agents){Colors.RESET}")
    print(f"{Colors.GREEN}+ User's .claude.json customizations{Colors.RESET}")
    print(f"{Colors.GREEN}+ Claude Code settings and other tools' configurations{Colors.RESET}")
    
    # Show additional preserved items
    preserved = []
    if args.keep_backups:
        preserved.append("backup files")
    if args.keep_logs:
        preserved.append("log files")
    if args.keep_settings:
        preserved.append("user settings")
    
    if preserved:
        for item in preserved:
            print(f"{Colors.GREEN}+ {item}{Colors.RESET}")
    
    if args.complete:
        print(f"\n{Colors.RED}⚠️  WARNING: Complete uninstall will remove all SuperClaude files{Colors.RESET}")
    
    # Environment variable cleanup information
    if env_vars:
        print(f"\n{Colors.BLUE}Environment Variables:{Colors.RESET}")
        if args.cleanup_env:
            print(f"{Colors.YELLOW}Will remove {len(env_vars)} API key environment variables:{Colors.RESET}")
            for env_var in env_vars.keys():
                print(f"  - {env_var}")
            if not args.no_restore_script:
                print(f"{Colors.GREEN}  + Restore script will be created{Colors.RESET}")
        else:
            print(f"{Colors.BLUE}Will preserve {len(env_vars)} API key environment variables:{Colors.RESET}")
            for env_var in env_vars.keys():
                print(f"  + {env_var}")
    
    print()


def create_uninstall_backup(install_dir: Path, components: List[str]) -> Optional[Path]:
    """Create backup before uninstall"""
    logger = get_logger()
    
    try:
        from datetime import datetime
        backup_dir = install_dir / "backups"
        backup_dir.mkdir(exist_ok=True)
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        backup_name = f"pre_uninstall_{timestamp}.tar.gz"
        backup_path = backup_dir / backup_name
        
        import tarfile
        
        logger.info(f"Creating uninstall backup: {backup_path}")
        
        with tarfile.open(backup_path, "w:gz") as tar:
            for component in components:
                # Add component files to backup
                settings_manager = SettingsService(install_dir)
                # This would need component-specific backup logic
                pass
        
        logger.success(f"Backup created: {backup_path}")
        return backup_path
        
    except Exception as e:
        logger.warning(f"Could not create backup: {e}")
        return None


def perform_uninstall(components: List[str], args: argparse.Namespace, info: Dict[str, Any], env_vars: Dict[str, str]) -> bool:
    """Perform the actual uninstall"""
    logger = get_logger()
    start_time = time.time()
    
    try:
        # Create component registry
        registry = ComponentRegistry(PROJECT_ROOT / "setup" / "components")
        registry.discover_components()
        
        # Create component instances
        component_instances = registry.create_component_instances(components, args.install_dir)
        
        # Setup progress tracking
        progress = ProgressBar(
            total=len(components),
            prefix="Uninstalling: ",
            suffix=""
        )
        
        # Uninstall components
        logger.info(f"Uninstalling {len(components)} components...")
        
        uninstalled_components = []
        failed_components = []
        
        for i, component_name in enumerate(components):
            progress.update(i, f"Uninstalling {component_name}")
            
            try:
                if component_name in component_instances:
                    instance = component_instances[component_name]
                    if instance.uninstall():
                        uninstalled_components.append(component_name)
                        logger.debug(f"Successfully uninstalled {component_name}")
                    else:
                        failed_components.append(component_name)
                        logger.error(f"Failed to uninstall {component_name}")
                else:
                    logger.warning(f"Component {component_name} not found, skipping")
                    
            except Exception as e:
                logger.error(f"Error uninstalling {component_name}: {e}")
                failed_components.append(component_name)
            
            progress.update(i + 1, f"Processed {component_name}")
            time.sleep(0.1)  # Brief pause for visual effect
        
        progress.finish("Uninstall complete")
        
        # Handle complete uninstall cleanup
        if args.complete:
            cleanup_installation_directory(args.install_dir, args)
        
        # Handle environment variable cleanup
        env_cleanup_success = True
        if args.cleanup_env and env_vars:
            logger.info("Cleaning up environment variables...")
            create_restore_script = not args.no_restore_script
            env_cleanup_success = cleanup_environment_variables(env_vars, create_restore_script)
            
            if env_cleanup_success:
                logger.success(f"Removed {len(env_vars)} environment variables")
            else:
                logger.warning("Some environment variables could not be removed")
        
        # Show results
        duration = time.time() - start_time
        
        if failed_components:
            logger.warning(f"Uninstall completed with some failures in {duration:.1f} seconds")
            logger.warning(f"Failed components: {', '.join(failed_components)}")
        else:
            logger.success(f"Uninstall completed successfully in {duration:.1f} seconds")
        
        if uninstalled_components:
            logger.info(f"Uninstalled components: {', '.join(uninstalled_components)}")
        
        return len(failed_components) == 0
        
    except Exception as e:
        logger.exception(f"Unexpected error during uninstall: {e}")
        return False


def cleanup_installation_directory(install_dir: Path, args: argparse.Namespace) -> None:
    """Clean up installation directory for complete uninstall"""
    logger = get_logger()
    file_manager = FileService()
    
    try:
        # Preserve specific directories/files if requested
        preserve_patterns = []
        
        if args.keep_backups:
            preserve_patterns.append("backups/*")
        if args.keep_logs:
            preserve_patterns.append("logs/*")
        if args.keep_settings and not args.complete:
            preserve_patterns.append("settings.json")
        
        # Remove installation directory contents
        if args.complete and not preserve_patterns:
            # Complete removal
            if file_manager.remove_directory(install_dir):
                logger.info(f"Removed installation directory: {install_dir}")
            else:
                logger.warning(f"Could not remove installation directory: {install_dir}")
        else:
            # Selective removal
            for item in install_dir.iterdir():
                should_preserve = False
                
                for pattern in preserve_patterns:
                    if item.match(pattern):
                        should_preserve = True
                        break
                
                if not should_preserve:
                    if item.is_file():
                        file_manager.remove_file(item)
                    elif item.is_dir():
                        file_manager.remove_directory(item)
                        
    except Exception as e:
        logger.error(f"Error during cleanup: {e}")


def run(args: argparse.Namespace) -> int:
    """Execute uninstall operation with parsed arguments"""
    operation = UninstallOperation()
    operation.setup_operation_logging(args)
    logger = get_logger()
    # ✅ Inserted validation code
    expected_home = get_home_directory().resolve()
    actual_dir = args.install_dir.resolve()

    if not str(actual_dir).startswith(str(expected_home)):
        print(f"\n[x] Installation must be inside your user profile directory.")
        print(f"    Expected prefix: {expected_home}")
        print(f"    Provided path:   {actual_dir}")
        sys.exit(1)
    
    try:
        # Validate global arguments
        success, errors = operation.validate_global_args(args)
        if not success:
            for error in errors:
                logger.error(error)
            return 1
        
        # Display header
        if not args.quiet:
            from setup.cli.base import __version__
            display_header(
                f"SuperClaude Uninstall v{__version__}",
                "Removing SuperClaude framework components"
            )
        
        # Get installation information
        info = get_installation_info(args.install_dir)
        
        # Display current installation
        if not args.quiet:
            display_uninstall_info(info)
        
        # Check for environment variables
        env_vars = display_environment_info() if not args.quiet else get_superclaude_environment_variables()
        
        # Check if SuperClaude is installed
        if not info["exists"]:
            logger.warning(f"No SuperClaude installation found in {args.install_dir}")
            return 0
        
        # Get components to uninstall using enhanced selection
        if args.components or args.complete:
            # Non-interactive mode - use existing logic
            components = get_components_to_uninstall(args, info["components"])
            cleanup_options = {
                'remove_mcp_configs': 'mcp' in (components or []),
                'cleanup_env_vars': args.cleanup_env,
                'create_restore_script': not args.no_restore_script
            }
            if components is None:
                logger.info("Uninstall cancelled by user")
                return 0
            elif not components:
                logger.info("No components selected for uninstall")
                return 0
        else:
            # Interactive mode - use enhanced selection
            result = interactive_component_selection(info["components"], env_vars)
            if result is None:
                logger.info("Uninstall cancelled by user")
                return 0
            elif not result:
                logger.info("No components selected for uninstall")
                return 0
            
            components, cleanup_options = result
            
            # Override command-line args with interactive choices
            args.cleanup_env = cleanup_options.get('cleanup_env_vars', False)
            args.no_restore_script = not cleanup_options.get('create_restore_script', True)
        
        # Display uninstall plan
        if not args.quiet:
            display_uninstall_plan(components, args, info, env_vars)
        
        # Confirmation
        if not args.no_confirm and not args.yes:
            if args.complete:
                warning_msg = "This will completely remove SuperClaude. Continue?"
            else:
                warning_msg = f"This will remove {len(components)} component(s). Continue?"
            
            if not confirm(warning_msg, default=False):
                logger.info("Uninstall cancelled by user")
                return 0
        
        # Create backup if not dry run and not keeping backups
        if not args.dry_run and not args.keep_backups:
            create_uninstall_backup(args.install_dir, components)
        
        # Perform uninstall
        success = perform_uninstall(components, args, info, env_vars)
        
        if success:
            if not args.quiet:
                display_success("SuperClaude uninstall completed successfully!")
                
                if not args.dry_run:
                    print(f"\n{Colors.CYAN}Uninstall complete:{Colors.RESET}")
                    print(f"SuperClaude has been removed from {args.install_dir}")
                    if not args.complete:
                        print(f"You can reinstall anytime using 'SuperClaude install'")
                    
            return 0
        else:
            display_error("Uninstall completed with some failures. Check logs for details.")
            return 1
            
    except KeyboardInterrupt:
        print(f"\n{Colors.YELLOW}Uninstall cancelled by user{Colors.RESET}")
        return 130
    except Exception as e:
        return operation.handle_operation_error("uninstall", e)