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

claude_mpm/services/recovery_manager.py

@@ -19,16 +19,15 @@ import asyncio
 import logging
 import os
 import signal
-import threading
 import time
 from abc import ABC, abstractmethod
 from collections import deque
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional
 
-from claude_mpm.core.constants import PerformanceConfig, RetryConfig, TimeoutConfig
+from claude_mpm.core.constants import PerformanceConfig, RetryConfig
 
 from .infrastructure.monitoring import HealthCheckResult, HealthStatus
 
@@ -85,17 +84,14 @@ class RecoveryStrategy(ABC):
     @abstractmethod
     def should_recover(self, health_result: HealthCheckResult) -> bool:
         """Determine if recovery should be triggered based on health result."""
-        pass
 
     @abstractmethod
     def get_recovery_action(self, health_result: HealthCheckResult) -> RecoveryAction:
         """Determine the appropriate recovery action."""
-        pass
 
     @abstractmethod
     def get_name(self) -> str:
         """Get the name of this recovery strategy."""
-        pass
 
 
 class GradedRecoveryStrategy(RecoveryStrategy):
@@ -183,16 +179,14 @@ class GradedRecoveryStrategy(RecoveryStrategy):
         if health_result.overall_status == HealthStatus.CRITICAL:
             if failure_count >= 3:
                 return RecoveryAction.EMERGENCY_STOP
-            elif failure_count >= 2:
+            if failure_count >= 2:
                 return RecoveryAction.RESTART_SERVICE
-            else:
-                return RecoveryAction.CLEAR_CONNECTIONS
+            return RecoveryAction.CLEAR_CONNECTIONS
 
-        elif health_result.overall_status == HealthStatus.WARNING:
+        if health_result.overall_status == HealthStatus.WARNING:
             if failure_count >= self.warning_threshold:
                 return RecoveryAction.CLEAR_CONNECTIONS
-            else:
-                return RecoveryAction.LOG_WARNING
+            return RecoveryAction.LOG_WARNING
 
         return RecoveryAction.NONE
 
@@ -242,17 +236,14 @@ class CircuitBreaker:
         if self.state == CircuitState.CLOSED:
             return True
 
-        elif self.state == CircuitState.OPEN:
+        if self.state == CircuitState.OPEN:
             # Check if timeout has elapsed
             if current_time - self.last_failure_time >= self.timeout_seconds:
                 self._transition_to_half_open()
                 return True
             return False
 
-        elif self.state == CircuitState.HALF_OPEN:
-            return True
-
-        return False
+        return self.state == CircuitState.HALF_OPEN
 
     def record_success(self) -> None:
         """Record a successful recovery operation."""
@@ -612,8 +603,8 @@ class RecoveryManager:
             self.logger.info("Attempting graceful service restart")
 
             # Save current configuration
-            host = getattr(self.server_instance, "host", "localhost")
-            port = getattr(self.server_instance, "port", 8765)
+            getattr(self.server_instance, "host", "localhost")
+            getattr(self.server_instance, "port", 8765)
 
             # Stop current server
             try:

claude_mpm/services/response_tracker.py

@@ -24,7 +24,6 @@ from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
 from claude_mpm.core.shared.config_loader import ConfigLoader
-from claude_mpm.services.claude_session_logger import ClaudeSessionLogger
 
 logger = logging.getLogger(__name__)
 

claude_mpm/services/runner_configuration_service.py

@@ -17,9 +17,8 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.core.config import Config
-from claude_mpm.core.container import ServiceLifetime, get_container
+from claude_mpm.core.container import ServiceLifetime
 from claude_mpm.core.logger import get_project_logger
-from claude_mpm.core.logging_config import get_logger
 from claude_mpm.core.shared.config_loader import ConfigLoader
 from claude_mpm.services.core.interfaces import RunnerConfigurationInterface
 
@@ -33,11 +32,9 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     # Implementation of abstract methods from RunnerConfigurationInterface
 
@@ -61,7 +58,6 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
         """
         # This method can delegate to existing service registration methods
         # For now, this is a no-op as service registration is handled elsewhere
-        pass
 
     def load_configuration(self, config_path: Optional[Path] = None) -> Dict[str, Any]:
         """Load configuration from file or defaults.
@@ -78,12 +74,15 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             if config_path:
                 # Use specific config file with ConfigLoader
                 from claude_mpm.core.shared.config_loader import ConfigPattern
+
                 pattern = ConfigPattern(
                     filenames=[Path(config_path).name],
                     search_paths=[str(Path(config_path).parent)],
-                    env_prefix="CLAUDE_MPM_"
+                    env_prefix="CLAUDE_MPM_",
+                )
+                config = config_loader.load_config(
+                    pattern, cache_key=f"runner_{config_path}"
                 )
-                config = config_loader.load_config(pattern, cache_key=f"runner_{config_path}")
             else:
                 # Use main config
                 config = config_loader.load_main_config()
@@ -198,7 +197,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
         try:
             project_logger = get_project_logger(log_level)
             project_logger.log_system(
-                f"Initializing ClaudeRunner", level="INFO", component="runner"
+                "Initializing ClaudeRunner", level="INFO", component="runner"
             )
             return project_logger
         except ImportError as e:
@@ -231,7 +230,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
                     "Response logging initialized", level="INFO", component="logging"
                 )
             return response_logger
-        except Exception as e:
+        except Exception:
             self.logger.warning("Failed to initialize response logger", exc_info=True)
             return None
 
@@ -244,7 +243,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
         if "CLAUDE_MPM_USER_PWD" in os.environ:
             user_working_dir = Path(os.environ["CLAUDE_MPM_USER_PWD"])
             self.logger.info(
-                f"Using user working directory from CLAUDE_MPM_USER_PWD",
+                "Using user working directory from CLAUDE_MPM_USER_PWD",
                 extra={"directory": str(user_working_dir)},
             )
             return user_working_dir
@@ -310,7 +309,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(HookServiceInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning("Failed to initialize hook service", exc_info=True)
             return None
 
@@ -336,7 +335,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(AgentCapabilitiesInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize agent capabilities service", exc_info=True
             )
@@ -371,7 +370,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(SystemInstructionsInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize system instructions service", exc_info=True
             )
@@ -407,7 +406,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(SubprocessLauncherInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize subprocess launcher service", exc_info=True
             )
@@ -431,7 +430,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(VersionServiceInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning("Failed to initialize version service", exc_info=True)
             return None
 
@@ -460,7 +459,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(CommandHandlerInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize command handler service", exc_info=True
             )
@@ -489,7 +488,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(MemoryHookInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize memory hook service", exc_info=True
             )
@@ -520,7 +519,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(SessionManagementInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning(
                 "Failed to initialize session management service", exc_info=True
             )
@@ -544,7 +543,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
 
         try:
             return container.get(UtilityServiceInterface)
-        except Exception as e:
+        except Exception:
             self.logger.warning("Failed to initialize utility service", exc_info=True)
             return None
 
@@ -569,7 +568,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             session_log_file = project_logger.session_dir / "system.jsonl"
 
             # Log session start event
-            session_event = {
+            {
                 "event": "session_start",
                 "runner": "ClaudeRunner",
                 "enable_tickets": config_data.get("enable_tickets"),

claude_mpm/services/session_management_service.py

@@ -34,11 +34,9 @@ class SessionManagementService(BaseService, SessionManagementInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def run_interactive_session(self, initial_context: Optional[str] = None) -> bool:
         """Run Claude in interactive mode using session delegation.
@@ -252,9 +250,8 @@ class SessionManagementService(BaseService, SessionManagementInterface):
 
             self.logger.info(f"Ended session {session_id}")
             return True
-        else:
-            self.logger.warning(f"Session {session_id} not found")
-            return False
+        self.logger.warning(f"Session {session_id} not found")
+        return False
 
     def get_session_status(self, session_id: str) -> Dict[str, Any]:
         """Get status of a session.
@@ -267,12 +264,11 @@ class SessionManagementService(BaseService, SessionManagementInterface):
         """
         if session_id in self.active_sessions:
             return self.active_sessions[session_id].copy()
-        else:
-            return {
-                "id": session_id,
-                "status": "not_found",
-                "error": "Session not found",
-            }
+        return {
+            "id": session_id,
+            "status": "not_found",
+            "error": "Session not found",
+        }
 
     def list_active_sessions(self) -> List[str]:
         """List all active session IDs.

claude_mpm/services/shared/__init__.py

@@ -13,7 +13,7 @@ from .service_factory import ServiceFactory
 
 __all__ = [
     "AsyncServiceBase",
-    "ConfigServiceBase", 
+    "ConfigServiceBase",
     "LifecycleServiceBase",
     "ManagerBase",
     "ServiceFactory",

claude_mpm/services/shared/async_service_base.py

@@ -12,6 +12,7 @@ from ...core.mixins import LoggerMixin
 
 class AsyncServiceState(Enum):
     """Standard states for async services."""
+
     UNINITIALIZED = "uninitialized"
     INITIALIZING = "initializing"
     RUNNING = "running"
@@ -23,18 +24,18 @@ class AsyncServiceState(Enum):
 class AsyncServiceBase(LoggerMixin, ABC):
     """
     Base class for asynchronous services.
-    
+
     Provides common patterns:
     - State management
     - Lifecycle methods
     - Error handling
     - Background task management
     """
-    
+
     def __init__(self, service_name: str, config: Optional[Dict[str, Any]] = None):
         """
         Initialize async service.
-        
+
         Args:
             service_name: Name of the service
             config: Optional configuration dictionary
@@ -42,38 +43,38 @@ class AsyncServiceBase(LoggerMixin, ABC):
         self.service_name = service_name
         self._logger_name = f"service.{service_name}"
         self.config = config or {}
-        
+
         # State management
         self._state = AsyncServiceState.UNINITIALIZED
         self._state_lock = asyncio.Lock()
-        
+
         # Background tasks
         self._background_tasks: set = set()
         self._shutdown_event = asyncio.Event()
-        
+
         # Error tracking
         self._last_error: Optional[Exception] = None
         self._error_count = 0
-    
+
     @property
     def state(self) -> AsyncServiceState:
         """Get current service state."""
         return self._state
-    
+
     @property
     def is_running(self) -> bool:
         """Check if service is running."""
         return self._state == AsyncServiceState.RUNNING
-    
+
     @property
     def is_healthy(self) -> bool:
         """Check if service is healthy."""
         return self._state == AsyncServiceState.RUNNING and self._last_error is None
-    
+
     async def initialize(self) -> bool:
         """
         Initialize the service.
-        
+
         Returns:
             True if initialization successful
         """
@@ -81,113 +82,122 @@ class AsyncServiceBase(LoggerMixin, ABC):
             if self._state != AsyncServiceState.UNINITIALIZED:
                 self.logger.warning(f"Service {self.service_name} already initialized")
                 return self._state == AsyncServiceState.RUNNING
-            
+
             self._state = AsyncServiceState.INITIALIZING
             self.logger.info(f"Initializing service: {self.service_name}")
-            
+
             try:
                 success = await self._do_initialize()
                 if success:
                     self._state = AsyncServiceState.RUNNING
-                    self.logger.info(f"Service {self.service_name} initialized successfully")
+                    self.logger.info(
+                        f"Service {self.service_name} initialized successfully"
+                    )
                 else:
                     self._state = AsyncServiceState.ERROR
-                    self.logger.error(f"Service {self.service_name} initialization failed")
-                
+                    self.logger.error(
+                        f"Service {self.service_name} initialization failed"
+                    )
+
                 return success
-                
+
             except Exception as e:
                 self._state = AsyncServiceState.ERROR
                 self._last_error = e
                 self._error_count += 1
-                self.logger.error(f"Service {self.service_name} initialization error: {e}", exc_info=True)
+                self.logger.error(
+                    f"Service {self.service_name} initialization error: {e}",
+                    exc_info=True,
+                )
                 return False
-    
+
     async def shutdown(self) -> None:
         """Shutdown the service gracefully."""
         async with self._state_lock:
             if self._state in (AsyncServiceState.STOPPED, AsyncServiceState.STOPPING):
                 return
-            
+
             self._state = AsyncServiceState.STOPPING
             self.logger.info(f"Shutting down service: {self.service_name}")
-            
+
             try:
                 # Signal shutdown to background tasks
                 self._shutdown_event.set()
-                
+
                 # Cancel background tasks
                 await self._cancel_background_tasks()
-                
+
                 # Service-specific shutdown
                 await self._do_shutdown()
-                
+
                 self._state = AsyncServiceState.STOPPED
                 self.logger.info(f"Service {self.service_name} shut down successfully")
-                
+
             except Exception as e:
                 self._state = AsyncServiceState.ERROR
                 self._last_error = e
-                self.logger.error(f"Service {self.service_name} shutdown error: {e}", exc_info=True)
-    
+                self.logger.error(
+                    f"Service {self.service_name} shutdown error: {e}", exc_info=True
+                )
+
     async def restart(self) -> bool:
         """Restart the service."""
         self.logger.info(f"Restarting service: {self.service_name}")
         await self.shutdown()
-        
+
         # Reset state for restart
         self._state = AsyncServiceState.UNINITIALIZED
         self._shutdown_event.clear()
         self._last_error = None
-        
+
         return await self.initialize()
-    
-    def create_background_task(self, coro, name: str = None) -> asyncio.Task:
+
+    def create_background_task(self, coro, name: Optional[str] = None) -> asyncio.Task:
         """
         Create and track a background task.
-        
+
         Args:
             coro: Coroutine to run
             name: Optional task name
-            
+
         Returns:
             Created task
         """
         task = asyncio.create_task(coro, name=name)
         self._background_tasks.add(task)
-        
+
         # Remove task from set when done
         task.add_done_callback(self._background_tasks.discard)
-        
+
         return task
-    
+
     async def _cancel_background_tasks(self) -> None:
         """Cancel all background tasks."""
         if not self._background_tasks:
             return
-        
+
         self.logger.debug(f"Cancelling {len(self._background_tasks)} background tasks")
-        
+
         # Cancel all tasks
         for task in self._background_tasks:
             if not task.done():
                 task.cancel()
-        
+
         # Wait for cancellation with timeout
         try:
             await asyncio.wait_for(
                 asyncio.gather(*self._background_tasks, return_exceptions=True),
-                timeout=5.0
+                timeout=5.0,
             )
         except asyncio.TimeoutError:
             self.logger.warning("Some background tasks did not cancel within timeout")
-        
+
         self._background_tasks.clear()
-    
+
     async def health_check(self) -> Dict[str, Any]:
         """
         Perform health check.
-        
+
         Returns:
             Health status dictionary
         """
@@ -197,23 +207,21 @@ class AsyncServiceBase(LoggerMixin, ABC):
             "healthy": self.is_healthy,
             "error_count": self._error_count,
             "last_error": str(self._last_error) if self._last_error else None,
-            "background_tasks": len(self._background_tasks)
+            "background_tasks": len(self._background_tasks),
         }
-    
+
     @abstractmethod
     async def _do_initialize(self) -> bool:
         """
         Service-specific initialization logic.
-        
+
         Returns:
             True if initialization successful
         """
-        pass
-    
+
     async def _do_shutdown(self) -> None:
         """Service-specific shutdown logic."""
-        pass
-    
+
     def __repr__(self) -> str:
         """String representation."""
         return f"{self.__class__.__name__}(name={self.service_name}, state={self._state.value})"