mirror of
https://github.com/SuperClaude-Org/SuperClaude_Framework.git
synced 2025-12-17 09:46:06 +00:00
9abaa10366
- Convert all hardcoded versions to dynamic loading from VERSION file - Reduce version update locations from 50+ to just 3 files - Add proper fallback handling for version reading - Update all CLI commands to use dynamic __version__ - Streamline future version management process This change makes version bumping much simpler - only need to update: 1. VERSION file 2. package.json 3. pyproject.toml
882 lines
33 KiB
Python
882 lines
33 KiB
Python
"""
|
|
SuperClaude Uninstall Operation Module
|
|
Refactored from uninstall.py for unified CLI hub
|
|
"""
|
|
|
|
import sys
|
|
import time
|
|
from pathlib import Path
|
|
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 = Path.home().resolve()
|
|
actual_dir = args.install_dir.resolve()
|
|
|
|
if not str(actual_dir).startswith(str(expected_home)):
|
|
print(f"\n[✗] 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)
|