claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/core/interfaces/infrastructure.py

@@ -35,27 +35,22 @@ class IServiceContainer(ABC):
         self, service_type: type, implementation: type, singleton: bool = True
     ) -> None:
         """Register a service implementation"""
-        pass
 
     @abstractmethod
     def register_instance(self, service_type: type, instance: Any) -> None:
         """Register a service instance"""
-        pass
 
     @abstractmethod
     def resolve(self, service_type: type) -> Any:
         """Resolve a service by type"""
-        pass
 
     @abstractmethod
     def resolve_all(self, service_type: type) -> List[Any]:
         """Resolve all implementations of a service type"""
-        pass
 
     @abstractmethod
     def is_registered(self, service_type: type) -> bool:
         """Check if a service type is registered"""
-        pass
 
 
 # Configuration management interfaces
@@ -65,22 +60,18 @@ class IConfigurationService(ABC):
     @abstractmethod
     def get(self, key: str, default: Any = None) -> Any:
         """Get configuration value by key"""
-        pass
 
     @abstractmethod
     def set(self, key: str, value: Any) -> None:
         """Set configuration value"""
-        pass
 
     @abstractmethod
     def reload(self) -> None:
         """Reload configuration from source"""
-        pass
 
     @abstractmethod
     def shutdown(self) -> None:
         """Shutdown configuration service"""
-        pass
 
 
 class IConfigurationManager(ABC):
@@ -89,32 +80,26 @@ class IConfigurationManager(ABC):
     @abstractmethod
     def get(self, key: str, default: Any = None) -> Any:
         """Get configuration value by key"""
-        pass
 
     @abstractmethod
     def set(self, key: str, value: Any) -> None:
         """Set configuration value"""
-        pass
 
     @abstractmethod
     def validate_config(self, config: Dict[str, Any]) -> Tuple[bool, List[str]]:
         """Validate configuration structure and values"""
-        pass
 
     @abstractmethod
     def load_from_file(self, config_path: Path) -> None:
         """Load configuration from file"""
-        pass
 
     @abstractmethod
     def save_to_file(self, config_path: Path) -> None:
         """Save configuration to file"""
-        pass
 
     @abstractmethod
     def watch_changes(self, callback: callable) -> None:
         """Watch for configuration changes"""
-        pass
 
 
 # Cache service interface
@@ -124,32 +109,26 @@ class ICacheService(ABC):
     @abstractmethod
     def get(self, key: str) -> Any:
         """Get value from cache"""
-        pass
 
     @abstractmethod
     def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
         """Set value in cache with optional TTL"""
-        pass
 
     @abstractmethod
     def delete(self, key: str) -> bool:
         """Delete key from cache"""
-        pass
 
     @abstractmethod
     def invalidate(self, pattern: str) -> int:
         """Invalidate keys matching pattern"""
-        pass
 
     @abstractmethod
     def clear(self) -> None:
         """Clear all cache entries"""
-        pass
 
     @abstractmethod
     def get_cache_metrics(self) -> Dict[str, Any]:
         """Get cache performance metrics"""
-        pass
 
 
 # Health monitoring interface
@@ -170,22 +149,18 @@ class IHealthMonitor(ABC):
     @abstractmethod
     async def check_health(self, service_name: str) -> HealthStatus:
         """Check health of a specific service"""
-        pass
 
     @abstractmethod
     async def check_all_services(self) -> Dict[str, HealthStatus]:
         """Check health of all registered services"""
-        pass
 
     @abstractmethod
     def register_health_check(self, service_name: str, check_func: callable) -> None:
         """Register a health check function for a service"""
-        pass
 
     @abstractmethod
     def get_health_summary(self) -> Dict[str, Any]:
         """Get overall health summary"""
-        pass
 
 
 # Prompt cache interface
@@ -211,27 +186,22 @@ class IPromptCache(ABC):
     @abstractmethod
     def get(self, key: str) -> Optional[Any]:
         """Get cached value by key"""
-        pass
 
     @abstractmethod
     def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
         """Set cached value with optional TTL"""
-        pass
 
     @abstractmethod
     def invalidate(self, pattern: str) -> int:
         """Invalidate cache entries matching pattern"""
-        pass
 
     @abstractmethod
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics"""
-        pass
 
     @abstractmethod
     def clear(self) -> None:
         """Clear all cache entries"""
-        pass
 
 
 # Template management interface
@@ -253,17 +223,14 @@ class ITemplateManager(ABC):
         self, template_content: str, context: TemplateRenderContext
     ) -> str:
         """Render template with given context"""
-        pass
 
     @abstractmethod
     async def load_template(self, template_path: Path) -> str:
         """Load template from file"""
-        pass
 
     @abstractmethod
     def register_function(self, name: str, func: callable) -> None:
         """Register custom template function"""
-        pass
 
 
 # Service factory interface
@@ -273,17 +240,14 @@ class IServiceFactory(Generic[ServiceType], ABC):
     @abstractmethod
     def create(self, **kwargs) -> ServiceType:
         """Create service instance"""
-        pass
 
     @abstractmethod
     def get_service_type(self) -> type:
         """Get the service type this factory creates"""
-        pass
 
     @abstractmethod
     def supports(self, service_type: type) -> bool:
         """Check if factory supports service type"""
-        pass
 
 
 # Logging interface
@@ -293,27 +257,22 @@ class IStructuredLogger(ABC):
     @abstractmethod
     def debug(self, message: str, **kwargs) -> None:
         """Log debug message with structured data"""
-        pass
 
     @abstractmethod
     def info(self, message: str, **kwargs) -> None:
         """Log info message with structured data"""
-        pass
 
     @abstractmethod
     def warning(self, message: str, **kwargs) -> None:
         """Log warning message with structured data"""
-        pass
 
     @abstractmethod
     def error(self, message: str, **kwargs) -> None:
         """Log error message with structured data"""
-        pass
 
     @abstractmethod
     def set_context(self, **kwargs) -> None:
         """Set logging context for all subsequent messages"""
-        pass
 
 
 # Service lifecycle interface
@@ -323,27 +282,22 @@ class IServiceLifecycle(ABC):
     @abstractmethod
     async def initialize(self) -> None:
         """Initialize the service"""
-        pass
 
     @abstractmethod
     async def start(self) -> None:
         """Start the service"""
-        pass
 
     @abstractmethod
     async def stop(self) -> None:
         """Stop the service"""
-        pass
 
     @abstractmethod
     async def restart(self) -> None:
         """Restart the service"""
-        pass
 
     @abstractmethod
     def is_running(self) -> bool:
         """Check if service is running"""
-        pass
 
 
 # Error handling interface
@@ -353,12 +307,10 @@ class IErrorHandler(ABC):
     @abstractmethod
     def handle_error(self, error: Exception, context: Dict[str, Any]) -> None:
         """Handle error with context"""
-        pass
 
     @abstractmethod
     def get_error_stats(self) -> Dict[str, Any]:
         """Get error statistics"""
-        pass
 
 
 # Performance monitoring interface
@@ -368,24 +320,20 @@ class IPerformanceMonitor(ABC):
     @abstractmethod
     def start_timer(self, operation: str) -> str:
         """Start timing an operation"""
-        pass
 
     @abstractmethod
     def end_timer(self, timer_id: str) -> float:
         """End timing and return duration"""
-        pass
 
     @abstractmethod
     def record_metric(
         self, name: str, value: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
         """Record a performance metric"""
-        pass
 
     @abstractmethod
     def get_metrics(self) -> Dict[str, Any]:
         """Get performance metrics"""
-        pass
 
 
 # Event system interface
@@ -395,19 +343,15 @@ class IEventBus(ABC):
     @abstractmethod
     def publish(self, event_type: str, data: Any) -> None:
         """Publish an event"""
-        pass
 
     @abstractmethod
     def subscribe(self, event_type: str, handler: callable) -> str:
         """Subscribe to an event type"""
-        pass
 
     @abstractmethod
     def unsubscribe(self, subscription_id: str) -> None:
         """Unsubscribe from events"""
-        pass
 
     @abstractmethod
     async def publish_async(self, event_type: str, data: Any) -> None:
         """Publish an event asynchronously"""
-        pass

claude_mpm/services/core/interfaces/service.py

@@ -41,7 +41,6 @@ class VersionServiceInterface(ABC):
         Returns:
             Version string in semantic version format
         """
-        pass
 
     @abstractmethod
     def get_version_info(self) -> Dict[str, Any]:
@@ -50,7 +49,6 @@ class VersionServiceInterface(ABC):
         Returns:
             Dictionary with version details and metadata
         """
-        pass
 
     @abstractmethod
     def format_version_display(self, include_build: bool = False) -> str:
@@ -62,7 +60,6 @@ class VersionServiceInterface(ABC):
         Returns:
             Formatted version string for display
         """
-        pass
 
     @abstractmethod
     def check_for_updates(self) -> Dict[str, Any]:
@@ -71,7 +68,6 @@ class VersionServiceInterface(ABC):
         Returns:
             Dictionary with update information
         """
-        pass
 
 
 # Command handler interface
@@ -97,7 +93,6 @@ class CommandHandlerInterface(ABC):
         Returns:
             Dictionary with command execution results
         """
-        pass
 
     @abstractmethod
     def get_available_commands(self) -> List[str]:
@@ -106,7 +101,6 @@ class CommandHandlerInterface(ABC):
         Returns:
             List of available command names
         """
-        pass
 
     @abstractmethod
     def get_command_help(self, command: str) -> str:
@@ -118,7 +112,6 @@ class CommandHandlerInterface(ABC):
         Returns:
             Help text for the command
         """
-        pass
 
 
 # Memory hook interface
@@ -136,12 +129,10 @@ class MemoryHookInterface(ABC):
     @abstractmethod
     def register_memory_hooks(self):
         """Register memory-related hooks with the hook service."""
-        pass
 
     @abstractmethod
     def unregister_memory_hooks(self):
         """Unregister memory-related hooks from the hook service."""
-        pass
 
     @abstractmethod
     def get_hook_status(self) -> Dict[str, Any]:
@@ -150,7 +141,6 @@ class MemoryHookInterface(ABC):
         Returns:
             Dictionary with hook status information
         """
-        pass
 
 
 # Session management interface
@@ -175,7 +165,6 @@ class SessionManagementInterface(ABC):
         Returns:
             Session ID
         """
-        pass
 
     @abstractmethod
     def end_session(self, session_id: str) -> bool:
@@ -187,7 +176,6 @@ class SessionManagementInterface(ABC):
         Returns:
             True if session ended successfully
         """
-        pass
 
     @abstractmethod
     def get_session_status(self, session_id: str) -> Dict[str, Any]:
@@ -199,7 +187,6 @@ class SessionManagementInterface(ABC):
         Returns:
             Dictionary with session status information
         """
-        pass
 
     @abstractmethod
     def list_active_sessions(self) -> List[str]:
@@ -208,7 +195,6 @@ class SessionManagementInterface(ABC):
         Returns:
             List of active session IDs
         """
-        pass
 
     @abstractmethod
     async def cleanup_sessions(self) -> int:
@@ -217,7 +203,6 @@ class SessionManagementInterface(ABC):
         Returns:
             Number of sessions cleaned up
         """
-        pass
 
 
 # Utility service interface
@@ -242,7 +227,6 @@ class UtilityServiceInterface(ABC):
         Returns:
             Formatted size string (e.g., "1.5 MB")
         """
-        pass
 
     @abstractmethod
     def format_duration(self, seconds: float) -> str:
@@ -254,7 +238,6 @@ class UtilityServiceInterface(ABC):
         Returns:
             Formatted duration string (e.g., "2m 30s")
         """
-        pass
 
     @abstractmethod
     def sanitize_filename(self, filename: str) -> str:
@@ -266,7 +249,6 @@ class UtilityServiceInterface(ABC):
         Returns:
             Sanitized filename
         """
-        pass
 
     @abstractmethod
     def generate_unique_id(self, prefix: str = "") -> str:
@@ -278,7 +260,6 @@ class UtilityServiceInterface(ABC):
         Returns:
             Unique identifier string
         """
-        pass
 
     @abstractmethod
     def validate_path(self, path: Path) -> Tuple[bool, Optional[str]]:
@@ -290,7 +271,6 @@ class UtilityServiceInterface(ABC):
         Returns:
             Tuple of (is_valid, error_message)
         """
-        pass
 
 
 # Memory service interface
@@ -315,7 +295,6 @@ class MemoryServiceInterface(ABC):
         Returns:
             Memory content as string or None if not found
         """
-        pass
 
     @abstractmethod
     def save_memory(self, agent_id: str, content: str) -> bool:
@@ -328,7 +307,6 @@ class MemoryServiceInterface(ABC):
         Returns:
             True if save successful
         """
-        pass
 
     @abstractmethod
     def validate_memory_size(self, content: str) -> Tuple[bool, Optional[str]]:
@@ -340,7 +318,6 @@ class MemoryServiceInterface(ABC):
         Returns:
             Tuple of (is_valid, error_message)
         """
-        pass
 
     @abstractmethod
     def optimize_memory(self, agent_id: str) -> bool:
@@ -352,7 +329,6 @@ class MemoryServiceInterface(ABC):
         Returns:
             True if optimization successful
         """
-        pass
 
     @abstractmethod
     def get_memory_stats(self, agent_id: str) -> Dict[str, Any]:
@@ -364,7 +340,6 @@ class MemoryServiceInterface(ABC):
         Returns:
             Dictionary with memory statistics
         """
-        pass
 
 
 # Hook service interface
@@ -393,7 +368,6 @@ class HookServiceInterface(ABC):
         Returns:
             Hook registration ID
         """
-        pass
 
     @abstractmethod
     def unregister_hook(self, registration_id: str) -> bool:
@@ -405,7 +379,6 @@ class HookServiceInterface(ABC):
         Returns:
             True if unregistration successful
         """
-        pass
 
     @abstractmethod
     def execute_hook(self, hook_name: str, *args, **kwargs) -> List[Any]:
@@ -419,7 +392,6 @@ class HookServiceInterface(ABC):
         Returns:
             List of callback return values
         """
-        pass
 
     @abstractmethod
     def get_hook_info(self, hook_name: str) -> Dict[str, Any]:
@@ -431,4 +403,3 @@ class HookServiceInterface(ABC):
         Returns:
             Dictionary with hook information
         """
-        pass

claude_mpm/services/diagnostics/__init__.py

@@ -15,4 +15,4 @@ from .diagnostic_runner import DiagnosticRunner
 from .doctor_reporter import DoctorReporter
 from .models import DiagnosticResult, DiagnosticStatus
 
-__all__ = ["DiagnosticRunner", "DoctorReporter", "DiagnosticResult", "DiagnosticStatus"]
+__all__ = ["DiagnosticResult", "DiagnosticRunner", "DiagnosticStatus", "DoctorReporter"]

claude_mpm/services/diagnostics/checks/__init__.py

@@ -17,14 +17,14 @@ from .monitor_check import MonitorCheck
 from .startup_log_check import StartupLogCheck
 
 __all__ = [
+    "AgentCheck",
     "BaseDiagnosticCheck",
-    "InstallationCheck",
-    "ConfigurationCheck",
     "ClaudeDesktopCheck",
-    "AgentCheck",
+    "CommonIssuesCheck",
+    "ConfigurationCheck",
+    "FilesystemCheck",
+    "InstallationCheck",
     "MCPCheck",
     "MonitorCheck",
-    "FilesystemCheck",
-    "CommonIssuesCheck",
     "StartupLogCheck",
-]
+]