SuperClaude/setup/core/registry.py

"""
Component registry for auto-discovery and dependency resolution
"""

import importlib
import inspect
from typing import Dict, List, Set, Optional, Type
from pathlib import Path
from .base import Component
from ..utils.logger import get_logger


class ComponentRegistry:
    """Auto-discovery and management of installable components"""
    
    def __init__(self, components_dir: Path):
        """
        Initialize component registry
        
        Args:
            components_dir: Directory containing component modules
        """
        self.components_dir = components_dir
        self.component_classes: Dict[str, Type[Component]] = {}
        self.component_instances: Dict[str, Component] = {}
        self.dependency_graph: Dict[str, Set[str]] = {}
        self._discovered = False
        self.logger = get_logger()
    
    def discover_components(self, force_reload: bool = False) -> None:
        """
        Auto-discover all component classes in components directory
        
        Args:
            force_reload: Force rediscovery even if already done
        """
        if self._discovered and not force_reload:
            return
        
        self.component_classes.clear()
        self.component_instances.clear()
        self.dependency_graph.clear()
        
        if not self.components_dir.exists():
            return
        
        # Add components directory to Python path temporarily
        import sys
        original_path = sys.path.copy()
        
        try:
            # Add parent directory to path so we can import setup.components
            setup_dir = self.components_dir.parent
            if str(setup_dir) not in sys.path:
                sys.path.insert(0, str(setup_dir))
            
            # Discover all Python files in components directory
            for py_file in self.components_dir.glob("*.py"):
                if py_file.name.startswith("__"):
                    continue
                
                module_name = py_file.stem
                self._load_component_module(module_name)
        
        finally:
            # Restore original Python path
            sys.path = original_path
        
        # Build dependency graph
        self._build_dependency_graph()
        self._discovered = True
    
    def _load_component_module(self, module_name: str) -> None:
        """
        Load component classes from a module
        
        Args:
            module_name: Name of module to load
        """
        try:
            # Import the module
            full_module_name = f"setup.components.{module_name}"
            module = importlib.import_module(full_module_name)
            
            # Find all Component subclasses in the module
            for name, obj in inspect.getmembers(module):
                if (inspect.isclass(obj) and 
                    issubclass(obj, Component) and 
                    obj is not Component):
                    
                    # Create instance to get metadata
                    try:
                        instance = obj()
                        metadata = instance.get_metadata()
                        component_name = metadata["name"]
                        
                        self.component_classes[component_name] = obj
                        self.component_instances[component_name] = instance
                        
                    except Exception as e:
                        self.logger.warning(f"Could not instantiate component {name}: {e}")
        
        except Exception as e:
            self.logger.warning(f"Could not load component module {module_name}: {e}")
    
    def _build_dependency_graph(self) -> None:
        """Build dependency graph for all discovered components"""
        for name, instance in self.component_instances.items():
            try:
                dependencies = instance.get_dependencies()
                self.dependency_graph[name] = set(dependencies)
            except Exception as e:
                self.logger.warning(f"Could not get dependencies for {name}: {e}")
                self.dependency_graph[name] = set()
    
    def get_component_class(self, component_name: str) -> Optional[Type[Component]]:
        """
        Get component class by name
        
        Args:
            component_name: Name of component
            
        Returns:
            Component class or None if not found
        """
        self.discover_components()
        return self.component_classes.get(component_name)
    
    def get_component_instance(self, component_name: str, install_dir: Optional[Path] = None) -> Optional[Component]:
        """
        Get component instance by name
        
        Args:
            component_name: Name of component
            install_dir: Installation directory (creates new instance with this dir)
            
        Returns:
            Component instance or None if not found
        """
        self.discover_components()
        
        if install_dir is not None:
            # Create new instance with specified install directory
            component_class = self.component_classes.get(component_name)
            if component_class:
                try:
                    return component_class(install_dir)
                except Exception as e:
                    self.logger.error(f"Error creating component instance {component_name}: {e}")
                    return None
        
        return self.component_instances.get(component_name)
    
    def list_components(self) -> List[str]:
        """
        Get list of all discovered component names
        
        Returns:
            List of component names
        """
        self.discover_components()
        return list(self.component_classes.keys())
    
    def get_component_metadata(self, component_name: str) -> Optional[Dict[str, str]]:
        """
        Get metadata for a component
        
        Args:
            component_name: Name of component
            
        Returns:
            Component metadata dict or None if not found
        """
        self.discover_components()
        instance = self.component_instances.get(component_name)
        if instance:
            try:
                return instance.get_metadata()
            except Exception:
                return None
        return None
    
    def resolve_dependencies(self, component_names: List[str]) -> List[str]:
        """
        Resolve component dependencies in correct installation order
        
        Args:
            component_names: List of component names to install
            
        Returns:
            Ordered list of component names including dependencies
            
        Raises:
            ValueError: If circular dependencies detected or unknown component
        """
        self.discover_components()
        
        resolved = []
        resolving = set()
        
        def resolve(name: str):
            if name in resolved:
                return
                
            if name in resolving:
                raise ValueError(f"Circular dependency detected involving {name}")
                
            if name not in self.dependency_graph:
                raise ValueError(f"Unknown component: {name}")
                
            resolving.add(name)
            
            # Resolve dependencies first
            for dep in self.dependency_graph[name]:
                resolve(dep)
                
            resolving.remove(name)
            resolved.append(name)
        
        # Resolve each requested component
        for name in component_names:
            resolve(name)
            
        return resolved
    
    def get_dependencies(self, component_name: str) -> Set[str]:
        """
        Get direct dependencies for a component
        
        Args:
            component_name: Name of component
            
        Returns:
            Set of dependency component names
        """
        self.discover_components()
        return self.dependency_graph.get(component_name, set())
    
    def get_dependents(self, component_name: str) -> Set[str]:
        """
        Get components that depend on the given component
        
        Args:
            component_name: Name of component
            
        Returns:
            Set of component names that depend on this component
        """
        self.discover_components()
        dependents = set()
        
        for name, deps in self.dependency_graph.items():
            if component_name in deps:
                dependents.add(name)
                
        return dependents
    
    def validate_dependency_graph(self) -> List[str]:
        """
        Validate dependency graph for cycles and missing dependencies
        
        Returns:
            List of validation errors (empty if valid)
        """
        self.discover_components()
        errors = []
        
        # Check for missing dependencies
        all_components = set(self.dependency_graph.keys())
        for name, deps in self.dependency_graph.items():
            missing_deps = deps - all_components
            if missing_deps:
                errors.append(f"Component {name} has missing dependencies: {missing_deps}")
        
        # Check for circular dependencies
        for name in all_components:
            try:
                self.resolve_dependencies([name])
            except ValueError as e:
                errors.append(str(e))
        
        return errors
    
    def get_components_by_category(self, category: str) -> List[str]:
        """
        Get components filtered by category
        
        Args:
            category: Component category to filter by
            
        Returns:
            List of component names in the category
        """
        self.discover_components()
        components = []
        
        for name, instance in self.component_instances.items():
            try:
                metadata = instance.get_metadata()
                if metadata.get("category") == category:
                    components.append(name)
            except Exception:
                continue
        
        return components
    
    def get_installation_order(self, component_names: List[str]) -> List[List[str]]:
        """
        Get installation order grouped by dependency levels
        
        Args:
            component_names: List of component names to install
            
        Returns:
            List of lists, where each inner list contains components
            that can be installed in parallel at that dependency level
        """
        self.discover_components()
        
        # Get all components including dependencies
        all_components = set(self.resolve_dependencies(component_names))
        
        # Group by dependency level
        levels = []
        remaining = all_components.copy()
        
        while remaining:
            # Find components with no unresolved dependencies
            current_level = []
            for name in list(remaining):
                deps = self.dependency_graph.get(name, set())
                unresolved_deps = deps & remaining
                
                if not unresolved_deps:
                    current_level.append(name)
            
            if not current_level:
                # This shouldn't happen if dependency graph is valid
                raise ValueError("Circular dependency detected in installation order calculation")
            
            levels.append(current_level)
            remaining -= set(current_level)
        
        return levels
    
    def create_component_instances(self, component_names: List[str], install_dir: Optional[Path] = None) -> Dict[str, Component]:
        """
        Create instances for multiple components
        
        Args:
            component_names: List of component names
            install_dir: Installation directory for instances
            
        Returns:
            Dict mapping component names to instances
        """
        self.discover_components()
        instances = {}
        
        for name in component_names:
            instance = self.get_component_instance(name, install_dir)
            if instance:
                instances[name] = instance
            else:
                self.logger.warning(f"Could not create instance for component {name}")
        
        return instances
    
    def get_registry_info(self) -> Dict[str, any]:
        """
        Get comprehensive registry information
        
        Returns:
            Dict with registry statistics and component info
        """
        self.discover_components()
        
        # Group components by category
        categories = {}
        for name, instance in self.component_instances.items():
            try:
                metadata = instance.get_metadata()
                category = metadata.get("category", "unknown")
                if category not in categories:
                    categories[category] = []
                categories[category].append(name)
            except Exception:
                if "unknown" not in categories:
                    categories["unknown"] = []
                categories["unknown"].append(name)
        
        return {
            "total_components": len(self.component_classes),
            "categories": categories,
            "dependency_graph": {name: list(deps) for name, deps in self.dependency_graph.items()},
            "validation_errors": self.validate_dependency_graph()
        }