claude-mpm 4.5.8__py3-none-any.whl → 4.5.12__py3-none-any.whl

claude_mpm/init.py

@@ -270,11 +270,11 @@ class ProjectInitializer:
         """
         try:
             # Read existing JSON configuration
-            with open(old_file) as f:
+            with old_file.open() as f:
                 config = json.load(f)
 
             # Write as YAML
-            with open(new_file, "w") as f:
+            with new_file.open("w") as f:
                 yaml.dump(config, f, default_flow_style=False, sort_keys=False)
 
             self.logger.info(
@@ -310,7 +310,7 @@ class ProjectInitializer:
             },
         }
 
-        with open(config_file, "w") as f:
+        with config_file.open("w") as f:
             yaml.dump(default_config, f, default_flow_style=False, sort_keys=False)
 
     def _create_project_config(self, config_file: Path):
@@ -322,7 +322,7 @@ class ProjectInitializer:
             "tickets": {"auto_create": True, "prefix": "TSK"},
         }
 
-        with open(config_file, "w") as f:
+        with config_file.open("w") as f:
             json.dump(project_config, f, indent=2)
 
     def _copy_agent_templates(self):

claude_mpm/models/agent_session.py

@@ -448,7 +448,7 @@ class AgentSession:
         filepath = directory / filename
 
         # Save to file
-        with open(filepath, "w", encoding="utf-8") as f:
+        with filepath.open("w", encoding="utf-8") as f:
             json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
 
         return str(filepath)

claude_mpm/scripts/socketio_daemon.py

@@ -37,7 +37,7 @@ def is_running(pid_file: Path) -> bool:
         return False
 
     try:
-        with open(pid_file) as f:
+        with pid_file.open() as f:
             pid = int(f.read().strip())
 
         # Check if process exists
@@ -85,7 +85,7 @@ def start_server(port: int = DEFAULT_PORT, daemon: bool = True) -> bool:
         logger.info(f"Socket.IO daemon started on port {actual_port}")
         # Save the port for clients to discover
         port_file = pid_file.parent / "socketio-port"
-        with open(port_file, "w") as f:
+        with port_file.open("w") as f:
             f.write(str(actual_port))
     else:
         logger.error("Failed to start Socket.IO daemon")
@@ -102,7 +102,7 @@ def stop_server() -> bool:
         return False
 
     try:
-        with open(pid_file) as f:
+        with pid_file.open() as f:
             pid = int(f.read().strip())
 
         # Send SIGTERM for graceful shutdown
@@ -155,12 +155,12 @@ def status_server() -> bool:
 
     if is_running(pid_file):
         try:
-            with open(pid_file) as f:
+            with pid_file.open() as f:
                 pid = int(f.read().strip())
 
             port = DEFAULT_PORT
             if port_file.exists():
-                with open(port_file) as f:
+                with port_file.open() as f:
                     port = int(f.read().strip())
 
             print(f"Socket.IO daemon is running (PID: {pid}, Port: {port})")

claude_mpm/services/__init__.py

@@ -13,169 +13,152 @@ New structure:
 
 
 # Use lazy imports to prevent circular dependency issues
-def __getattr__(name):  # noqa: PLR0911
-    """Lazy import to prevent circular dependencies."""
-    if name == "TicketManager":
-        from .ticket_manager import TicketManager
-
-        return TicketManager
-    if name == "AgentDeploymentService":
-        # Use correct path
-        from .agents.deployment import AgentDeploymentService
-
-        return AgentDeploymentService
-    if name == "AgentMemoryManager":
-        from .agents.memory import AgentMemoryManager
-
-        return AgentMemoryManager
-    if name == "get_memory_manager":
-        from .agents.memory import get_memory_manager
-
-        return get_memory_manager
-    # Add backward compatibility for other agent services
-    if name == "AgentRegistry":
-        # Use correct path
-        from .agents.registry import AgentRegistry
-
-        return AgentRegistry
-    if name == "AgentLifecycleManager":
-        from .agents.deployment import AgentLifecycleManager
-
-        return AgentLifecycleManager
-    if name == "AgentManager":
-        from .agents.management import AgentManager
-
-        return AgentManager
-    if name == "AgentCapabilitiesGenerator":
-        from .agents.management import AgentCapabilitiesGenerator
-
-        return AgentCapabilitiesGenerator
-    if name == "AgentModificationTracker":
-        from .agents.registry import AgentModificationTracker
-
-        return AgentModificationTracker
-    if name == "AgentPersistenceService":
-        from .agents.memory import AgentPersistenceService
-
-        return AgentPersistenceService
-    if name == "AgentProfileLoader":
-        from .agents.loading import AgentProfileLoader
-
-        return AgentProfileLoader
-    if name == "AgentVersionManager":
-        from .agents.deployment import AgentVersionManager
-
-        return AgentVersionManager
-    if name == "BaseAgentManager":
-        from .agents.loading import BaseAgentManager
-
-        return BaseAgentManager
-    if name == "DeployedAgentDiscovery":
-        from .agents.registry import DeployedAgentDiscovery
-
-        return DeployedAgentDiscovery
-    if name == "FrameworkAgentLoader":
-        from .agents.loading import FrameworkAgentLoader
-
-        return FrameworkAgentLoader
-    if name == "HookService":
-        from .hook_service import HookService
-
-        return HookService
-    if name == "ProjectAnalyzer":
-        from .project.analyzer import ProjectAnalyzer
-
-        return ProjectAnalyzer
-    if name == "AdvancedHealthMonitor":
-        from .infrastructure.monitoring import AdvancedHealthMonitor
-
-        return AdvancedHealthMonitor
-    if name == "HealthMonitor":
-        # For backward compatibility, return AdvancedHealthMonitor
-        # Note: There's also a different HealthMonitor in infrastructure.health_monitor
-        from .infrastructure.monitoring import AdvancedHealthMonitor
-
-        return AdvancedHealthMonitor
+def __getattr__(name):
+    """Lazy import to prevent circular dependencies using dictionary-based mapping."""
+    from importlib import import_module
+
+    # Dictionary mapping: name -> (module_path, attribute_name)
+    # For agent services, we import from the __init__.py modules to respect their import structure
+    _LAZY_IMPORTS = {
+        # Agent services - use __init__.py modules (not direct file paths) to respect import structure
+        "AgentDeploymentService": (
+            "claude_mpm.services.agents.deployment",
+            "AgentDeploymentService",
+        ),
+        "AgentMemoryManager": (
+            "claude_mpm.services.agents.memory",
+            "AgentMemoryManager",
+        ),
+        "get_memory_manager": (
+            "claude_mpm.services.agents.memory",
+            "get_memory_manager",
+        ),
+        "AgentRegistry": ("claude_mpm.services.agents.registry", "AgentRegistry"),
+        "AgentLifecycleManager": (
+            "claude_mpm.services.agents.deployment",
+            "AgentLifecycleManager",
+        ),
+        "AgentManager": ("claude_mpm.services.agents.management", "AgentManager"),
+        "AgentCapabilitiesGenerator": (
+            "claude_mpm.services.agents.management",
+            "AgentCapabilitiesGenerator",
+        ),
+        "AgentModificationTracker": (
+            "claude_mpm.services.agents.registry",
+            "AgentModificationTracker",
+        ),
+        "AgentPersistenceService": (
+            "claude_mpm.services.agents.memory",
+            "AgentPersistenceService",
+        ),
+        "AgentProfileLoader": (
+            "claude_mpm.services.agents.loading",
+            "AgentProfileLoader",
+        ),
+        "AgentVersionManager": (
+            "claude_mpm.services.agents.deployment",
+            "AgentVersionManager",
+        ),
+        "BaseAgentManager": ("claude_mpm.services.agents.loading", "BaseAgentManager"),
+        "DeployedAgentDiscovery": (
+            "claude_mpm.services.agents.registry",
+            "DeployedAgentDiscovery",
+        ),
+        "FrameworkAgentLoader": (
+            "claude_mpm.services.agents.loading",
+            "FrameworkAgentLoader",
+        ),
+        "AgentManagementService": (
+            "claude_mpm.services.agents.management",
+            "AgentManager",
+        ),
+        # Infrastructure services
+        "HookService": ("claude_mpm.services.hook_service", "HookService"),
+        "ProjectAnalyzer": ("claude_mpm.services.project.analyzer", "ProjectAnalyzer"),
+        "AdvancedHealthMonitor": (
+            "claude_mpm.services.infrastructure.monitoring",
+            "AdvancedHealthMonitor",
+        ),
+        "HealthMonitor": (
+            "claude_mpm.services.infrastructure.monitoring",
+            "AdvancedHealthMonitor",
+        ),
+        "LoggingService": (
+            "claude_mpm.services.infrastructure.logging",
+            "LoggingService",
+        ),
+        # Communication services
+        "StandaloneSocketIOServer": (
+            "claude_mpm.services.socketio_server",
+            "SocketIOServer",
+        ),
+        "SocketIOServer": ("claude_mpm.services.socketio_server", "SocketIOServer"),
+        "SocketIOClientManager": (
+            "claude_mpm.services.socketio_client_manager",
+            "SocketIOClientManager",
+        ),
+        # Memory services
+        "MemoryBuilder": ("claude_mpm.services.memory.builder", "MemoryBuilder"),
+        "MemoryRouter": ("claude_mpm.services.memory.router", "MemoryRouter"),
+        "MemoryOptimizer": ("claude_mpm.services.memory.optimizer", "MemoryOptimizer"),
+        "SimpleCacheService": (
+            "claude_mpm.services.memory.cache.simple_cache",
+            "SimpleCacheService",
+        ),
+        "SharedPromptCache": (
+            "claude_mpm.services.memory.cache.shared_prompt_cache",
+            "SharedPromptCache",
+        ),
+        # Project services
+        "ProjectRegistry": ("claude_mpm.services.project.registry", "ProjectRegistry"),
+        # MCP Gateway services
+        "MCPConfiguration": (
+            "claude_mpm.services.mcp_gateway.config.configuration",
+            "MCPConfiguration",
+        ),
+        "MCPConfigLoader": (
+            "claude_mpm.services.mcp_gateway.config.config_loader",
+            "MCPConfigLoader",
+        ),
+        "MCPServer": ("claude_mpm.services.mcp_gateway.server.mcp_server", "MCPServer"),
+        "MCPToolRegistry": (
+            "claude_mpm.services.mcp_gateway.tools.tool_registry",
+            "MCPToolRegistry",
+        ),
+        "BaseMCPService": (
+            "claude_mpm.services.mcp_gateway.core.base",
+            "BaseMCPService",
+        ),
+        # Other services
+        "TicketManager": ("claude_mpm.services.ticket_manager", "TicketManager"),
+    }
+
+    # Handle direct mappings
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+        module = import_module(module_path)
+        return getattr(module, attr_name)
+
+    # Handle RecoveryManager with special error handling
     if name == "RecoveryManager":
         try:
-            from .recovery_manager import RecoveryManager
-
-            return RecoveryManager
-        except ImportError:
-            raise AttributeError(f"Recovery management not available: {name}")
-    elif name in {"StandaloneSocketIOServer", "SocketIOServer"}:
-        from .socketio_server import SocketIOServer
-
-        return SocketIOServer
-    # Backward compatibility for memory services
-    elif name == "MemoryBuilder":
-        from .memory.builder import MemoryBuilder
-
-        return MemoryBuilder
-    elif name == "MemoryRouter":
-        from .memory.router import MemoryRouter
-
-        return MemoryRouter
-    elif name == "MemoryOptimizer":
-        from .memory.optimizer import MemoryOptimizer
-
-        return MemoryOptimizer
-    elif name == "SimpleCacheService":
-        from .memory.cache.simple_cache import SimpleCacheService
-
-        return SimpleCacheService
-    elif name == "SharedPromptCache":
-        from .memory.cache.shared_prompt_cache import SharedPromptCache
-
-        return SharedPromptCache
-    # New service organization imports
-    elif name == "AgentManagementService":
-        from .agents.management import AgentManager
-
-        return AgentManager
-    elif name == "ProjectRegistry":
-        from .project.registry import ProjectRegistry
-
-        return ProjectRegistry
-    elif name == "LoggingService":
-        from .infrastructure.logging import LoggingService
-
-        return LoggingService
-    elif name == "SocketIOClientManager":
-        from .socketio_client_manager import SocketIOClientManager
-
-        return SocketIOClientManager
-    # MCP Gateway services
-    elif name == "MCPConfiguration":
-        from .mcp_gateway.config.configuration import MCPConfiguration
-
-        return MCPConfiguration
-    elif name == "MCPConfigLoader":
-        from .mcp_gateway.config.config_loader import MCPConfigLoader
-
-        return MCPConfigLoader
-    elif name == "MCPServer":
-        from .mcp_gateway.server.mcp_server import MCPServer
-
-        return MCPServer
-    elif name == "MCPToolRegistry":
-        from .mcp_gateway.tools.tool_registry import MCPToolRegistry
-
-        return MCPToolRegistry
-    elif name == "BaseMCPService":
-        from .mcp_gateway.core.base import BaseMCPService
-
-        return BaseMCPService
-    elif name.startswith("IMCP"):
-        from .mcp_gateway.core import interfaces
-
-        return getattr(interfaces, name)
-    elif name.startswith("MCP") and "Error" in name:
-        from .mcp_gateway.core import exceptions
-
-        return getattr(exceptions, name)
-    # Core interfaces and base classes
-    elif name.startswith("I") or name in [
+            module = import_module("claude_mpm.services.recovery_manager")
+            return module.RecoveryManager
+        except ImportError as e:
+            raise AttributeError(f"Recovery management not available: {name}") from e
+
+    # Handle MCP interfaces (names starting with "IMCP")
+    if name.startswith("IMCP"):
+        module = import_module("claude_mpm.services.mcp_gateway.core.interfaces")
+        return getattr(module, name)
+
+    # Handle MCP exceptions (names starting with "MCP" and containing "Error")
+    if name.startswith("MCP") and "Error" in name:
+        module = import_module("claude_mpm.services.mcp_gateway.core.exceptions")
+        return getattr(module, name)
+
+    # Handle core interfaces and base classes
+    if name.startswith("I") or name in [
         "BaseService",
         "SyncBaseService",
         "SingletonService",
@@ -183,6 +166,7 @@ def __getattr__(name):  # noqa: PLR0911
         from . import core
 
         return getattr(core, name)
+
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 

claude_mpm/services/agent_capabilities_service.py

@@ -215,7 +215,7 @@ class AgentCapabilitiesService(BaseService, AgentCapabilitiesInterface):
                 self.logger.debug(f"Could not parse agent {agent_file}: {e}")
                 continue
 
-    def _categorize_agent(self, agent_id: str, content: str) -> str:  # noqa: PLR0911
+    def _categorize_agent(self, agent_id: str, content: str) -> str:
         """Categorize an agent based on its ID and content."""
         agent_id_lower = agent_id.lower()
         content_lower = content.lower()

claude_mpm/services/agents/agent_builder.py

@@ -287,7 +287,7 @@ class AgentBuilderService:
 
         for template_file in self.templates_dir.glob("*.json"):
             try:
-                with open(template_file) as f:
+                with template_file.open() as f:
                     config = json.load(f)
 
                 # Use filename stem as ID if not specified in config
@@ -377,12 +377,12 @@ class AgentBuilderService:
             raise AgentDeploymentError(f"Template '{template_id}' not found")
 
         try:
-            with open(template_file) as f:
+            with template_file.open() as f:
                 config = json.load(f)
                 self._template_cache[template_id] = config
                 return config.copy()
         except Exception as e:
-            raise AgentDeploymentError(f"Failed to load template '{template_id}': {e}")
+            raise AgentDeploymentError(f"Failed to load template '{template_id}': {e}") from e
 
     def _load_instructions(self, agent_id: str) -> str:
         """Load agent instructions.
@@ -406,7 +406,7 @@ class AgentBuilderService:
         for instructions_file in possible_files:
             if instructions_file.exists():
                 try:
-                    with open(instructions_file) as f:
+                    with instructions_file.open() as f:
                         return f.read()
                 except Exception as e:
                     self.logger.warning(

claude_mpm/services/agents/deployment/agent_lifecycle_manager.py

@@ -272,7 +272,7 @@ class AgentLifecycleManager(BaseService):
             # First convert to JSON string with custom encoder, then save
             json_str = json.dumps(data, indent=2, default=str)
             records_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(records_file, "w", encoding="utf-8") as f:
+            with records_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(self.agent_records)} agent records")

claude_mpm/services/agents/deployment/agent_metrics_collector.py

@@ -227,7 +227,7 @@ class AgentMetricsCollector:
             return "validation_error"
         return "other_error"
 
-    def _extract_agent_type(self, agent_name: str) -> str:  # noqa: PLR0911
+    def _extract_agent_type(self, agent_name: str) -> str:
         """
         Extract agent type from agent name for categorization.
 

claude_mpm/services/agents/deployment/agent_record_service.py

@@ -80,7 +80,7 @@ class AgentRecordService(BaseService):
             json_str = json.dumps(data, indent=2, default=str)
             self.records_file.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(self.records_file, "w", encoding="utf-8") as f:
+            with self.records_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(records)} agent records")
@@ -149,7 +149,7 @@ class AgentRecordService(BaseService):
             json_str = json.dumps(data, indent=2, default=str)
             self.history_file.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(self.history_file, "w", encoding="utf-8") as f:
+            with self.history_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(history)} operation history entries")
@@ -255,7 +255,7 @@ class AgentRecordService(BaseService):
 
                 # Write to output path
                 json_str = json.dumps(data, indent=2, default=str)
-                with open(output_path, "w", encoding="utf-8") as f:
+                with output_path.open("w", encoding="utf-8") as f:
                     f.write(json_str)
 
             elif format == "csv":

claude_mpm/services/agents/deployment/deployment_config_loader.py

@@ -112,8 +112,29 @@ class DeploymentConfigLoader:
         Returns:
             True if the agent should be deployed, False otherwise
         """
+        if config is None:
+            config = Config()
+
         settings = self.get_deployment_settings(config)
 
+        # Check startup configuration for system agents
+        if agent_source == "system":
+            # Check startup configuration first
+            startup_enabled = config.get("startup.enabled_agents", [])
+            if startup_enabled:
+                # Normalize for comparison
+                check_id = agent_id if settings["case_sensitive"] else agent_id.lower()
+                startup_list = (
+                    startup_enabled
+                    if settings["case_sensitive"]
+                    else [a.lower() for a in startup_enabled]
+                )
+                if check_id not in startup_list:
+                    self.logger.debug(
+                        f"Skipping system agent {agent_id} - not in startup enabled list"
+                    )
+                    return False
+
         # Check if the source type is enabled
         if agent_source == "system" and not settings["deploy_system_agents"]:
             self.logger.debug(

claude_mpm/services/agents/deployment/deployment_wrapper.py

@@ -91,7 +91,7 @@ class DeploymentServiceWrapper:
 
                     # Read agent content if file exists
                     if agent_path.exists():
-                        with open(agent_path) as f:
+                        with agent_path.open() as f:
                             content = f.read()
 
                         # Parse metadata from content

claude_mpm/services/agents/deployment/pipeline/steps/target_directory_step.py

@@ -48,10 +48,10 @@ class TargetDirectorySetupStep(BaseDeploymentStep):
             try:
                 test_file.write_text("test")
                 test_file.unlink()
-            except Exception:
+            except Exception as e:
                 raise PermissionError(
                     f"Target directory is not writable: {context.actual_target_dir}"
-                )
+                ) from e
 
             self.logger.info(f"Target directory set up: {context.actual_target_dir}")
 

claude_mpm/services/agents/loading/agent_profile_loader.py

@@ -457,7 +457,7 @@ class AgentProfileLoader(BaseService):
 
         if prompt_file.exists():
             try:
-                with open(prompt_file) as f:
+                with prompt_file.open() as f:
                     data = json.load(f)
                     for prompt_data in data:
                         prompt = ImprovedPrompt(
@@ -500,7 +500,7 @@ class AgentProfileLoader(BaseService):
 
             # Save to file
             prompt_file = self.improved_prompts_path / f"{agent_name}_prompts.json"
-            with open(prompt_file, "w") as f:
+            with prompt_file.open("w") as f:
                 json.dump(
                     [
                         {

claude_mpm/services/agents/loading/base_agent_manager.py

@@ -13,7 +13,9 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+# Lazy import for base_agent_loader to reduce initialization overhead
+# base_agent_loader adds ~500ms to import time
+# from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 from claude_mpm.services.shared import ConfigServiceBase
@@ -21,6 +23,13 @@ from claude_mpm.services.shared import ConfigServiceBase
 logger = get_logger(__name__)
 
 
+def _get_clear_base_agent_cache():
+    """Lazy loader for clear_base_agent_cache function."""
+    from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+
+    return clear_base_agent_cache
+
+
 class BaseAgentSection(str, Enum):
     """Base agent markdown sections."""
 
@@ -134,7 +143,8 @@ class BaseAgentManager(ConfigServiceBase):
         content = self._structure_to_markdown(current)
         self.base_agent_path.write_text(content, encoding="utf-8")
 
-        # Clear caches
+        # Clear caches (lazy load to avoid import overhead)
+        clear_base_agent_cache = _get_clear_base_agent_cache()
         clear_base_agent_cache()
         self.cache.invalidate("base_agent:instructions")
 

claude_mpm/services/agents/local_template_manager.py

@@ -195,7 +195,7 @@ class LocalAgentTemplateManager:
         """
         for template_file in directory.glob("*.json"):
             try:
-                with open(template_file) as f:
+                with template_file.open() as f:
                     data = json.load(f)
 
                 # Create LocalAgentTemplate
@@ -307,7 +307,7 @@ class LocalAgentTemplateManager:
 
         # Save to JSON file
         template_file = target_dir / f"{template.agent_id}.json"
-        with open(template_file, "w") as f:
+        with template_file.open("w") as f:
             json.dump(template.to_json(), f, indent=2)
 
         # Invalidate cache
@@ -628,7 +628,7 @@ class LocalAgentTemplateManager:
 
         # Save current version
         old_version_file = versions_dir / f"{template.agent_version}.json"
-        with open(old_version_file, "w") as f:
+        with old_version_file.open("w") as f:
             json.dump(template.to_json(), f, indent=2)
 
         # Update template version
@@ -691,7 +691,7 @@ class LocalAgentTemplateManager:
         count = 0
         for agent_id, template in templates.items():
             output_file = output_dir / f"{agent_id}.json"
-            with open(output_file, "w") as f:
+            with output_file.open("w") as f:
                 json.dump(template.to_json(), f, indent=2)
             count += 1
 
@@ -715,7 +715,7 @@ class LocalAgentTemplateManager:
         count = 0
         for template_file in input_dir.glob("*.json"):
             try:
-                with open(template_file) as f:
+                with template_file.open() as f:
                     data = json.load(f)
 
                 template = LocalAgentTemplate.from_json(data)