claude-mpm 3.9.11__py3-none-any.whl → 4.0.4__py3-none-any.whl

claude_mpm/services/core/__init__.py

@@ -9,115 +9,68 @@ and implement the appropriate interfaces.
 Part of TSK-0046: Service Layer Architecture Reorganization
 """
 
-from .interfaces import (
-    # Core dependency injection
-    IServiceContainer,
-    ServiceType,
-    
-    # Configuration management
-    IConfigurationService,
-    IConfigurationManager,
-    
-    # Agent management
-    IAgentRegistry,
+from .base import BaseService, SingletonService, SyncBaseService
+from .interfaces import (  # Core dependency injection; Configuration management; Agent management; Health monitoring; Caching; Template management; Factory patterns; Event system; Logging; Service lifecycle; Error handling; Performance monitoring; Cache service; Agent deployment; Memory service; Hook service; SocketIO service; Project analyzer; Ticket manager; Interface registry
+    AgentDeploymentInterface,
     AgentMetadata,
-    
-    # Health monitoring
-    IHealthMonitor,
+    CacheEntry,
     HealthStatus,
-    
-    # Caching
+    HookServiceInterface,
+    IAgentRegistry,
+    ICacheService,
+    IConfigurationManager,
+    IConfigurationService,
+    IErrorHandler,
+    IEventBus,
+    IHealthMonitor,
+    InterfaceRegistry,
+    IPerformanceMonitor,
     IPromptCache,
-    CacheEntry,
-    
-    # Template management
-    ITemplateManager,
-    TemplateRenderContext,
-    
-    # Factory patterns
+    IServiceContainer,
     IServiceFactory,
-    
-    # Event system
-    IEventBus,
-    
-    # Logging
-    IStructuredLogger,
-    
-    # Service lifecycle
     IServiceLifecycle,
-    
-    # Error handling
-    IErrorHandler,
-    
-    # Performance monitoring
-    IPerformanceMonitor,
-    
-    # Cache service
-    ICacheService,
-    
-    # Agent deployment
-    AgentDeploymentInterface,
-    
-    # Memory service
+    IStructuredLogger,
+    ITemplateManager,
     MemoryServiceInterface,
-    
-    # Hook service
-    HookServiceInterface,
-    
-    # SocketIO service
-    SocketIOServiceInterface,
-    
-    # Project analyzer
     ProjectAnalyzerInterface,
-    
-    # Ticket manager
+    ServiceType,
+    SocketIOServiceInterface,
+    TemplateRenderContext,
     TicketManagerInterface,
-    
-    # Interface registry
-    InterfaceRegistry,
-)
-
-from .base import (
-    BaseService,
-    SyncBaseService,
-    SingletonService,
 )
 
 __all__ = [
     # Core interfaces
-    'IServiceContainer',
-    'ServiceType',
-    'IConfigurationService',
-    'IConfigurationManager',
-    'IAgentRegistry',
-    'AgentMetadata',
-    'IHealthMonitor',
-    'HealthStatus',
-    'IPromptCache',
-    'CacheEntry',
-    'ITemplateManager',
-    'TemplateRenderContext',
-    'IServiceFactory',
-    'IEventBus',
-    'IStructuredLogger',
-    'IServiceLifecycle',
-    'IErrorHandler',
-    'IPerformanceMonitor',
-    'ICacheService',
-    
+    "IServiceContainer",
+    "ServiceType",
+    "IConfigurationService",
+    "IConfigurationManager",
+    "IAgentRegistry",
+    "AgentMetadata",
+    "IHealthMonitor",
+    "HealthStatus",
+    "IPromptCache",
+    "CacheEntry",
+    "ITemplateManager",
+    "TemplateRenderContext",
+    "IServiceFactory",
+    "IEventBus",
+    "IStructuredLogger",
+    "IServiceLifecycle",
+    "IErrorHandler",
+    "IPerformanceMonitor",
+    "ICacheService",
     # Service interfaces
-    'AgentDeploymentInterface',
-    'MemoryServiceInterface',
-    'HookServiceInterface',
-    'SocketIOServiceInterface',
-    'ProjectAnalyzerInterface',
-    'TicketManagerInterface',
-    
+    "AgentDeploymentInterface",
+    "MemoryServiceInterface",
+    "HookServiceInterface",
+    "SocketIOServiceInterface",
+    "ProjectAnalyzerInterface",
+    "TicketManagerInterface",
     # Registry
-    'InterfaceRegistry',
-    
+    "InterfaceRegistry",
     # Base classes
-    'BaseService',
-    'SyncBaseService',
-    'SingletonService',
-]
+    "BaseService",
+    "SyncBaseService",
+    "SingletonService",
+]

claude_mpm/services/core/base.py

@@ -9,10 +9,9 @@ and lifecycle management.
 Part of TSK-0046: Service Layer Architecture Reorganization
 """
 
+import logging
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
-import logging
-from pathlib import Path
 
 from claude_mpm.core.logger import get_logger
 
@@ -20,18 +19,22 @@ from claude_mpm.core.logger import get_logger
 class BaseService(ABC):
     """
     Base class for all services in the Claude MPM framework.
-    
+
     Provides:
     - Logging setup
     - Configuration access
     - Lifecycle management
     - Common error handling patterns
     """
-    
-    def __init__(self, service_name: Optional[str] = None, config: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        service_name: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ):
         """
         Initialize base service.
-        
+
         Args:
             service_name: Name of the service for logging
             config: Service-specific configuration
@@ -41,78 +44,78 @@ class BaseService(ABC):
         self._config = config or {}
         self._initialized = False
         self._shutdown = False
-    
+
     @abstractmethod
     async def initialize(self) -> bool:
         """
         Initialize the service.
-        
+
         This method should be called before the service is used.
         Implementations should set up any required resources.
-        
+
         Returns:
             True if initialization successful, False otherwise
         """
         pass
-    
+
     @abstractmethod
     async def shutdown(self) -> None:
         """
         Shutdown the service gracefully.
-        
+
         This method should clean up any resources held by the service.
         """
         pass
-    
+
     def get_config(self, key: str, default: Any = None) -> Any:
         """
         Get configuration value.
-        
+
         Args:
             key: Configuration key
             default: Default value if key not found
-            
+
         Returns:
             Configuration value or default
         """
         return self._config.get(key, default)
-    
+
     def set_config(self, key: str, value: Any) -> None:
         """
         Set configuration value.
-        
+
         Args:
             key: Configuration key
             value: Configuration value
         """
         self._config[key] = value
-    
+
     @property
     def is_initialized(self) -> bool:
         """Check if service is initialized."""
         return self._initialized
-    
+
     @property
     def is_shutdown(self) -> bool:
         """Check if service is shutdown."""
         return self._shutdown
-    
+
     def log_debug(self, message: str, **kwargs) -> None:
         """Log debug message."""
         self.logger.debug(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_info(self, message: str, **kwargs) -> None:
         """Log info message."""
         self.logger.info(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_warning(self, message: str, **kwargs) -> None:
         """Log warning message."""
         self.logger.warning(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_error(self, message: str, **kwargs) -> None:
         """Log error message."""
         self.logger.error(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_critical(self, message: str, **kwargs) -> None:
         """Log critical message."""
         self.logger.critical(f"[{self.service_name}] {message}", **kwargs)
@@ -121,14 +124,18 @@ class BaseService(ABC):
 class SyncBaseService(ABC):
     """
     Base class for synchronous services in the Claude MPM framework.
-    
+
     Similar to BaseService but for services that don't require async operations.
     """
-    
-    def __init__(self, service_name: Optional[str] = None, config: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        service_name: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ):
         """
         Initialize base service.
-        
+
         Args:
             service_name: Name of the service for logging
             config: Service-specific configuration
@@ -138,78 +145,78 @@ class SyncBaseService(ABC):
         self._config = config or {}
         self._initialized = False
         self._shutdown = False
-    
+
     @abstractmethod
     def initialize(self) -> bool:
         """
         Initialize the service.
-        
+
         This method should be called before the service is used.
         Implementations should set up any required resources.
-        
+
         Returns:
             True if initialization successful, False otherwise
         """
         pass
-    
+
     @abstractmethod
     def shutdown(self) -> None:
         """
         Shutdown the service gracefully.
-        
+
         This method should clean up any resources held by the service.
         """
         pass
-    
+
     def get_config(self, key: str, default: Any = None) -> Any:
         """
         Get configuration value.
-        
+
         Args:
             key: Configuration key
             default: Default value if key not found
-            
+
         Returns:
             Configuration value or default
         """
         return self._config.get(key, default)
-    
+
     def set_config(self, key: str, value: Any) -> None:
         """
         Set configuration value.
-        
+
         Args:
             key: Configuration key
             value: Configuration value
         """
         self._config[key] = value
-    
+
     @property
     def is_initialized(self) -> bool:
         """Check if service is initialized."""
         return self._initialized
-    
+
     @property
     def is_shutdown(self) -> bool:
         """Check if service is shutdown."""
         return self._shutdown
-    
+
     def log_debug(self, message: str, **kwargs) -> None:
         """Log debug message."""
         self.logger.debug(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_info(self, message: str, **kwargs) -> None:
         """Log info message."""
         self.logger.info(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_warning(self, message: str, **kwargs) -> None:
         """Log warning message."""
         self.logger.warning(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_error(self, message: str, **kwargs) -> None:
         """Log error message."""
         self.logger.error(f"[{self.service_name}] {message}", **kwargs)
-    
+
     def log_critical(self, message: str, **kwargs) -> None:
         """Log critical message."""
         self.logger.critical(f"[{self.service_name}] {message}", **kwargs)
@@ -218,30 +225,30 @@ class SyncBaseService(ABC):
 class SingletonService(SyncBaseService):
     """
     Base class for singleton services.
-    
+
     Ensures only one instance of the service exists.
     """
-    
-    _instances: Dict[type, 'SingletonService'] = {}
-    
+
+    _instances: Dict[type, "SingletonService"] = {}
+
     def __new__(cls, *args, **kwargs):
         """Ensure only one instance exists."""
         if cls not in cls._instances:
             cls._instances[cls] = super().__new__(cls)
         return cls._instances[cls]
-    
+
     @classmethod
-    def get_instance(cls) -> 'SingletonService':
+    def get_instance(cls) -> "SingletonService":
         """Get the singleton instance."""
         if cls not in cls._instances:
             cls._instances[cls] = cls()
         return cls._instances[cls]
-    
+
     @classmethod
     def clear_instance(cls) -> None:
         """Clear the singleton instance (useful for testing)."""
         if cls in cls._instances:
             instance = cls._instances[cls]
-            if hasattr(instance, 'shutdown') and not instance.is_shutdown:
+            if hasattr(instance, "shutdown") and not instance.is_shutdown:
                 instance.shutdown()
-            del cls._instances[cls]
+            del cls._instances[cls]

claude_mpm/services/core/interfaces/__init__.py

@@ -0,0 +1,188 @@
+"""
+Core Interfaces Package for Claude MPM Framework
+===============================================
+
+WHY: This package contains the modular interface definitions that were extracted
+from the monolithic interfaces.py file. The interfaces are now organized by
+domain for better maintainability and discoverability.
+
+DESIGN DECISION: Interfaces are grouped by domain (infrastructure, agent, service,
+communication) rather than alphabetically to create logical cohesion and make
+it easier to understand the system architecture.
+
+REFACTORING IMPACT:
+- Original interfaces.py: 1,437 lines with 34 classes
+- Split into 4 focused modules: ~1,200 lines total
+- Improved organization and maintainability
+- Preserved all original functionality through re-exports
+
+MODULES:
+- infrastructure.py: Core framework services (DI, config, caching, health)
+- agent.py: Agent management, deployment, and capabilities
+- service.py: Business services (memory, hooks, utilities)
+- communication.py: External communication (WebSocket, project analysis, tickets)
+"""
+
+# Agent interfaces (agent management and operations)
+from .agent import (  # Agent registry; Agent deployment; Agent capabilities; System instructions; Subprocess management; Runner configuration
+    AgentCapabilitiesInterface,
+    AgentDeploymentInterface,
+    AgentMetadata,
+    IAgentRegistry,
+    RunnerConfigurationInterface,
+    SubprocessLauncherInterface,
+    SystemInstructionsInterface,
+)
+
+# Communication interfaces (external services)
+from .communication import (  # WebSocket/SocketIO; Project analysis; Ticket management
+    ProjectAnalyzerInterface,
+    SocketIOServiceInterface,
+    TicketManagerInterface,
+)
+
+# Infrastructure interfaces (core framework services)
+from .infrastructure import (  # Type variables; Core dependency injection; Configuration management; Caching; Health monitoring; Template management; Service factory; Logging; Service lifecycle; Error handling; Performance monitoring; Event system
+    CacheEntry,
+    HealthStatus,
+    ICacheService,
+    IConfigurationManager,
+    IConfigurationService,
+    IErrorHandler,
+    IEventBus,
+    IHealthMonitor,
+    IPerformanceMonitor,
+    IPromptCache,
+    IServiceContainer,
+    IServiceFactory,
+    IServiceLifecycle,
+    IStructuredLogger,
+    ITemplateManager,
+    ServiceType,
+    T,
+    TemplateRenderContext,
+)
+
+# Service interfaces (business services)
+from .service import (  # Version service; Command handling; Memory management; Session management; Utilities; Hook service
+    CommandHandlerInterface,
+    HookServiceInterface,
+    MemoryHookInterface,
+    MemoryServiceInterface,
+    SessionManagementInterface,
+    UtilityServiceInterface,
+    VersionServiceInterface,
+)
+
+
+# Interface registry for dependency injection discovery
+class InterfaceRegistry:
+    """Registry of all core interfaces for dependency injection.
+
+    WHY: Provides a centralized registry for interface discovery and
+    dependency injection container registration. This enables dynamic
+    service discovery and loose coupling between components.
+    """
+
+    _interfaces = {
+        # Infrastructure interfaces
+        "service_container": IServiceContainer,
+        "configuration_service": IConfigurationService,
+        "configuration_manager": IConfigurationManager,
+        "cache_service": ICacheService,
+        "prompt_cache": IPromptCache,
+        "health_monitor": IHealthMonitor,
+        "template_manager": ITemplateManager,
+        "service_factory": IServiceFactory,
+        "structured_logger": IStructuredLogger,
+        "service_lifecycle": IServiceLifecycle,
+        "error_handler": IErrorHandler,
+        "performance_monitor": IPerformanceMonitor,
+        "event_bus": IEventBus,
+        # Agent interfaces
+        "agent_registry": IAgentRegistry,
+        "agent_deployment": AgentDeploymentInterface,
+        "agent_capabilities": AgentCapabilitiesInterface,
+        "system_instructions": SystemInstructionsInterface,
+        "subprocess_launcher": SubprocessLauncherInterface,
+        "runner_configuration": RunnerConfigurationInterface,
+        # Service interfaces
+        "version_service": VersionServiceInterface,
+        "command_handler": CommandHandlerInterface,
+        "memory_hook": MemoryHookInterface,
+        "memory_service": MemoryServiceInterface,
+        "session_management": SessionManagementInterface,
+        "utility_service": UtilityServiceInterface,
+        "hook_service": HookServiceInterface,
+        # Communication interfaces
+        "socketio_service": SocketIOServiceInterface,
+        "project_analyzer": ProjectAnalyzerInterface,
+        "ticket_manager": TicketManagerInterface,
+    }
+
+    @classmethod
+    def get_interface(cls, name: str):
+        """Get interface by name."""
+        return cls._interfaces.get(name)
+
+    @classmethod
+    def get_all_interfaces(cls):
+        """Get all registered interfaces."""
+        return cls._interfaces.copy()
+
+    @classmethod
+    def register_interface(cls, name: str, interface_class):
+        """Register a new interface."""
+        cls._interfaces[name] = interface_class
+
+    @classmethod
+    def list_interface_names(cls):
+        """Get list of all interface names."""
+        return list(cls._interfaces.keys())
+
+
+# Re-export everything for backward compatibility
+__all__ = [
+    # Type variables
+    "T",
+    "ServiceType",
+    # Infrastructure interfaces
+    "IServiceContainer",
+    "IConfigurationService",
+    "IConfigurationManager",
+    "ICacheService",
+    "IPromptCache",
+    "CacheEntry",
+    "IHealthMonitor",
+    "HealthStatus",
+    "ITemplateManager",
+    "TemplateRenderContext",
+    "IServiceFactory",
+    "IStructuredLogger",
+    "IServiceLifecycle",
+    "IErrorHandler",
+    "IPerformanceMonitor",
+    "IEventBus",
+    # Agent interfaces
+    "IAgentRegistry",
+    "AgentMetadata",
+    "AgentDeploymentInterface",
+    "AgentCapabilitiesInterface",
+    "SystemInstructionsInterface",
+    "SubprocessLauncherInterface",
+    "RunnerConfigurationInterface",
+    # Service interfaces
+    "VersionServiceInterface",
+    "CommandHandlerInterface",
+    "MemoryHookInterface",
+    "MemoryServiceInterface",
+    "SessionManagementInterface",
+    "UtilityServiceInterface",
+    "HookServiceInterface",
+    # Communication interfaces
+    "SocketIOServiceInterface",
+    "ProjectAnalyzerInterface",
+    "TicketManagerInterface",
+    # Registry
+    "InterfaceRegistry",
+]