claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/core/mixins.py

@@ -0,0 +1,150 @@
+"""Core mixins for Claude MPM.
+
+This module provides reusable mixins that add common functionality
+to classes throughout the framework.
+"""
+
+import logging
+from typing import Optional
+
+
+class LoggerMixin:
+    """Mixin that provides automatic logger initialization.
+    
+    This mixin eliminates duplicate logger initialization code by automatically
+    creating a logger instance based on the class name or a custom name.
+    
+    Usage:
+        class MyService(LoggerMixin):
+            def __init__(self):
+                # Logger is automatically available as self.logger
+                self.logger.info("Service initialized")
+                
+        class CustomLogger(LoggerMixin):
+            def __init__(self):
+                # Use custom logger name
+                self._logger_name = "my.custom.logger"
+                self.logger.info("Using custom logger")
+                
+    The logger is lazily initialized on first access, using either:
+    1. A custom name set via self._logger_name
+    2. The module and class name (e.g., 'claude_mpm.services.MyService')
+    3. The module name if class name is not available
+    
+    Attributes:
+        logger: The logging.Logger instance for this class
+        _logger_name: Optional custom logger name to use instead of class name
+        _logger_instance: Cached logger instance (internal use)
+    """
+    
+    _logger_instance: Optional[logging.Logger] = None
+    _logger_name: Optional[str] = None
+    
+    @property
+    def logger(self) -> logging.Logger:
+        """Get or create the logger instance.
+        
+        Returns:
+            logging.Logger: The logger instance for this class
+            
+        Examples:
+            >>> class MyService(LoggerMixin):
+            ...     def process(self):
+            ...         self.logger.info("Processing...")
+            >>> 
+            >>> service = MyService()
+            >>> service.process()  # Logs with 'claude_mpm.module.MyService'
+            
+            >>> class CustomService(LoggerMixin):
+            ...     def __init__(self):
+            ...         self._logger_name = "custom.service"
+            ...         self.logger.debug("Initialized")
+            >>> 
+            >>> custom = CustomService()  # Logs with 'custom.service'
+        """
+        if self._logger_instance is None:
+            if self._logger_name:
+                # Use custom logger name if provided
+                logger_name = self._logger_name
+            else:
+                # Build logger name from module and class
+                module = self.__class__.__module__
+                class_name = self.__class__.__name__
+                
+                if module and module != "__main__":
+                    logger_name = f"{module}.{class_name}"
+                else:
+                    # Fallback to just class name if no proper module
+                    logger_name = class_name
+                    
+            self._logger_instance = logging.getLogger(logger_name)
+            
+        return self._logger_instance
+    
+    def set_logger(self, logger: Optional[logging.Logger] = None, 
+                   name: Optional[str] = None) -> None:
+        """Set a custom logger instance or name.
+        
+        This method allows overriding the automatic logger creation with either
+        a pre-configured logger instance or a custom logger name.
+        
+        Args:
+            logger: A pre-configured Logger instance to use
+            name: A custom name for creating a new logger
+            
+        Raises:
+            ValueError: If both logger and name are provided
+            
+        Examples:
+            >>> service = MyService()
+            >>> service.set_logger(name="my.custom.logger")
+            >>> service.logger.info("Using custom logger")
+            
+            >>> import logging
+            >>> custom_logger = logging.getLogger("preconfigured")
+            >>> service.set_logger(logger=custom_logger)
+        """
+        if logger and name:
+            raise ValueError("Cannot specify both logger instance and name")
+            
+        if logger:
+            self._logger_instance = logger
+            self._logger_name = logger.name
+        elif name:
+            self._logger_name = name
+            self._logger_instance = None  # Reset to force recreation
+        else:
+            # Reset to defaults
+            self._logger_name = None
+            self._logger_instance = None
+
+
+# Example usage patterns for reference
+if __name__ == "__main__":
+    # Example 1: Basic usage with automatic logger naming
+    class ExampleService(LoggerMixin):
+        def do_work(self):
+            self.logger.info("Doing work...")
+            self.logger.debug("Debug details")
+            
+    # Example 2: Custom logger name
+    class CustomService(LoggerMixin):
+        def __init__(self):
+            self._logger_name = "custom.service"
+            self.logger.info("Service initialized with custom logger")
+            
+    # Example 3: Setting logger after initialization
+    class ConfigurableService(LoggerMixin):
+        def configure(self, logger_name: str):
+            self.set_logger(name=logger_name)
+            self.logger.info(f"Reconfigured with logger: {logger_name}")
+            
+    # Example 4: Multiple inheritance friendly
+    class BaseService:
+        def __init__(self, config=None):
+            self.config = config
+            
+    class AdvancedService(BaseService, LoggerMixin):
+        def __init__(self, config=None):
+            super().__init__(config)
+            self.logger.info("Advanced service ready")

claude_mpm/core/service_registry.py

@@ -0,0 +1,299 @@
+"""
+Service Registry for Claude MPM.
+
+Provides centralized service registration and discovery, working with
+the DI container to manage application services.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type, Union
+
+from .container import DIContainer, ServiceLifetime, get_container
+from .base_service import BaseService
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ServiceRegistry:
+    """
+    Central registry for all application services.
+    
+    Manages service registration, configuration, and lifecycle.
+    """
+    
+    def __init__(self, container: Optional[DIContainer] = None):
+        """
+        Initialize service registry.
+        
+        Args:
+            container: DI container to use (uses global if not provided)
+        """
+        self.container = container or get_container()
+        self._services: Dict[str, Type[BaseService]] = {}
+        self._initialized = False
+        
+    def register_core_services(self) -> None:
+        """Register all core framework services."""
+        from ..services.shared_prompt_cache import SharedPromptCache
+        from ..services.json_rpc_hook_manager import JSONRPCHookManager
+        from ..services.ticket_manager import TicketManager
+        from ..services.agent_deployment import AgentDeploymentService
+        from .session_manager import SessionManager
+        from .agent_session_manager import AgentSessionManager
+        from .config import Config
+        
+        # Register configuration as singleton
+        config = Config()
+        self.container.register_singleton(Config, instance=config)
+        
+        # Register core services
+        self.register_service(
+            "session_manager",
+            SessionManager,
+            lifetime=ServiceLifetime.SINGLETON
+        )
+        
+        self.register_service(
+            "agent_session_manager",
+            AgentSessionManager,
+            lifetime=ServiceLifetime.SINGLETON,
+            dependencies={
+                'session_dir': lambda c: c.resolve(Config).get('session_dir')
+            }
+        )
+        
+        # Register shared cache as singleton (it's already a singleton internally)
+        self.register_service(
+            "prompt_cache",
+            SharedPromptCache,
+            lifetime=ServiceLifetime.SINGLETON,
+            factory=lambda c: SharedPromptCache.get_instance()
+        )
+        
+        # Register hook manager
+        self.register_service(
+            "hook_manager",
+            JSONRPCHookManager,
+            lifetime=ServiceLifetime.SINGLETON
+        )
+        
+        # Register ticket manager
+        self.register_service(
+            "ticket_manager",
+            TicketManager,
+            lifetime=ServiceLifetime.TRANSIENT
+        )
+        
+        # Register agent deployment service
+        self.register_service(
+            "agent_deployment",
+            AgentDeploymentService,
+            lifetime=ServiceLifetime.TRANSIENT
+        )
+        
+        logger.info("Core services registered")
+        
+    def register_service(
+        self,
+        name: str,
+        service_class: Type[BaseService],
+        lifetime: ServiceLifetime = ServiceLifetime.SINGLETON,
+        factory: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
+        config: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Register a service with the registry.
+        
+        Args:
+            name: Service name for lookup
+            service_class: Service class (must inherit from BaseService)
+            lifetime: Service lifetime management
+            factory: Optional factory function
+            dependencies: Optional dependency mapping
+            config: Optional service-specific configuration
+        """
+        # Store service metadata
+        self._services[name] = service_class
+        
+        # Create factory wrapper if config provided
+        if config and not factory:
+            factory = lambda c: service_class(name=name, config=config, container=c)
+        elif not factory:
+            # Default factory with container injection
+            factory = lambda c: service_class(name=name, container=c)
+            
+        # Register with DI container
+        self.container.register(
+            service_class,
+            factory=factory,
+            lifetime=lifetime,
+            dependencies=dependencies
+        )
+        
+        logger.debug(f"Registered service: {name} ({service_class.__name__})")
+        
+    def get_service(self, service_type: Union[str, Type[BaseService]]) -> BaseService:
+        """
+        Get a service instance.
+        
+        Args:
+            service_type: Service name or class
+            
+        Returns:
+            Service instance
+        """
+        if isinstance(service_type, str):
+            # Look up by name
+            if service_type not in self._services:
+                raise KeyError(f"Service '{service_type}' not registered")
+            service_class = self._services[service_type]
+        else:
+            service_class = service_type
+            
+        return self.container.resolve(service_class)
+        
+    def get_service_optional(
+        self,
+        service_type: Union[str, Type[BaseService]],
+        default: Optional[BaseService] = None
+    ) -> Optional[BaseService]:
+        """Get a service if available, otherwise return default."""
+        try:
+            return self.get_service(service_type)
+        except (KeyError, Exception):
+            return default
+            
+    def start_all_services(self) -> None:
+        """Start all registered singleton services."""
+        import asyncio
+        
+        async def _start_all():
+            for name, service_class in self._services.items():
+                try:
+                    # Only start singleton services
+                    registration = self.container.get_all_registrations().get(service_class)
+                    if registration and registration.lifetime == ServiceLifetime.SINGLETON:
+                        service = self.get_service(service_class)
+                        if hasattr(service, 'start'):
+                            await service.start()
+                            logger.info(f"Started service: {name}")
+                except Exception as e:
+                    logger.error(f"Failed to start service {name}: {e}")
+                    
+        asyncio.run(_start_all())
+        self._initialized = True
+        
+    def stop_all_services(self) -> None:
+        """Stop all running singleton services."""
+        import asyncio
+        
+        async def _stop_all():
+            for name, service_class in reversed(list(self._services.items())):
+                try:
+                    # Only stop singleton services
+                    registration = self.container.get_all_registrations().get(service_class)
+                    if registration and registration.lifetime == ServiceLifetime.SINGLETON:
+                        if service_class in self.container._singletons:
+                            service = self.container._singletons[service_class]
+                            if hasattr(service, 'stop') and service.running:
+                                await service.stop()
+                                logger.info(f"Stopped service: {name}")
+                except Exception as e:
+                    logger.error(f"Failed to stop service {name}: {e}")
+                    
+        asyncio.run(_stop_all())
+        
+    def get_service_health(self) -> Dict[str, Dict[str, Any]]:
+        """Get health status of all services."""
+        import asyncio
+        
+        async def _get_health():
+            health_status = {}
+            
+            for name, service_class in self._services.items():
+                try:
+                    if service_class in self.container._singletons:
+                        service = self.container._singletons[service_class]
+                        if hasattr(service, 'health_check'):
+                            health = await service.health_check()
+                            health_status[name] = {
+                                'status': health.status,
+                                'message': health.message,
+                                'metrics': health.metrics
+                            }
+                except Exception as e:
+                    health_status[name] = {
+                        'status': 'error',
+                        'message': str(e)
+                    }
+                    
+            return health_status
+            
+        return asyncio.run(_get_health())
+        
+    def list_services(self) -> List[Dict[str, Any]]:
+        """List all registered services with their metadata."""
+        services = []
+        
+        for name, service_class in self._services.items():
+            registration = self.container.get_all_registrations().get(service_class)
+            
+            service_info = {
+                'name': name,
+                'class': service_class.__name__,
+                'module': service_class.__module__,
+                'lifetime': registration.lifetime.value if registration else 'unknown',
+                'is_singleton': registration.lifetime == ServiceLifetime.SINGLETON if registration else False,
+                'is_running': False
+            }
+            
+            # Check if singleton is running
+            if service_class in self.container._singletons:
+                service = self.container._singletons[service_class]
+                if hasattr(service, 'running'):
+                    service_info['is_running'] = service.running
+                    
+            services.append(service_info)
+            
+        return services
+
+
+# Global registry instance
+_global_registry: Optional[ServiceRegistry] = None
+
+
+def get_service_registry() -> ServiceRegistry:
+    """Get the global service registry instance."""
+    global _global_registry
+    if _global_registry is None:
+        _global_registry = ServiceRegistry()
+        _global_registry.register_core_services()
+    return _global_registry
+
+
+def initialize_services(config: Optional[Dict[str, Any]] = None) -> ServiceRegistry:
+    """
+    Initialize all application services.
+    
+    Args:
+        config: Optional configuration overrides
+        
+    Returns:
+        Initialized service registry
+    """
+    registry = get_service_registry()
+    
+    if config:
+        # Apply configuration overrides
+        config_service = registry.container.resolve(Config)
+        for key, value in config.items():
+            config_service.set(key, value)
+            
+    # Start all services
+    if not registry._initialized:
+        registry.start_all_services()
+        
+    return registry

claude_mpm/core/session_manager.py

@@ -0,0 +1,190 @@
+"""Session ID management for Claude subprocess optimization."""
+
+import uuid
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+import json
+from pathlib import Path
+
+from ..core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class SessionManager:
+    """Manages session IDs for Claude subprocess reuse."""
+    
+    def __init__(self, session_dir: Optional[Path] = None):
+        """Initialize session manager.
+        
+        Args:
+            session_dir: Directory to store session metadata
+        """
+        self.session_dir = session_dir or Path.home() / ".claude-mpm" / "sessions"
+        self.session_dir.mkdir(parents=True, exist_ok=True)
+        self.active_sessions: Dict[str, Dict[str, Any]] = {}
+        self._load_sessions()
+    
+    def create_session(self, context: str = "default") -> str:
+        """Create a new session ID.
+        
+        Args:
+            context: Context identifier (e.g., "pm_orchestration", "agent_delegation")
+            
+        Returns:
+            UUID session ID
+        """
+        session_id = str(uuid.uuid4())
+        
+        self.active_sessions[session_id] = {
+            "id": session_id,
+            "context": context,
+            "created_at": datetime.now().isoformat(),
+            "last_used": datetime.now().isoformat(),
+            "use_count": 0,
+            "agents_run": []
+        }
+        
+        self._save_sessions()
+        logger.info(f"Created session {session_id} for context: {context}")
+        
+        return session_id
+    
+    def get_or_create_session(self, context: str = "default", max_age_minutes: int = 30) -> str:
+        """Get existing session or create new one.
+        
+        Args:
+            context: Context identifier
+            max_age_minutes: Maximum age of session to reuse
+            
+        Returns:
+            Session ID
+        """
+        # Look for existing session in context
+        now = datetime.now()
+        max_age = timedelta(minutes=max_age_minutes)
+        
+        for session_id, session_data in self.active_sessions.items():
+            if session_data["context"] == context:
+                last_used = datetime.fromisoformat(session_data["last_used"])
+                if now - last_used < max_age:
+                    # Reuse this session
+                    session_data["last_used"] = now.isoformat()
+                    session_data["use_count"] += 1
+                    self._save_sessions()
+                    logger.info(f"Reusing session {session_id} for context: {context}")
+                    return session_id
+        
+        # No valid session found, create new one
+        return self.create_session(context)
+    
+    def record_agent_use(self, session_id: str, agent: str, task: str):
+        """Record that an agent used this session.
+        
+        Args:
+            session_id: Session ID
+            agent: Agent name
+            task: Task description
+        """
+        if session_id in self.active_sessions:
+            self.active_sessions[session_id]["agents_run"].append({
+                "agent": agent,
+                "task": task[:100],  # Truncate long tasks
+                "timestamp": datetime.now().isoformat()
+            })
+            self.active_sessions[session_id]["last_used"] = datetime.now().isoformat()
+            self._save_sessions()
+    
+    def cleanup_old_sessions(self, max_age_hours: int = 24):
+        """Remove sessions older than max_age_hours.
+        
+        Args:
+            max_age_hours: Maximum age in hours
+        """
+        now = datetime.now()
+        max_age = timedelta(hours=max_age_hours)
+        
+        expired = []
+        for session_id, session_data in self.active_sessions.items():
+            created = datetime.fromisoformat(session_data["created_at"])
+            if now - created > max_age:
+                expired.append(session_id)
+        
+        for session_id in expired:
+            del self.active_sessions[session_id]
+            logger.info(f"Cleaned up expired session: {session_id}")
+        
+        if expired:
+            self._save_sessions()
+    
+    def _save_sessions(self):
+        """Save sessions to disk."""
+        session_file = self.session_dir / "active_sessions.json"
+        try:
+            with open(session_file, 'w') as f:
+                json.dump(self.active_sessions, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save sessions: {e}")
+    
+    def _load_sessions(self):
+        """Load sessions from disk."""
+        session_file = self.session_dir / "active_sessions.json"
+        if session_file.exists():
+            try:
+                with open(session_file, 'r') as f:
+                    self.active_sessions = json.load(f)
+                    
+                # Clean up old sessions on load
+                self.cleanup_old_sessions()
+            except Exception as e:
+                logger.error(f"Failed to load sessions: {e}")
+                self.active_sessions = {}
+
+
+class OrchestrationSession:
+    """Context manager for orchestration sessions."""
+    
+    def __init__(self, session_manager: SessionManager, context: str = "orchestration"):
+        """Initialize orchestration session.
+        
+        Args:
+            session_manager: SessionManager instance
+            context: Session context
+        """
+        self.session_manager = session_manager
+        self.context = context
+        self.session_id: Optional[str] = None
+    
+    def __enter__(self) -> str:
+        """Enter session context, return session ID."""
+        self.session_id = self.session_manager.get_or_create_session(self.context)
+        return self.session_id
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit session context."""
+        # Could add cleanup here if needed
+        pass
+
+
+# Example usage in subprocess orchestrator:
+"""
+session_manager = SessionManager()
+
+# In run_non_interactive:
+with OrchestrationSession(session_manager, "pm_delegation") as session_id:
+    # Run PM with session
+    stdout, stderr, returncode = self.launcher.launch_oneshot(
+        message=pm_prompt,
+        session_id=session_id,  # First call creates context
+        timeout=30
+    )
+    
+    # Run agents with same session (reuses context)
+    for agent, task in delegations:
+        stdout, stderr, returncode = self.launcher.launch_oneshot(
+            message=agent_prompt,
+            session_id=session_id,  # Reuses PM context!
+            timeout=60
+        )
+        session_manager.record_agent_use(session_id, agent, task)
+"""