claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/scripts/start_activity_logging.py

@@ -51,7 +51,9 @@ if __name__ == "__main__":
 
     # Initialize aggregator
     aggregator = EventAggregator(
-        host="localhost", port=dashboard_port, save_dir=None  # Will use config value
+        host="localhost",
+        port=dashboard_port,
+        save_dir=None,  # Will use config value
     )
 
     # Set up signal handlers

claude_mpm/services/__init__.py

@@ -14,168 +14,151 @@ New structure:
 
 # Use lazy imports to prevent circular dependency issues
 def __getattr__(name):
-    """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
+    """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):
         from . import core
 
         return getattr(core, name)
+
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 

claude_mpm/services/agents/__init__.py

@@ -1,5 +1,8 @@
 """Agent services module - hierarchical organization of agent-related services."""
 
+# Auto-configuration exports
+from .auto_config_manager import AutoConfigManagerService
+
 # Registry exports
 # Deployment exports
 from .deployment.agent_deployment import AgentDeploymentService
@@ -29,6 +32,15 @@ from .memory.agent_persistence_service import (
     PersistenceRecord,
     PersistenceStrategy,
 )
+from .observers import (
+    CompositeObserver,
+    ConsoleProgressObserver,
+    IDeploymentObserver,
+    NullObserver,
+)
+
+# Recommender exports
+from .recommender import AgentRecommenderService
 from .registry import AgentMetadata, AgentRegistry, AgentTier, AgentType
 from .registry.deployed_agent_discovery import DeployedAgentDiscovery
 from .registry.modification_tracker import (
@@ -41,34 +53,35 @@ from .registry.modification_tracker import (
 
 __all__ = [
     "AgentCapabilitiesGenerator",
-    # Deployment
     "AgentDeploymentService",
     "AgentLifecycleManager",
     "AgentLifecycleRecord",
-    # Management
     "AgentManager",
-    # Memory
     "AgentMemoryManager",
     "AgentMetadata",
     "AgentModification",
     "AgentModificationTracker",
     "AgentPersistenceService",
     "AgentProfileLoader",
-    # Registry
+    "AgentRecommenderService",
     "AgentRegistry",
     "AgentTier",
     "AgentType",
     "AgentVersionManager",
+    "AutoConfigManagerService",
     "BaseAgentManager",
+    "CompositeObserver",
+    "ConsoleProgressObserver",
     "DeployedAgentDiscovery",
-    # Loading
     "FrameworkAgentLoader",
+    "IDeploymentObserver",
     "LifecycleOperation",
     "LifecycleOperationResult",
     "LifecycleState",
     "ModificationHistory",
     "ModificationTier",
     "ModificationType",
+    "NullObserver",
     "PersistenceOperation",
     "PersistenceRecord",
     "PersistenceStrategy",

claude_mpm/services/agents/agent_builder.py

@@ -8,11 +8,12 @@ This service provides comprehensive agent lifecycle management including:
 - Integration with deployment services
 """
 
-import json
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
+
+import yaml
 
 from claude_mpm.core.exceptions import AgentDeploymentError
 from claude_mpm.core.logging_config import get_logger
@@ -22,13 +23,13 @@ class AgentBuilderService:
     """Service for building and managing agent configurations."""
 
     # Valid agent models
-    VALID_MODELS = ["sonnet", "opus", "haiku"]
+    VALID_MODELS: ClassVar[list[str]] = ["sonnet", "opus", "haiku"]
 
     # Valid tool choices
-    VALID_TOOL_CHOICES = ["auto", "required", "any", "none"]
+    VALID_TOOL_CHOICES: ClassVar[list[str]] = ["auto", "required", "any", "none"]
 
     # Agent categories
-    AGENT_CATEGORIES = [
+    AGENT_CATEGORIES: ClassVar[list[str]] = [
         "engineering",
         "qa",
         "documentation",
@@ -108,7 +109,7 @@ class AgentBuilderService:
         agent_metadata = {
             "description": description,
             "version": "1.0.0",
-            "created": datetime.now().isoformat(),
+            "created": datetime.now(timezone.utc).isoformat(),
             "author": "Agent Manager",
             "category": "custom",
         }
@@ -179,7 +180,7 @@ class AgentBuilderService:
             {
                 "base_agent": base_agent_id,
                 "variant": True,
-                "variant_created": datetime.now().isoformat(),
+                "variant_created": datetime.now(timezone.utc).isoformat(),
             }
         )
 
@@ -285,10 +286,15 @@ class AgentBuilderService:
         if not self.templates_dir.exists():
             return templates
 
-        for template_file in self.templates_dir.glob("*.json"):
+        # Agent templates migrated to Markdown with YAML frontmatter (v4.26.0+)
+        for template_file in self.templates_dir.glob("*.md"):
             try:
-                with open(template_file) as f:
-                    config = json.load(f)
+                # Read markdown content and extract YAML frontmatter
+                content = template_file.read_text()
+                config = self._extract_yaml_frontmatter(content)
+                if not config:
+                    self.logger.warning(f"No YAML frontmatter in {template_file.name}")
+                    continue
 
                 # Use filename stem as ID if not specified in config
                 template_id = config.get("id") or template_file.stem
@@ -308,6 +314,30 @@ class AgentBuilderService:
 
         return templates
 
+    def _extract_yaml_frontmatter(self, content: str) -> Optional[Dict[str, Any]]:
+        """
+        Extract and parse YAML frontmatter from markdown content.
+
+        Args:
+            content: File content to parse
+
+        Returns:
+            Parsed YAML frontmatter as dict, or None if not found/invalid
+        """
+        if not content.strip().startswith("---"):
+            return None
+
+        # Split on --- delimiters
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            return None
+
+        try:
+            return yaml.safe_load(parts[1])
+        except yaml.YAMLError as e:
+            self.logger.warning(f"Failed to parse YAML frontmatter: {e}")
+            return None
+
     def _validate_agent_id(self, agent_id: str) -> None:
         """Validate agent ID format.
 
@@ -371,18 +401,26 @@ class AgentBuilderService:
         if template_id in self._template_cache:
             return self._template_cache[template_id].copy()
 
-        template_file = self.templates_dir / f"{template_id}.json"
+        # Agent templates migrated to Markdown with YAML frontmatter (v4.26.0+)
+        template_file = self.templates_dir / f"{template_id}.md"
 
         if not template_file.exists():
             raise AgentDeploymentError(f"Template '{template_id}' not found")
 
         try:
-            with open(template_file) as f:
-                config = json.load(f)
-                self._template_cache[template_id] = config
-                return config.copy()
+            # Read markdown content and extract YAML frontmatter
+            content = template_file.read_text()
+            config = self._extract_yaml_frontmatter(content)
+            if not config:
+                raise AgentDeploymentError(
+                    f"No YAML frontmatter in template '{template_id}'"
+                )
+            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 +444,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(