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

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -507,6 +507,7 @@ class MultiSourceAgentDeploymentService:
             "needs_update": [],
             "up_to_date": [],
             "new_agents": [],
+            "orphaned_agents": [],  # Agents without templates
             "version_upgrades": [],
             "version_downgrades": [],
             "source_changes": []
@@ -527,9 +528,11 @@ class MultiSourceAgentDeploymentService:
             # Read template version
             try:
                 template_data = json.loads(template_path.read_text())
+                metadata = template_data.get("metadata", {})
                 template_version = self.version_manager.parse_version(
                     template_data.get("agent_version") or 
-                    template_data.get("version", "0.0.0")
+                    template_data.get("version") or
+                    metadata.get("version", "0.0.0")
                 )
             except Exception as e:
                 self.logger.warning(f"Error reading template for '{agent_name}': {e}")
@@ -597,13 +600,20 @@ class MultiSourceAgentDeploymentService:
                     "source": agent_sources[agent_name]
                 })
         
+        # Check for orphaned agents (deployed but no template)
+        orphaned = self._detect_orphaned_agents_simple(deployed_agents_dir, agents_to_deploy)
+        comparison_results["orphaned_agents"] = orphaned
+        
         # Log summary
-        self.logger.info(
-            f"Version comparison complete: "
-            f"{len(comparison_results['needs_update'])} need updates, "
-            f"{len(comparison_results['up_to_date'])} up to date, "
+        summary_parts = [
+            f"{len(comparison_results['needs_update'])} need updates",
+            f"{len(comparison_results['up_to_date'])} up to date",
             f"{len(comparison_results['new_agents'])} new agents"
-        )
+        ]
+        if comparison_results["orphaned_agents"]:
+            summary_parts.append(f"{len(comparison_results['orphaned_agents'])} orphaned")
+        
+        self.logger.info(f"Version comparison complete: {', '.join(summary_parts)}")
         
         if comparison_results["version_upgrades"]:
             for upgrade in comparison_results["version_upgrades"]:
@@ -622,10 +632,24 @@ class MultiSourceAgentDeploymentService:
         
         if comparison_results["version_downgrades"]:
             for downgrade in comparison_results["version_downgrades"]:
-                self.logger.warning(
-                    f"  Warning: {downgrade['name']} deployed version "
+                # Changed from warning to debug - deployed versions higher than templates
+                # are not errors, just informational
+                self.logger.debug(
+                    f"  Note: {downgrade['name']} deployed version "
                     f"{downgrade['deployed_version']} is higher than template "
-                    f"{downgrade['template_version']}"
+                    f"{downgrade['template_version']} (keeping deployed version)"
+                )
+        
+        # Log orphaned agents if found
+        if comparison_results["orphaned_agents"]:
+            self.logger.info(
+                f"Found {len(comparison_results['orphaned_agents'])} orphaned agent(s) "
+                f"(deployed without templates):"
+            )
+            for orphan in comparison_results["orphaned_agents"]:
+                self.logger.info(
+                    f"  - {orphan['name']} v{orphan['version']} "
+                    f"(consider removing or creating a template)"
                 )
         
         return comparison_results
@@ -692,4 +716,177 @@ class MultiSourceAgentDeploymentService:
             return "system"
         
         # Complex names are more likely to be user/project agents
-        return "user"
+        return "user"
+    
+    def detect_orphaned_agents(
+        self, 
+        deployed_agents_dir: Path,
+        available_agents: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Detect deployed agents that don't have corresponding templates.
+        
+        WHY: Orphaned agents can cause confusion with version warnings.
+        This method identifies them so they can be handled appropriately.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            available_agents: Dictionary of available agents from all sources
+            
+        Returns:
+            List of orphaned agent information
+        """
+        orphaned = []
+        
+        if not deployed_agents_dir.exists():
+            return orphaned
+        
+        # Build a mapping of file stems to agent names for comparison
+        # Since available_agents uses display names like "Code Analysis Agent"
+        # but deployed files use stems like "code_analyzer"
+        available_stems = set()
+        stem_to_name = {}
+        
+        for agent_name, agent_sources in available_agents.items():
+            # Get the file path from the first source to extract the stem
+            if agent_sources and isinstance(agent_sources, list) and len(agent_sources) > 0:
+                first_source = agent_sources[0]
+                if 'file_path' in first_source:
+                    file_path = Path(first_source['file_path'])
+                    stem = file_path.stem
+                    available_stems.add(stem)
+                    stem_to_name[stem] = agent_name
+        
+        for deployed_file in deployed_agents_dir.glob("*.md"):
+            agent_stem = deployed_file.stem
+            
+            # Skip if this agent has a template (check by stem, not display name)
+            if agent_stem in available_stems:
+                continue
+            
+            # This is an orphaned agent
+            try:
+                deployed_content = deployed_file.read_text()
+                deployed_version, _, _ = self.version_manager.extract_version_from_frontmatter(
+                    deployed_content
+                )
+                version_str = self.version_manager.format_version_display(deployed_version)
+            except Exception:
+                version_str = "unknown"
+            
+            orphaned.append({
+                "name": agent_stem,
+                "file": str(deployed_file),
+                "version": version_str
+            })
+        
+        return orphaned
+    
+    def _detect_orphaned_agents_simple(
+        self, 
+        deployed_agents_dir: Path,
+        agents_to_deploy: Dict[str, Path]
+    ) -> List[Dict[str, Any]]:
+        """Simple orphan detection that works with agents_to_deploy structure.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            agents_to_deploy: Dictionary mapping file stems to template paths
+            
+        Returns:
+            List of orphaned agent information
+        """
+        orphaned = []
+        
+        if not deployed_agents_dir.exists():
+            return orphaned
+        
+        # agents_to_deploy already contains file stems as keys
+        available_stems = set(agents_to_deploy.keys())
+        
+        for deployed_file in deployed_agents_dir.glob("*.md"):
+            agent_stem = deployed_file.stem
+            
+            # Skip if this agent has a template (check by stem)
+            if agent_stem in available_stems:
+                continue
+            
+            # This is an orphaned agent
+            try:
+                deployed_content = deployed_file.read_text()
+                deployed_version, _, _ = self.version_manager.extract_version_from_frontmatter(
+                    deployed_content
+                )
+                version_str = self.version_manager.format_version_display(deployed_version)
+            except Exception:
+                version_str = "unknown"
+            
+            orphaned.append({
+                "name": agent_stem,
+                "file": str(deployed_file),
+                "version": version_str
+            })
+        
+        return orphaned
+    
+    def cleanup_orphaned_agents(
+        self,
+        deployed_agents_dir: Path,
+        dry_run: bool = True
+    ) -> Dict[str, Any]:
+        """Clean up orphaned agents that don't have templates.
+        
+        WHY: Orphaned agents can accumulate over time and cause confusion.
+        This method provides a way to clean them up systematically.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            dry_run: If True, only report what would be removed
+            
+        Returns:
+            Dictionary with cleanup results
+        """
+        results = {
+            "orphaned": [],
+            "removed": [],
+            "errors": []
+        }
+        
+        # First, discover all available agents from all sources
+        all_agents = self.discover_agents_from_all_sources()
+        available_names = set(all_agents.keys())
+        
+        # Detect orphaned agents
+        orphaned = self.detect_orphaned_agents(deployed_agents_dir, all_agents)
+        results["orphaned"] = orphaned
+        
+        if not orphaned:
+            self.logger.info("No orphaned agents found")
+            return results
+        
+        self.logger.info(f"Found {len(orphaned)} orphaned agent(s)")
+        
+        for orphan in orphaned:
+            agent_file = Path(orphan["file"])
+            
+            if dry_run:
+                self.logger.info(
+                    f"  Would remove: {orphan['name']} v{orphan['version']}"
+                )
+            else:
+                try:
+                    agent_file.unlink()
+                    results["removed"].append(orphan["name"])
+                    self.logger.info(
+                        f"  Removed: {orphan['name']} v{orphan['version']}"
+                    )
+                except Exception as e:
+                    error_msg = f"Failed to remove {orphan['name']}: {e}"
+                    results["errors"].append(error_msg)
+                    self.logger.error(f"  {error_msg}")
+        
+        if dry_run and orphaned:
+            self.logger.info(
+                "Run with dry_run=False to actually remove orphaned agents"
+            )
+        
+        return results

claude_mpm/services/event_bus/config.py

@@ -0,0 +1,165 @@
+"""Configuration for EventBus service.
+
+WHY configuration module:
+- Centralized configuration management
+- Environment variable support
+- Easy testing with different configurations
+- Runtime configuration changes
+"""
+
+import os
+from typing import List, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class EventBusConfig:
+    """Configuration for EventBus service.
+    
+    All settings can be overridden via environment variables.
+    """
+    
+    # Enable/disable the EventBus
+    enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_ENABLED", "true").lower() == "true"
+    )
+    
+    # Debug logging
+    debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_DEBUG", "false").lower() == "true"
+    )
+    
+    # Event history settings
+    max_history_size: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_EVENTBUS_HISTORY_SIZE", "100"))
+    )
+    
+    # Event filters (comma-separated list)
+    event_filters: List[str] = field(
+        default_factory=lambda: [
+            f.strip() for f in os.environ.get("CLAUDE_MPM_EVENTBUS_FILTERS", "").split(",") 
+            if f.strip()
+        ]
+    )
+    
+    # Relay configuration
+    relay_enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_ENABLED", "true").lower() == "true"
+    )
+    
+    relay_port: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
+    )
+    
+    relay_debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_DEBUG", "false").lower() == "true"
+    )
+    
+    # Connection settings
+    relay_max_retries: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_RELAY_MAX_RETRIES", "3"))
+    )
+    
+    relay_retry_delay: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_RETRY_DELAY", "0.5"))
+    )
+    
+    relay_connection_cooldown: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_CONNECTION_COOLDOWN", "5.0"))
+    )
+    
+    @classmethod
+    def from_env(cls) -> "EventBusConfig":
+        """Create configuration from environment variables.
+        
+        Returns:
+            EventBusConfig: Configuration instance
+        """
+        return cls()
+    
+    def to_dict(self) -> dict:
+        """Convert configuration to dictionary.
+        
+        Returns:
+            dict: Configuration as dictionary
+        """
+        return {
+            "enabled": self.enabled,
+            "debug": self.debug,
+            "max_history_size": self.max_history_size,
+            "event_filters": self.event_filters,
+            "relay_enabled": self.relay_enabled,
+            "relay_port": self.relay_port,
+            "relay_debug": self.relay_debug,
+            "relay_max_retries": self.relay_max_retries,
+            "relay_retry_delay": self.relay_retry_delay,
+            "relay_connection_cooldown": self.relay_connection_cooldown
+        }
+    
+    def apply_to_eventbus(self, event_bus) -> None:
+        """Apply configuration to an EventBus instance.
+        
+        Args:
+            event_bus: EventBus instance to configure
+        """
+        if not self.enabled:
+            event_bus.disable()
+        else:
+            event_bus.enable()
+        
+        event_bus.set_debug(self.debug)
+        event_bus._max_history_size = self.max_history_size
+        
+        # Apply filters
+        event_bus.clear_filters()
+        for filter_pattern in self.event_filters:
+            event_bus.add_filter(filter_pattern)
+    
+    def apply_to_relay(self, relay) -> None:
+        """Apply configuration to a SocketIORelay instance.
+        
+        Args:
+            relay: SocketIORelay instance to configure
+        """
+        if not self.relay_enabled:
+            relay.disable()
+        else:
+            relay.enable()
+        
+        relay.port = self.relay_port
+        relay.debug = self.relay_debug
+        relay.max_retries = self.relay_max_retries
+        relay.retry_delay = self.relay_retry_delay
+        relay.connection_cooldown = self.relay_connection_cooldown
+
+
+# Global configuration instance
+_config: Optional[EventBusConfig] = None
+
+
+def get_config() -> EventBusConfig:
+    """Get the global EventBus configuration.
+    
+    Returns:
+        EventBusConfig: Configuration instance
+    """
+    global _config
+    if _config is None:
+        _config = EventBusConfig.from_env()
+    return _config
+
+
+def set_config(config: EventBusConfig) -> None:
+    """Set the global EventBus configuration.
+    
+    Args:
+        config: Configuration to set
+    """
+    global _config
+    _config = config
+
+
+def reset_config() -> None:
+    """Reset configuration to defaults from environment."""
+    global _config
+    _config = EventBusConfig.from_env()

claude_mpm/services/event_bus/event_bus.py

@@ -13,7 +13,7 @@ import logging
 import threading
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Set
-from pyee import AsyncIOEventEmitter
+from pyee.asyncio import AsyncIOEventEmitter
 
 # Configure logger
 logger = logging.getLogger(__name__)
@@ -176,9 +176,33 @@ class EventBus:
             # Record event in history
             self._record_event(event_type, data)
             
-            # Emit event (pyee handles thread safety)
+            # Emit event to regular handlers (pyee handles thread safety)
             self._emitter.emit(event_type, data)
             
+            # Also emit to wildcard handlers
+            if hasattr(self, '_wildcard_handlers'):
+                for prefix, handlers in self._wildcard_handlers.items():
+                    if event_type.startswith(prefix):
+                        for handler in handlers:
+                            try:
+                                # Call with event_type and data for wildcard handlers
+                                if asyncio.iscoroutinefunction(handler):
+                                    # Schedule async handlers
+                                    try:
+                                        loop = asyncio.get_event_loop()
+                                        if loop.is_running():
+                                            asyncio.create_task(handler(event_type, data))
+                                        else:
+                                            loop.run_until_complete(handler(event_type, data))
+                                    except RuntimeError:
+                                        # No event loop, skip async handler
+                                        pass
+                                else:
+                                    handler(event_type, data)
+                            except Exception as e:
+                                if self._debug:
+                                    logger.debug(f"Wildcard handler error: {e}")
+            
             # Update stats
             self._stats["events_published"] += 1
             self._stats["last_event_time"] = datetime.now().isoformat()
@@ -217,29 +241,20 @@ class EventBus:
             handler: The handler function
         """
         if event_type.endswith("*"):
-            # Register for wildcard pattern
-            prefix = event_type[:-1]
+            # Store wildcard handlers separately
+            if not hasattr(self, '_wildcard_handlers'):
+                self._wildcard_handlers = {}
             
-            # Create a wrapper that checks event names
-            def wildcard_wrapper(actual_event_type: str):
-                def wrapper(data):
-                    if actual_event_type.startswith(prefix):
-                        if asyncio.iscoroutinefunction(handler):
-                            return handler(actual_event_type, data)
-                        else:
-                            handler(actual_event_type, data)
-                return wrapper
+            prefix = event_type[:-1]
+            if prefix not in self._wildcard_handlers:
+                self._wildcard_handlers[prefix] = []
+            self._wildcard_handlers[prefix].append(handler)
             
-            # Register for all possible events (we'll filter in the wrapper)
-            # For now, register common prefixes
-            for common_event in ["hook", "socketio", "system", "agent"]:
-                if common_event.startswith(prefix) or prefix.startswith(common_event):
-                    self._emitter.on(f"{common_event}.*", wildcard_wrapper(f"{common_event}.*"))
+            logger.debug(f"Registered wildcard handler for: {event_type}")
         else:
             # Regular event registration
             self._emitter.on(event_type, handler)
-        
-        logger.debug(f"Registered handler for: {event_type}")
+            logger.debug(f"Registered handler for: {event_type}")
     
     def once(self, event_type: str, handler: Callable) -> None:
         """Register a one-time event handler.

claude_mpm/services/event_bus/relay.py

@@ -106,20 +106,21 @@ class SocketIORelay:
         self.last_connection_attempt = current_time
         
         try:
-            # Create new client
+            # Create new client with better connection settings
             self.client = socketio.Client(
                 reconnection=True,
-                reconnection_attempts=3,
-                reconnection_delay=1,
+                reconnection_attempts=5,
+                reconnection_delay=2,
+                reconnection_delay_max=10,
                 logger=False,
                 engineio_logger=False
             )
             
-            # Connect to server
+            # Connect to server with longer timeout
             self.client.connect(
                 f"http://localhost:{self.port}",
                 wait=True,
-                wait_timeout=2.0,
+                wait_timeout=10.0,  # Increase timeout for stability
                 transports=['websocket', 'polling']
             )
             
@@ -219,15 +220,10 @@ class SocketIORelay:
             if event_type.startswith("hook."):
                 await self.relay_event(event_type, data)
         
-        # Subscribe to all hook events
+        # Subscribe to all hook events via wildcard
+        # This will catch ALL hook.* events
         self.event_bus.on("hook.*", handle_hook_event)
         
-        # Also subscribe to specific high-priority events
-        for event in ["hook.pre_tool", "hook.post_tool", "hook.subagent_stop", 
-                      "hook.user_prompt", "hook.assistant_response"]:
-            self.event_bus.on(event, lambda data, evt=event: 
-                             asyncio.create_task(self.relay_event(evt, data)))
-        
         logger.info("SocketIO relay started and subscribed to events")
     
     def stop(self) -> None: