SuperClaude/setup/components/hooks.py

"""
Hooks component for Claude Code hooks integration (future-ready)
"""

from typing import Dict, List, Tuple, Any
from pathlib import Path

from ..base.component import Component
from ..core.file_manager import FileManager
from ..core.settings_manager import SettingsManager
from ..utils.security import SecurityValidator
from ..utils.logger import get_logger


class HooksComponent(Component):
    """Claude Code hooks integration component"""
    
    def __init__(self, install_dir: Path = None):
        """Initialize hooks component"""
        super().__init__(install_dir)
        self.logger = get_logger()
        self.file_manager = FileManager()
        self.settings_manager = SettingsManager(self.install_dir)
        
        # Define hook files to install (when hooks are ready)
        self.hook_files = [
            "pre_tool_use.py",
            "post_tool_use.py",
            "error_handler.py",
            "context_accumulator.py",
            "performance_monitor.py"
        ]
    
    def get_metadata(self) -> Dict[str, str]:
        """Get component metadata"""
        return {
            "name": "hooks",
            "version": "3.0.0",
            "description": "Claude Code hooks integration (future-ready)",
            "category": "integration"
        }
    
    def validate_prerequisites(self) -> Tuple[bool, List[str]]:
        """Check prerequisites"""
        errors = []
        
        # Check if source directory exists (when hooks are implemented)
        source_dir = self._get_source_dir()
        if not source_dir.exists():
            # This is expected for now - hooks are future-ready
            self.logger.debug(f"Hooks source directory not found: {source_dir} (expected for future implementation)")
        
        # Check write permissions to install directory
        hooks_dir = self.install_dir / "hooks"
        has_perms, missing = SecurityValidator.check_permissions(
            self.install_dir, {'write'}
        )
        if not has_perms:
            errors.append(f"No write permissions to {self.install_dir}: {missing}")
        
        # Validate installation target
        is_safe, validation_errors = SecurityValidator.validate_installation_target(hooks_dir)
        if not is_safe:
            errors.extend(validation_errors)
        
        return len(errors) == 0, errors
    
    def get_files_to_install(self) -> List[Tuple[Path, Path]]:
        """Get files to install"""
        source_dir = self._get_source_dir()
        files = []
        
        # Only include files that actually exist
        for filename in self.hook_files:
            source = source_dir / filename
            if source.exists():
                target = self.install_dir / "hooks" / filename
                files.append((source, target))
        
        return files
    
    def get_settings_modifications(self) -> Dict[str, Any]:
        """Get settings modifications"""
        hooks_dir = self.install_dir / "hooks"
        
        # Build hooks configuration based on available files
        hook_config = {}
        for filename in self.hook_files:
            hook_path = hooks_dir / filename
            if hook_path.exists():
                hook_name = filename.replace('.py', '')
                hook_config[hook_name] = [str(hook_path)]
        
        settings_mods = {
            "components": {
                "hooks": {
                    "version": "3.0.0",
                    "installed": True,
                    "files_count": len(hook_config)
                }
            }
        }
        
        # Only add hooks configuration if we have actual hook files
        if hook_config:
            settings_mods["hooks"] = {
                "enabled": True,
                **hook_config
            }
        
        return settings_mods
    
    def install(self, config: Dict[str, Any]) -> bool:
        """Install hooks component"""
        try:
            self.logger.info("Installing SuperClaude hooks component...")
            
            # This component is future-ready - hooks aren't implemented yet
            source_dir = self._get_source_dir()
            if not source_dir.exists():
                self.logger.info("Hooks are not yet implemented - installing placeholder component")
                
                # Create placeholder hooks directory
                hooks_dir = self.install_dir / "hooks"
                if not self.file_manager.ensure_directory(hooks_dir):
                    self.logger.error(f"Could not create hooks directory: {hooks_dir}")
                    return False
                
                # Create placeholder file
                placeholder_content = '''"""
SuperClaude Hooks - Future Implementation

This directory is reserved for Claude Code hooks integration.
Hooks will provide lifecycle management and automation capabilities.

Planned hooks:
- pre_tool_use: Execute before tool usage
- post_tool_use: Execute after tool completion
- error_handler: Handle tool errors and recovery
- context_accumulator: Manage context across operations
- performance_monitor: Track and optimize performance

For more information, see SuperClaude documentation.
"""

# Placeholder for future hooks implementation
def placeholder_hook():
    """Placeholder hook function"""
    pass
'''
                
                placeholder_path = hooks_dir / "PLACEHOLDER.py"
                try:
                    with open(placeholder_path, 'w') as f:
                        f.write(placeholder_content)
                    self.logger.debug("Created hooks placeholder file")
                except Exception as e:
                    self.logger.warning(f"Could not create placeholder file: {e}")
                
                # Update settings with placeholder registration
                try:
                    settings_mods = {
                        "components": {
                            "hooks": {
                                "version": "3.0.0",
                                "installed": True,
                                "status": "placeholder",
                                "files_count": 0
                            }
                        }
                    }
                    self.settings_manager.update_settings(settings_mods)
                    self.logger.info("Updated settings.json with hooks component registration")
                except Exception as e:
                    self.logger.error(f"Failed to update settings.json: {e}")
                    return False
                
                self.logger.success("Hooks component installed successfully (placeholder)")
                return True
            
            # If hooks source directory exists, install actual hooks
            self.logger.info("Installing actual hook files...")
            
            # Validate installation
            success, errors = self.validate_prerequisites()
            if not success:
                for error in errors:
                    self.logger.error(error)
                return False
            
            # Get files to install
            files_to_install = self.get_files_to_install()
            
            if not files_to_install:
                self.logger.warning("No hook files found to install")
                return False
            
            # Validate all files for security
            hooks_dir = self.install_dir / "hooks"
            is_safe, security_errors = SecurityValidator.validate_component_files(
                files_to_install, source_dir, hooks_dir
            )
            if not is_safe:
                for error in security_errors:
                    self.logger.error(f"Security validation failed: {error}")
                return False
            
            # Ensure hooks directory exists
            if not self.file_manager.ensure_directory(hooks_dir):
                self.logger.error(f"Could not create hooks directory: {hooks_dir}")
                return False
            
            # Copy hook files
            success_count = 0
            for source, target in files_to_install:
                self.logger.debug(f"Copying {source.name} to {target}")
                
                if self.file_manager.copy_file(source, target):
                    success_count += 1
                    self.logger.debug(f"Successfully copied {source.name}")
                else:
                    self.logger.error(f"Failed to copy {source.name}")
            
            if success_count != len(files_to_install):
                self.logger.error(f"Only {success_count}/{len(files_to_install)} hook files copied successfully")
                return False
            
            # Update settings.json
            try:
                settings_mods = self.get_settings_modifications()
                self.settings_manager.update_settings(settings_mods)
                self.logger.info("Updated settings.json with hooks configuration")
            except Exception as e:
                self.logger.error(f"Failed to update settings.json: {e}")
                return False
            
            self.logger.success(f"Hooks component installed successfully ({success_count} hook files)")
            return True
            
        except Exception as e:
            self.logger.exception(f"Unexpected error during hooks installation: {e}")
            return False
    
    def uninstall(self) -> bool:
        """Uninstall hooks component"""
        try:
            self.logger.info("Uninstalling SuperClaude hooks component...")
            
            # Remove hook files and placeholder
            hooks_dir = self.install_dir / "hooks"
            removed_count = 0
            
            # Remove actual hook files
            for filename in self.hook_files:
                file_path = hooks_dir / filename
                if self.file_manager.remove_file(file_path):
                    removed_count += 1
                    self.logger.debug(f"Removed {filename}")
            
            # Remove placeholder file
            placeholder_path = hooks_dir / "PLACEHOLDER.py"
            if self.file_manager.remove_file(placeholder_path):
                removed_count += 1
                self.logger.debug("Removed hooks placeholder")
            
            # Remove hooks directory if empty
            try:
                if hooks_dir.exists():
                    remaining_files = list(hooks_dir.iterdir())
                    if not remaining_files:
                        hooks_dir.rmdir()
                        self.logger.debug("Removed empty hooks directory")
            except Exception as e:
                self.logger.warning(f"Could not remove hooks directory: {e}")
            
            # Update settings.json to remove hooks component and configuration
            try:
                if self.settings_manager.is_component_installed("hooks"):
                    self.settings_manager.remove_component_registration("hooks")
                    
                    # Also remove hooks configuration section if it exists
                    settings = self.settings_manager.load_settings()
                    if "hooks" in settings:
                        del settings["hooks"]
                        self.settings_manager.save_settings(settings)
                    
                    self.logger.info("Removed hooks component and configuration from settings.json")
            except Exception as e:
                self.logger.warning(f"Could not update settings.json: {e}")
            
            self.logger.success(f"Hooks component uninstalled ({removed_count} files removed)")
            return True
            
        except Exception as e:
            self.logger.exception(f"Unexpected error during hooks uninstallation: {e}")
            return False
    
    def get_dependencies(self) -> List[str]:
        """Get dependencies"""
        return ["core"]
    
    def update(self, config: Dict[str, Any]) -> bool:
        """Update hooks component"""
        try:
            self.logger.info("Updating SuperClaude hooks component...")
            
            # Check current version
            current_version = self.settings_manager.get_component_version("hooks")
            target_version = self.get_metadata()["version"]
            
            if current_version == target_version:
                self.logger.info(f"Hooks component already at version {target_version}")
                return True
            
            self.logger.info(f"Updating hooks component from {current_version} to {target_version}")
            
            # Create backup of existing hook files
            hooks_dir = self.install_dir / "hooks"
            backup_files = []
            
            if hooks_dir.exists():
                for filename in self.hook_files + ["PLACEHOLDER.py"]:
                    file_path = hooks_dir / filename
                    if file_path.exists():
                        backup_path = self.file_manager.backup_file(file_path)
                        if backup_path:
                            backup_files.append(backup_path)
                            self.logger.debug(f"Backed up {filename}")
            
            # Perform installation (overwrites existing files)
            success = self.install(config)
            
            if success:
                # Remove backup files on successful update
                for backup_path in backup_files:
                    try:
                        backup_path.unlink()
                    except Exception:
                        pass  # Ignore cleanup errors
                
                self.logger.success(f"Hooks component updated to version {target_version}")
            else:
                # Restore from backup on failure
                self.logger.warning("Update failed, restoring from backup...")
                for backup_path in backup_files:
                    try:
                        original_path = backup_path.with_suffix('')
                        backup_path.rename(original_path)
                        self.logger.debug(f"Restored {original_path.name}")
                    except Exception as e:
                        self.logger.error(f"Could not restore {backup_path}: {e}")
            
            return success
            
        except Exception as e:
            self.logger.exception(f"Unexpected error during hooks update: {e}")
            return False
    
    def validate_installation(self) -> Tuple[bool, List[str]]:
        """Validate hooks component installation"""
        errors = []
        
        # Check if hooks directory exists
        hooks_dir = self.install_dir / "hooks"
        if not hooks_dir.exists():
            errors.append("Hooks directory not found")
            return False, errors
        
        # Check settings.json registration
        if not self.settings_manager.is_component_installed("hooks"):
            errors.append("Hooks component not registered in settings.json")
        else:
            # Check version matches
            installed_version = self.settings_manager.get_component_version("hooks")
            expected_version = self.get_metadata()["version"]
            if installed_version != expected_version:
                errors.append(f"Version mismatch: installed {installed_version}, expected {expected_version}")
        
        # Check if we have either actual hooks or placeholder
        has_placeholder = (hooks_dir / "PLACEHOLDER.py").exists()
        has_actual_hooks = any((hooks_dir / filename).exists() for filename in self.hook_files)
        
        if not has_placeholder and not has_actual_hooks:
            errors.append("No hook files or placeholder found")
        
        return len(errors) == 0, errors
    
    def _get_source_dir(self) -> Path:
        """Get source directory for hook files"""
        # Assume we're in SuperClaude/setup/components/hooks.py
        # and hook files are in SuperClaude/SuperClaude/Hooks/
        project_root = Path(__file__).parent.parent.parent
        return project_root / "SuperClaude" / "Hooks"
    
    def get_size_estimate(self) -> int:
        """Get estimated installation size"""
        # Estimate based on placeholder or actual files
        source_dir = self._get_source_dir()
        total_size = 0
        
        if source_dir.exists():
            for filename in self.hook_files:
                file_path = source_dir / filename
                if file_path.exists():
                    total_size += file_path.stat().st_size
        
        # Add placeholder overhead or minimum size
        total_size = max(total_size, 10240)  # At least 10KB
        
        return total_size
    
    def get_installation_summary(self) -> Dict[str, Any]:
        """Get installation summary"""
        source_dir = self._get_source_dir()
        status = "placeholder" if not source_dir.exists() else "implemented"
        
        return {
            "component": self.get_metadata()["name"],
            "version": self.get_metadata()["version"],
            "status": status,
            "hook_files": self.hook_files if source_dir.exists() else ["PLACEHOLDER.py"],
            "estimated_size": self.get_size_estimate(),
            "install_directory": str(self.install_dir / "hooks"),
            "dependencies": self.get_dependencies()
        }