mirror of
https://github.com/SuperClaude-Org/SuperClaude_Framework.git
synced 2025-12-29 16:16:08 +00:00
01ddc14354
**Changes**: - Remove individual MCP server docs (superclaude/mcp/*.md) - Remove MCP server configs (superclaude/mcp/configs/*.json) - Delete MCP docs component (setup/components/mcp_docs.py) - Simplify installer (setup/core/installer.py) - Update components for unified gateway approach **Rationale**: - Unified gateway (airis-mcp-gateway) provides all MCP servers - Individual docs/configs no longer needed (managed centrally) - Reduces maintenance burden and file count - Simplifies installation process **Files Removed**: 17 MCP files (docs + configs) **Installer Changes**: Removed legacy MCP installation logic 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
984 lines
33 KiB
Python
984 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 ...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",
|
|
],
|
|
}
|
|
|
|
# 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 (airis-mcp-gateway)",
|
|
"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 (airis-mcp-gateway)",
|
|
},
|
|
"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)
|