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

claude_mpm/core/config_constants.py

@@ -18,7 +18,7 @@ Usage:
     cache_size = ConfigConstants.get_cache_setting('max_size_mb')
 """
 
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from .unified_config import ConfigurationService
 
@@ -79,6 +79,11 @@ class ConfigConstants:
             "max_file_size_mb": 10,
             "max_memory_usage_mb": 1024,
         },
+        # Logging configuration
+        "logging": {
+            "startup_logs_retention_count": 10,
+            "mpm_logs_retention_count": 10,
+        },
     }
 
     @classmethod
@@ -109,18 +114,17 @@ class ConfigConstants:
 
             if timeout_type == "hook_execution":
                 return config.performance.hook_timeout_seconds
-            elif timeout_type == "session_default":
+            if timeout_type == "session_default":
                 return config.performance.session_timeout_seconds
-            elif timeout_type == "session_extended":
+            if timeout_type == "session_extended":
                 return config.sessions.session_timeout_minutes * 60
-            elif timeout_type == "agent_loading":
+            if timeout_type == "agent_loading":
                 return config.performance.agent_load_timeout_seconds
-            elif timeout_type == "startup":
+            if timeout_type == "startup":
                 return config.performance.startup_timeout
-            elif timeout_type == "graceful_shutdown":
+            if timeout_type == "graceful_shutdown":
                 return config.performance.graceful_shutdown_timeout
-            else:
-                return cls.DEFAULT_VALUES["timeouts"].get(timeout_type, 30)
+            return cls.DEFAULT_VALUES["timeouts"].get(timeout_type, 30)
         except Exception:
             return cls.DEFAULT_VALUES["timeouts"].get(timeout_type, 30)
 
@@ -140,12 +144,11 @@ class ConfigConstants:
 
             if port_type == "socketio_default":
                 return config.network.socketio_port
-            elif port_type == "socketio_range_start":
+            if port_type == "socketio_range_start":
                 return config.network.socketio_port_range[0]
-            elif port_type == "socketio_range_end":
+            if port_type == "socketio_range_end":
                 return config.network.socketio_port_range[1]
-            else:
-                return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
+            return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
         except Exception:
             return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
 
@@ -165,15 +168,38 @@ class ConfigConstants:
 
             if setting_name == "max_size_mb":
                 return config.performance.cache_max_size_mb
-            elif setting_name == "max_entries":
+            if setting_name == "max_entries":
                 return config.performance.cache_max_entries
-            elif setting_name == "default_ttl_seconds":
+            if setting_name == "default_ttl_seconds":
                 return config.performance.cache_default_ttl_seconds
-            else:
-                return cls.DEFAULT_VALUES["cache"].get(setting_name)
+            return cls.DEFAULT_VALUES["cache"].get(setting_name)
         except Exception:
             return cls.DEFAULT_VALUES["cache"].get(setting_name)
 
+    @classmethod
+    def get_logging_setting(cls, setting_name: str) -> Any:
+        """
+        Get logging setting by name.
+
+        Args:
+            setting_name: Name of logging setting
+
+        Returns:
+            Logging setting value
+        """
+        try:
+            # For now, just return from DEFAULT_VALUES
+            # Can be extended to read from unified config later
+            return cls.DEFAULT_VALUES["logging"].get(setting_name)
+        except Exception:
+            # Fallback to default values
+            if setting_name in {
+                "startup_logs_retention_count",
+                "mpm_logs_retention_count",
+            }:
+                return 10
+            return None
+
     @classmethod
     def get_session_setting(cls, setting_name: str) -> Any:
         """
@@ -190,12 +216,11 @@ class ConfigConstants:
 
             if setting_name == "max_age_minutes":
                 return config.sessions.max_age_minutes
-            elif setting_name == "cleanup_max_age_hours":
+            if setting_name == "cleanup_max_age_hours":
                 return config.sessions.cleanup_max_age_hours
-            elif setting_name == "timeout_minutes":
+            if setting_name == "timeout_minutes":
                 return config.sessions.session_timeout_minutes
-            else:
-                return cls.DEFAULT_VALUES["sessions"].get(setting_name)
+            return cls.DEFAULT_VALUES["sessions"].get(setting_name)
         except Exception:
             return cls.DEFAULT_VALUES["sessions"].get(setting_name)
 
@@ -215,10 +240,9 @@ class ConfigConstants:
 
             if setting_name == "max_restarts":
                 return config.performance.max_restarts
-            elif setting_name == "max_recovery_attempts":
+            if setting_name == "max_recovery_attempts":
                 return config.performance.max_recovery_attempts
-            else:
-                return cls.DEFAULT_VALUES["recovery"].get(setting_name, 3)
+            return cls.DEFAULT_VALUES["recovery"].get(setting_name, 3)
         except Exception:
             return cls.DEFAULT_VALUES["recovery"].get(setting_name, 3)
 
@@ -238,12 +262,11 @@ class ConfigConstants:
 
             if interval_type == "health_check":
                 return config.performance.health_check_interval_seconds
-            elif interval_type == "polling":
+            if interval_type == "polling":
                 return config.performance.polling_interval_seconds
-            elif interval_type == "batch_window_ms":
+            if interval_type == "batch_window_ms":
                 return config.performance.batch_window_ms / 1000.0
-            else:
-                return cls.DEFAULT_VALUES["intervals"].get(interval_type, 1.0)
+            return cls.DEFAULT_VALUES["intervals"].get(interval_type, 1.0)
         except Exception:
             return cls.DEFAULT_VALUES["intervals"].get(interval_type, 1.0)
 
@@ -263,10 +286,9 @@ class ConfigConstants:
 
             if limit_type == "max_file_size_mb":
                 return config.security.max_file_size_mb
-            elif limit_type == "max_memory_usage_mb":
+            if limit_type == "max_memory_usage_mb":
                 return config.performance.max_memory_usage_mb
-            else:
-                return cls.DEFAULT_VALUES["limits"].get(limit_type, 100)
+            return cls.DEFAULT_VALUES["limits"].get(limit_type, 100)
         except Exception:
             return cls.DEFAULT_VALUES["limits"].get(limit_type, 100)
 

claude_mpm/core/constants.py

@@ -4,7 +4,6 @@ This module consolidates all magic numbers and configuration constants
 that were previously scattered throughout the codebase.
 """
 
-from enum import Enum
 from typing import Tuple
 
 

claude_mpm/core/container.py

@@ -13,7 +13,6 @@ that supports:
 
 import inspect
 import threading
-from abc import ABC
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Set, Type, TypeVar, Union
 
@@ -76,22 +75,17 @@ class ServiceRegistration:
         # 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
+        # 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 ServiceScope:
     """
@@ -337,17 +331,16 @@ class DIContainer(IServiceContainer):
                 if not hasattr(self, "_named_singletons"):
                     self._named_singletons = {}
                 self._named_singletons[named_key] = instance
+        # Normal registration without name
+        elif instance is not None:
+            self._register_internal(interface, instance=instance)
+        elif implementation is not None and not inspect.isclass(implementation):
+            # It's an instance passed as implementation (backward compatibility)
+            self._register_internal(interface, instance=implementation)
         else:
-            # Normal registration without name
-            if instance is not None:
-                self._register_internal(interface, instance=instance)
-            elif implementation is not None and not inspect.isclass(implementation):
-                # It's an instance passed as implementation (backward compatibility)
-                self._register_internal(interface, instance=implementation)
-            else:
-                self._register_internal(
-                    interface, implementation, lifetime=ServiceLifetime.SINGLETON
-                )
+            self._register_internal(
+                interface, implementation, lifetime=ServiceLifetime.SINGLETON
+            )
 
         # Handle disposal handler
         if dispose_handler:
@@ -485,12 +478,11 @@ class DIContainer(IServiceContainer):
             registration = self._named_registrations[name]
             if registration.instance is not None:
                 return registration.instance
-            elif registration.factory:
+            if registration.factory:
                 return registration.factory(self)
-            else:
-                return self.create_instance(
-                    registration.implementation, registration.dependencies
-                )
+            return self.create_instance(
+                registration.implementation, registration.dependencies
+            )
 
         return self._resolve_internal(interface)
 
@@ -669,8 +661,7 @@ class DIContainer(IServiceContainer):
                         raise CircularDependencyError(
                             f"Circular dependency detected: {cycle}"
                         )
-                    else:
-                        kwargs[param_name] = self.resolve(param_type)
+                    kwargs[param_name] = self.resolve(param_type)
                 elif param.default != param.empty:
                     # Use default value
                     kwargs[param_name] = param.default
@@ -813,7 +804,7 @@ class DIContainer(IServiceContainer):
         type_name = service_type.__name__.lower()
         similar = []
 
-        for registered_type in self._registrations.keys():
+        for registered_type in self._registrations:
             registered_name = registered_type.__name__
             registered_lower = registered_name.lower()
 
@@ -845,7 +836,7 @@ class DIContainer(IServiceContainer):
         name_lower = name.lower()
         similar = []
 
-        for registered_name in self._named_registrations.keys():
+        for registered_name in self._named_registrations:
             registered_lower = registered_name.lower()
 
             # Check for substring match

claude_mpm/core/exceptions.py

@@ -24,7 +24,7 @@ Usage:
     raise AgentDeploymentError("Failed to deploy agent to .claude/agents directory")
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 
 class MPMError(Exception):
@@ -429,7 +429,7 @@ class ProcessError(MPMError):
                 self.message = f"[Command: {context['command']}] {message}"
             if "exit_code" in context:
                 self.message += f"\nExit code: {context['exit_code']}"
-            if "stderr" in context and context["stderr"]:
+            if context.get("stderr"):
                 stderr_preview = str(context["stderr"])[:200]
                 self.message += f"\nError output: {stderr_preview}"
                 if len(str(context["stderr"])) > 200:

claude_mpm/core/factories.py

@@ -7,14 +7,18 @@ Provides factory patterns for services that require complex initialization
 or have multiple configuration options.
 """
 
+import os
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Dict, Optional, TypeVar
 
 from ..services import AgentDeploymentService
 from .config import Config
 from .container import DIContainer
 from .logger import get_logger
 
+if TYPE_CHECKING:
+    from .unified_config import ConfigurationService
+
 # Note: Orchestration functionality has been replaced by claude_runner
 
 logger = get_logger(__name__)
@@ -28,7 +32,6 @@ class ServiceFactory(ABC):
     @abstractmethod
     def create(self, container: DIContainer, **kwargs) -> Any:
         """Create a service instance."""
-        pass
 
 
 # OrchestratorFactoryWrapper has been removed - orchestration replaced by claude_runner
@@ -57,8 +60,6 @@ class AgentServiceFactory(ServiceFactory):
         config = container.resolve(Config)
 
         # Get directories from config if not provided
-        import os
-
         if framework_dir is None:
             framework_dir = Path(config.get("framework.dir", "framework"))
 
@@ -112,14 +113,13 @@ class SessionManagerFactory(ServiceFactory):
             return AgentSessionManager(
                 session_dir=session_dir, max_sessions_per_agent=max_sessions
             )
-        else:
-            from ..core.session_manager import SessionManager
+        from ..core.session_manager import SessionManager
 
-            session_dir = kwargs.get("session_dir") or Path(
-                config.get("session.dir", ".claude-mpm/sessions")
-            )
+        session_dir = kwargs.get("session_dir") or Path(
+            config.get("session.dir", ".claude-mpm/sessions")
+        )
 
-            return SessionManager(session_dir=session_dir)
+        return SessionManager(session_dir=session_dir)
 
 
 class ConfigurationFactory(ServiceFactory):
@@ -148,8 +148,6 @@ class ConfigurationFactory(ServiceFactory):
         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