claude-mpm 4.5.6__py3-none-any.whl → 4.5.11__py3-none-any.whl

claude_mpm/cli/parsers/configure_parser.py

@@ -58,6 +58,11 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
         action="store_true",
         help="Jump directly to behavior file management",
     )
+    nav_group.add_argument(
+        "--startup",
+        action="store_true",
+        help="Configure startup services and agents",
+    )
     nav_group.add_argument(
         "--version-info",
         action="store_true",

claude_mpm/core/__init__.py

@@ -1,20 +1,56 @@
-"""Core components for Claude MPM."""
-
-from .claude_runner import ClaudeRunner
-from .config import Config
-
-# Import DI components
-from .container import DIContainer, ServiceLifetime, get_container
-from .factories import (
-    AgentServiceFactory,
-    ConfigurationFactory,
-    ServiceFactory,
-    SessionManagerFactory,
-    get_factory_registry,
-)
-from .injectable_service import InjectableService
-from .mixins import LoggerMixin
-from .service_registry import ServiceRegistry, get_service_registry, initialize_services
+"""Core components for Claude MPM.
+
+Lazy imports for all components to avoid loading heavy dependencies
+when only importing lightweight utilities (constants, logging_utils, etc).
+"""
+
+
+# Lazy imports via __getattr__ to prevent loading heavy dependencies
+# when hooks only need lightweight utilities
+def __getattr__(name):
+    """Lazy load core components only when accessed using dictionary-based mapping."""
+    from importlib import import_module
+
+    # Dictionary mapping: name -> (module_path, attribute_name)
+    _LAZY_IMPORTS = {
+        # Core components
+        "ClaudeRunner": ("claude_mpm.core.claude_runner", "ClaudeRunner"),
+        "Config": ("claude_mpm.core.config", "Config"),
+        # Dependency injection
+        "DIContainer": ("claude_mpm.core.container", "DIContainer"),
+        "ServiceLifetime": ("claude_mpm.core.container", "ServiceLifetime"),
+        "get_container": ("claude_mpm.core.container", "get_container"),
+        # Factories
+        "AgentServiceFactory": ("claude_mpm.core.factories", "AgentServiceFactory"),
+        "ConfigurationFactory": ("claude_mpm.core.factories", "ConfigurationFactory"),
+        "ServiceFactory": ("claude_mpm.core.factories", "ServiceFactory"),
+        "SessionManagerFactory": ("claude_mpm.core.factories", "SessionManagerFactory"),
+        "get_factory_registry": ("claude_mpm.core.factories", "get_factory_registry"),
+        # Services and utilities
+        "InjectableService": (
+            "claude_mpm.core.injectable_service",
+            "InjectableService",
+        ),
+        "LoggerMixin": ("claude_mpm.core.mixins", "LoggerMixin"),
+        # Service registry
+        "ServiceRegistry": ("claude_mpm.core.service_registry", "ServiceRegistry"),
+        "get_service_registry": (
+            "claude_mpm.core.service_registry",
+            "get_service_registry",
+        ),
+        "initialize_services": (
+            "claude_mpm.core.service_registry",
+            "initialize_services",
+        ),
+    }
+
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+        module = import_module(module_path)
+        return getattr(module, attr_name)
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
 
 __all__ = [
     "AgentServiceFactory",

claude_mpm/core/config.py

@@ -201,7 +201,7 @@ class Config:
                         # Set flag IMMEDIATELY before logging to prevent any possibility of duplicate
                         # messages. No lock needed here since we're already inside __init__ lock
                         Config._success_logged = True
-                        logger.info(
+                        logger.debug(
                             f"✓ Successfully loaded configuration from {file_path}"
                         )
                     else:

claude_mpm/core/log_manager.py

@@ -122,6 +122,13 @@ class LogManager:
         if run_cleanup_on_startup is None:
             return  # Cleanup utility not available
 
+        # Check environment variable to skip cleanup (for configure command)
+        import os
+
+        if os.environ.get("CLAUDE_MPM_SKIP_CLEANUP", "0") == "1":
+            logger.debug("Startup cleanup skipped (CLAUDE_MPM_SKIP_CLEANUP=1)")
+            return
+
         try:
             # Get cleanup configuration
             cleanup_config = self.config.get("log_cleanup", {})

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -10,28 +10,27 @@ import os
 import re
 import sys
 from datetime import datetime, timezone
-from typing import Optional
+from typing import Any, Optional
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
 # Response tracking integration
-RESPONSE_TRACKING_AVAILABLE = False
-try:
-    from claude_mpm.services.response_tracker import ResponseTracker
-
-    RESPONSE_TRACKING_AVAILABLE = True
-except Exception as e:
-    if DEBUG:
-        print(f"Response tracking not available: {e}", file=sys.stderr)
-    RESPONSE_TRACKING_AVAILABLE = False
+# NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
+# This prevents unnecessary import of base_agent_loader and other heavy dependencies
+# when hooks don't need response tracking
+RESPONSE_TRACKING_AVAILABLE = (
+    True  # Assume available, will check on actual initialization
+)
 
 
 class ResponseTrackingManager:
     """Manager for response tracking functionality."""
 
     def __init__(self):
-        self.response_tracker: Optional[ResponseTracker] = None
+        self.response_tracker: Optional[Any] = (
+            None  # Type hint changed to Any for lazy import
+        )
         self.response_tracking_enabled = False
         self.track_all_interactions = (
             False  # Track all Claude interactions, not just delegations
@@ -49,8 +48,14 @@ class ResponseTrackingManager:
 
         DESIGN DECISION: Check configuration to allow enabling/disabling
         response tracking without code changes.
+
+        NOTE: ResponseTracker is imported lazily here to avoid loading
+        base_agent_loader and other heavy dependencies unless actually needed.
         """
         try:
+            # Lazy import of ResponseTracker to avoid unnecessary dependency loading
+            from claude_mpm.services.response_tracker import ResponseTracker
+
             # Create configuration with optional config file using ConfigLoader
             config_file = os.environ.get("CLAUDE_PM_CONFIG_FILE")
             from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -26,14 +26,8 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter
-try:
-    from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-    EVENT_EMITTER_AVAILABLE = True
-except ImportError:
-    EVENT_EMITTER_AVAILABLE = False
-    get_event_emitter = None
+# Import high-performance event emitter - lazy loaded in _async_emit()
+# to reduce hook handler initialization time by ~85% (792ms -> minimal)
 
 # Import EventNormalizer for consistent event formatting
 try:
@@ -137,9 +131,6 @@ class ConnectionManagerService:
 
     def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
         """Try to emit event using high-performance async emitter."""
-        if not EVENT_EMITTER_AVAILABLE:
-            return False
-
         try:
             # Run async emission in the current event loop or create one
             loop = None
@@ -170,8 +161,15 @@ class ConnectionManagerService:
     async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
         """Async helper for event emission."""
         try:
+            # Lazy load event emitter to reduce initialization overhead
+            from claude_mpm.services.monitor.event_emitter import get_event_emitter
+
             emitter = await get_event_emitter()
             return await emitter.emit_event(namespace, "claude_event", data)
+        except ImportError:
+            if DEBUG:
+                print("⚠️ Event emitter not available", file=sys.stderr)
+            return False
         except Exception as e:
             if DEBUG:
                 print(f"⚠️ Async emitter error: {e}", file=sys.stderr)

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
+            module = import_module("claude_mpm.services.recovery_manager")
+            return module.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
+    # 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)
 
-        return LoggingService
-    elif name == "SocketIOClientManager":
-        from .socketio_client_manager import SocketIOClientManager
+    # 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)
 
-        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 [
+    # 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/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/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")