claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/core/container.py

@@ -0,0 +1,347 @@
+"""
+Lightweight Dependency Injection Container for Claude MPM.
+
+This module provides a simple yet powerful dependency injection container
+that supports:
+- Service registration with interfaces
+- Constructor injection
+- Singleton and transient lifetimes
+- Factory functions
+- Lazy initialization
+- Circular dependency detection
+"""
+
+import inspect
+import threading
+from abc import ABC
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Set, Type, TypeVar, Union
+
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+T = TypeVar('T')
+
+
+class ServiceLifetime(Enum):
+    """Service lifetime options."""
+    SINGLETON = "singleton"  # One instance per container
+    TRANSIENT = "transient"  # New instance per request
+    SCOPED = "scoped"       # One instance per scope (future enhancement)
+
+
+class ServiceRegistration:
+    """Represents a service registration in the container."""
+    
+    def __init__(
+        self,
+        service_type: Type,
+        implementation: Optional[Union[Type, Callable]] = None,
+        factory: Optional[Callable] = None,
+        instance: Optional[Any] = None,
+        lifetime: ServiceLifetime = ServiceLifetime.SINGLETON,
+        dependencies: Optional[Dict[str, Type]] = None
+    ):
+        """
+        Initialize service registration.
+        
+        Args:
+            service_type: The interface/base type being registered
+            implementation: The concrete implementation class
+            factory: Factory function to create instances
+            instance: Pre-created instance (for singleton registration)
+            lifetime: Service lifetime management
+            dependencies: Explicit dependency mapping
+        """
+        self.service_type = service_type
+        self.implementation = implementation or service_type
+        self.factory = factory
+        self.instance = instance
+        self.lifetime = lifetime
+        self.dependencies = dependencies or {}
+        self._lock = threading.Lock()
+        
+    def create_instance(self, container: 'DIContainer') -> Any:
+        """Create an instance of the service."""
+        if self.instance is not None:
+            return self.instance
+            
+        if self.factory:
+            return self.factory(container)
+            
+        # Get constructor parameters
+        if inspect.isclass(self.implementation):
+            return container.create_instance(self.implementation, self.dependencies)
+        else:
+            # It's already an instance or callable
+            return self.implementation
+
+
+class CircularDependencyError(Exception):
+    """Raised when circular dependencies are detected."""
+    pass
+
+
+class ServiceNotFoundError(Exception):
+    """Raised when a requested service is not registered."""
+    pass
+
+
+class DIContainer:
+    """
+    Lightweight Dependency Injection Container.
+    
+    Provides service registration, resolution, and lifecycle management.
+    """
+    
+    def __init__(self):
+        """Initialize the DI container."""
+        self._registrations: Dict[Type, ServiceRegistration] = {}
+        self._singletons: Dict[Type, Any] = {}
+        self._lock = threading.RLock()
+        self._resolving: Set[Type] = set()
+        
+    def register(
+        self,
+        service_type: Type[T],
+        implementation: Optional[Union[Type[T], Callable[..., T]]] = None,
+        lifetime: ServiceLifetime = ServiceLifetime.SINGLETON,
+        factory: Optional[Callable[['DIContainer'], T]] = None,
+        instance: Optional[T] = None,
+        dependencies: Optional[Dict[str, Type]] = None
+    ) -> None:
+        """
+        Register a service in the container.
+        
+        Args:
+            service_type: The interface/base type to register
+            implementation: The concrete implementation (class or factory)
+            lifetime: Service lifetime (singleton/transient)
+            factory: Optional factory function
+            instance: Pre-created instance (for singleton)
+            dependencies: Explicit dependency mapping for constructor params
+            
+        Examples:
+            # Register interface with implementation
+            container.register(ILogger, ConsoleLogger)
+            
+            # Register with factory
+            container.register(IDatabase, factory=lambda c: Database(c.resolve(IConfig)))
+            
+            # Register singleton instance
+            container.register(IConfig, instance=Config())
+            
+            # Register with explicit dependencies
+            container.register(IService, ServiceImpl, dependencies={'logger': ILogger})
+        """
+        with self._lock:
+            registration = ServiceRegistration(
+                service_type=service_type,
+                implementation=implementation,
+                factory=factory,
+                instance=instance,
+                lifetime=lifetime,
+                dependencies=dependencies
+            )
+            self._registrations[service_type] = registration
+            
+            # If instance provided, store as singleton
+            if instance is not None:
+                self._singletons[service_type] = instance
+                
+    def register_singleton(
+        self,
+        service_type: Type[T],
+        implementation: Optional[Union[Type[T], T]] = None
+    ) -> None:
+        """
+        Register a singleton service.
+        
+        Convenience method for registering singletons.
+        """
+        if implementation is not None and not inspect.isclass(implementation):
+            # It's an instance
+            self.register(service_type, instance=implementation)
+        else:
+            self.register(service_type, implementation, lifetime=ServiceLifetime.SINGLETON)
+            
+    def register_transient(
+        self,
+        service_type: Type[T],
+        implementation: Optional[Type[T]] = None
+    ) -> None:
+        """
+        Register a transient service.
+        
+        Convenience method for registering transient services.
+        """
+        self.register(service_type, implementation, lifetime=ServiceLifetime.TRANSIENT)
+        
+    def register_factory(
+        self,
+        service_type: Type[T],
+        factory: Callable[['DIContainer'], T],
+        lifetime: ServiceLifetime = ServiceLifetime.SINGLETON
+    ) -> None:
+        """
+        Register a service with a factory function.
+        
+        The factory receives the container as parameter for resolving dependencies.
+        """
+        self.register(service_type, factory=factory, lifetime=lifetime)
+        
+    def resolve(self, service_type: Type[T]) -> T:
+        """
+        Resolve a service from the container.
+        
+        Args:
+            service_type: The type to resolve
+            
+        Returns:
+            Instance of the requested service
+            
+        Raises:
+            ServiceNotFoundError: If service is not registered
+            CircularDependencyError: If circular dependencies detected
+        """
+        with self._lock:
+            # Check for circular dependencies
+            if service_type in self._resolving:
+                cycle = " -> ".join(str(t) for t in self._resolving) + f" -> {service_type}"
+                raise CircularDependencyError(f"Circular dependency detected: {cycle}")
+                
+            # Check if registered
+            if service_type not in self._registrations:
+                raise ServiceNotFoundError(f"Service {service_type} is not registered")
+                
+            registration = self._registrations[service_type]
+            
+            # Return existing singleton if available
+            if registration.lifetime == ServiceLifetime.SINGLETON:
+                if service_type in self._singletons:
+                    return self._singletons[service_type]
+                    
+            # Mark as resolving
+            self._resolving.add(service_type)
+            
+            try:
+                # Create instance
+                instance = registration.create_instance(self)
+                
+                # Store singleton
+                if registration.lifetime == ServiceLifetime.SINGLETON:
+                    self._singletons[service_type] = instance
+                    
+                return instance
+                
+            finally:
+                self._resolving.remove(service_type)
+                
+    def resolve_optional(self, service_type: Type[T], default: Optional[T] = None) -> Optional[T]:
+        """
+        Resolve a service if registered, otherwise return default.
+        
+        Useful for optional dependencies.
+        """
+        try:
+            return self.resolve(service_type)
+        except ServiceNotFoundError:
+            return default
+            
+    def create_instance(self, cls: Type[T], explicit_deps: Optional[Dict[str, Type]] = None) -> T:
+        """
+        Create an instance of a class, resolving constructor dependencies.
+        
+        Args:
+            cls: The class to instantiate
+            explicit_deps: Explicit dependency mapping for constructor params
+            
+        Returns:
+            New instance with resolved dependencies
+        """
+        # Get constructor signature
+        sig = inspect.signature(cls.__init__)
+        kwargs = {}
+        
+        for param_name, param in sig.parameters.items():
+            if param_name == 'self':
+                continue
+                
+            # Check explicit dependencies first
+            if explicit_deps and param_name in explicit_deps:
+                dep_type = explicit_deps[param_name]
+                kwargs[param_name] = self.resolve(dep_type)
+                continue
+                
+            # Try to resolve by type annotation
+            if param.annotation != param.empty:
+                param_type = param.annotation
+                
+                # Handle Optional types
+                if hasattr(param_type, '__origin__') and param_type.__origin__ is Union:
+                    # Get the non-None type from Optional
+                    args = param_type.__args__
+                    param_type = next((arg for arg in args if arg is not type(None)), None)
+                    
+                if param_type and param_type in self._registrations:
+                    kwargs[param_name] = self.resolve(param_type)
+                elif param.default != param.empty:
+                    # Use default value
+                    kwargs[param_name] = param.default
+                    
+        return cls(**kwargs)
+        
+    def is_registered(self, service_type: Type) -> bool:
+        """Check if a service type is registered."""
+        return service_type in self._registrations
+        
+    def get_all_registrations(self) -> Dict[Type, ServiceRegistration]:
+        """Get all service registrations."""
+        with self._lock:
+            return self._registrations.copy()
+            
+    def create_child_container(self) -> 'DIContainer':
+        """
+        Create a child container that inherits registrations.
+        
+        Useful for scoped scenarios.
+        """
+        child = DIContainer()
+        with self._lock:
+            # Copy registrations but not singleton instances
+            for service_type, registration in self._registrations.items():
+                child._registrations[service_type] = registration
+        return child
+        
+    def clear(self) -> None:
+        """Clear all registrations and instances."""
+        with self._lock:
+            self._registrations.clear()
+            self._singletons.clear()
+            self._resolving.clear()
+
+
+# Global container instance (optional, for convenience)
+_global_container: Optional[DIContainer] = None
+_global_lock = threading.Lock()
+
+
+def get_container() -> DIContainer:
+    """
+    Get the global DI container instance.
+    
+    Creates one if it doesn't exist.
+    """
+    global _global_container
+    with _global_lock:
+        if _global_container is None:
+            _global_container = DIContainer()
+        return _global_container
+
+
+def set_container(container: DIContainer) -> None:
+    """Set the global DI container instance."""
+    global _global_container
+    with _global_lock:
+        _global_container = container

claude_mpm/core/factories.py

@@ -0,0 +1,281 @@
+"""
+Factory classes for creating complex dependencies in Claude MPM.
+
+Provides factory patterns for services that require complex initialization
+or have multiple configuration options.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, Optional, Type, TypeVar
+
+from .container import DIContainer
+from .logger import get_logger
+from .config import Config
+from ..services.json_rpc_hook_manager import JSONRPCHookManager
+from ..services.agent_deployment import AgentDeploymentService
+from ..orchestration.factory import OrchestratorFactory
+from ..orchestration.base import BaseOrchestrator
+
+logger = get_logger(__name__)
+
+T = TypeVar('T')
+
+
+class ServiceFactory(ABC):
+    """Base factory for creating services."""
+    
+    @abstractmethod
+    def create(self, container: DIContainer, **kwargs) -> Any:
+        """Create a service instance."""
+        pass
+
+
+class HookManagerFactory(ServiceFactory):
+    """Factory for creating hook manager instances."""
+    
+    def create(
+        self,
+        container: DIContainer,
+        log_dir: Optional[Path] = None,
+        enabled: bool = True
+    ) -> Optional[JSONRPCHookManager]:
+        """
+        Create a hook manager instance.
+        
+        Args:
+            container: DI container
+            log_dir: Log directory path
+            enabled: Whether hooks are enabled
+            
+        Returns:
+            Hook manager instance or None if disabled
+        """
+        config = container.resolve(Config)
+        
+        # Check if hooks are enabled
+        if not enabled or config.get('hooks.enabled', True) is False:
+            logger.info("Hooks are disabled")
+            return None
+            
+        # Get log directory from config if not provided
+        if log_dir is None:
+            log_dir = Path(config.get('log_dir', '.claude-mpm/logs'))
+            
+        # Create hook manager
+        hook_manager = JSONRPCHookManager(log_dir=log_dir)
+        
+        # Start the service
+        if hook_manager.start_service():
+            logger.info("Hook manager initialized successfully")
+            return hook_manager
+        else:
+            logger.warning("Failed to start hook manager")
+            return None
+
+
+class OrchestratorFactoryWrapper(ServiceFactory):
+    """Factory wrapper for creating orchestrator instances."""
+    
+    def __init__(self):
+        """Initialize the factory wrapper."""
+        self._factory = OrchestratorFactory()
+        
+    def create(
+        self,
+        container: DIContainer,
+        orchestrator_type: Optional[str] = None,
+        **kwargs
+    ) -> BaseOrchestrator:
+        """
+        Create an orchestrator instance.
+        
+        Args:
+            container: DI container
+            orchestrator_type: Type of orchestrator to create
+            **kwargs: Additional arguments for orchestrator
+            
+        Returns:
+            Orchestrator instance
+        """
+        config = container.resolve(Config)
+        
+        # Get orchestrator type from config if not provided
+        if orchestrator_type is None:
+            orchestrator_type = config.get('orchestrator.type', 'subprocess')
+            
+        # Get orchestrator config
+        orch_config = config.get(f'orchestrator.{orchestrator_type}', {})
+        
+        # Merge with provided kwargs
+        orch_config.update(kwargs)
+        
+        # Inject services into orchestrator config
+        if 'hook_manager' not in orch_config and container.is_registered(JSONRPCHookManager):
+            orch_config['hook_manager'] = container.resolve_optional(JSONRPCHookManager)
+            
+        # Create orchestrator
+        orchestrator = self._factory.create_orchestrator(
+            orchestrator_type,
+            **orch_config
+        )
+        
+        logger.info(f"Created {orchestrator_type} orchestrator")
+        return orchestrator
+
+
+class AgentServiceFactory(ServiceFactory):
+    """Factory for creating agent-related services."""
+    
+    def create(
+        self,
+        container: DIContainer,
+        framework_dir: Optional[Path] = None,
+        project_dir: Optional[Path] = None
+    ) -> AgentDeploymentService:
+        """
+        Create an agent deployment service.
+        
+        Args:
+            container: DI container
+            framework_dir: Framework directory path
+            project_dir: Project directory path
+            
+        Returns:
+            Agent deployment service instance
+        """
+        config = container.resolve(Config)
+        
+        # Get directories from config if not provided
+        if framework_dir is None:
+            framework_dir = Path(config.get('framework.dir', 'framework'))
+            
+        if project_dir is None:
+            project_dir = Path(config.get('project.dir', '.'))
+            
+        # Create service with dependencies
+        service = AgentDeploymentService()
+        
+        # Inject any required dependencies
+        if hasattr(service, 'set_directories'):
+            service.set_directories(framework_dir, project_dir)
+            
+        logger.info("Created agent deployment service")
+        return service
+
+
+class SessionManagerFactory(ServiceFactory):
+    """Factory for creating session managers."""
+    
+    def create(
+        self,
+        container: DIContainer,
+        session_type: str = "standard",
+        **kwargs
+    ) -> Any:
+        """
+        Create a session manager instance.
+        
+        Args:
+            container: DI container
+            session_type: Type of session manager
+            **kwargs: Additional configuration
+            
+        Returns:
+            Session manager instance
+        """
+        config = container.resolve(Config)
+        
+        if session_type == "agent":
+            from ..core.agent_session_manager import AgentSessionManager
+            
+            session_dir = kwargs.get('session_dir') or Path(config.get('session.dir', '.claude-mpm/sessions'))
+            max_sessions = kwargs.get('max_sessions_per_agent', config.get('session.max_per_agent', 3))
+            
+            return AgentSessionManager(
+                session_dir=session_dir,
+                max_sessions_per_agent=max_sessions
+            )
+        else:
+            from ..core.session_manager import SessionManager
+            
+            session_dir = kwargs.get('session_dir') or Path(config.get('session.dir', '.claude-mpm/sessions'))
+            
+            return SessionManager(session_dir=session_dir)
+
+
+class ConfigurationFactory(ServiceFactory):
+    """Factory for creating configuration instances."""
+    
+    def create(
+        self,
+        container: DIContainer,
+        config_data: Optional[Dict[str, Any]] = None,
+        config_path: Optional[Path] = None,
+        env_prefix: str = "CLAUDE_MPM"
+    ) -> Config:
+        """
+        Create a configuration instance.
+        
+        Args:
+            container: DI container
+            config_data: Initial configuration data
+            config_path: Path to configuration file
+            env_prefix: Environment variable prefix
+            
+        Returns:
+            Configuration instance
+        """
+        # Load from multiple sources
+        config = Config(config_data or {}, config_path)
+        
+        # Load environment variables
+        import os
+        for key, value in os.environ.items():
+            if key.startswith(env_prefix):
+                # Convert CLAUDE_MPM_FOO_BAR to foo.bar
+                config_key = key[len(env_prefix)+1:].lower().replace('_', '.')
+                config.set(config_key, value)
+                
+        logger.info("Created configuration instance")
+        return config
+
+
+# Factory registry for easy access
+class FactoryRegistry:
+    """Registry for all service factories."""
+    
+    def __init__(self):
+        """Initialize factory registry."""
+        self._factories: Dict[str, ServiceFactory] = {
+            'hook_manager': HookManagerFactory(),
+            'orchestrator': OrchestratorFactoryWrapper(),
+            'agent_service': AgentServiceFactory(),
+            'session_manager': SessionManagerFactory(),
+            'configuration': ConfigurationFactory(),
+        }
+        
+    def get_factory(self, name: str) -> ServiceFactory:
+        """Get a factory by name."""
+        if name not in self._factories:
+            raise KeyError(f"Factory '{name}' not registered")
+        return self._factories[name]
+        
+    def register_factory(self, name: str, factory: ServiceFactory) -> None:
+        """Register a new factory."""
+        self._factories[name] = factory
+        logger.debug(f"Registered factory: {name}")
+        
+    def create(self, factory_name: str, container: DIContainer, **kwargs) -> Any:
+        """Create a service using a named factory."""
+        factory = self.get_factory(factory_name)
+        return factory.create(container, **kwargs)
+
+
+# Global factory registry
+_factory_registry = FactoryRegistry()
+
+
+def get_factory_registry() -> FactoryRegistry:
+    """Get the global factory registry."""
+    return _factory_registry