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

claude_mpm/services/socketio/server/core.py

@@ -31,6 +31,9 @@ except ImportError:
     aiohttp = None
     web = None
 
+# Import VersionService for dynamic version retrieval
+from claude_mpm.services.version_service import VersionService
+
 from ....core.constants import (
     NetworkConfig,
     PerformanceConfig,
@@ -158,11 +161,14 @@ class SocketIOServerCore:
     async def _start_server(self):
         """Start the Socket.IO server with aiohttp."""
         try:
-            # Create Socket.IO server
+            # Create Socket.IO server with proper ping/pong configuration
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
                 logger=False,  # Disable Socket.IO's own logging
                 engineio_logger=False,
+                ping_interval=25,  # Send ping every 25 seconds
+                ping_timeout=60,   # Wait 60 seconds for pong response
+                max_http_buffer_size=1e8,  # 100MB max buffer
             )
 
             # Create aiohttp application
@@ -255,6 +261,23 @@ class SocketIOServerCore:
                         return web.Response(text="Dashboard not available", status=404)
 
                 self.app.router.add_get("/", index_handler)
+                
+                # Serve version.json from dashboard directory
+                async def version_handler(request):
+                    version_file = self.dashboard_path / "version.json"
+                    if version_file.exists():
+                        self.logger.debug(f"Serving version.json from: {version_file}")
+                        return web.FileResponse(version_file)
+                    else:
+                        # Return default version info if file doesn't exist
+                        return web.json_response({
+                            "version": "1.0.0",
+                            "build": 1,
+                            "formatted_build": "0001",
+                            "full_version": "v1.0.0-0001"
+                        })
+                
+                self.app.router.add_get("/version.json", version_handler)
 
                 # Serve static assets (CSS, JS) from the dashboard static directory
                 dashboard_static_path = (
@@ -414,18 +437,19 @@ class SocketIOServerCore:
                     except Exception as e:
                         self.logger.debug(f"Could not get active sessions: {e}")
                 
-                # Prepare heartbeat data
+                # Prepare heartbeat data (using new schema)
                 heartbeat_data = {
                     "type": "system",
-                    "event": "heartbeat",
+                    "subtype": "heartbeat",
                     "timestamp": datetime.now().isoformat(),
+                    "source": "server",
                     "data": {
                         "uptime_seconds": uptime_seconds,
                         "connected_clients": len(self.connected_clients),
                         "total_events": self.stats.get("events_sent", 0),
                         "active_sessions": active_sessions,
                         "server_info": {
-                            "version": "4.0.2",
+                            "version": VersionService().get_version(),
                             "port": self.port,
                         },
                     },
@@ -435,7 +459,7 @@ class SocketIOServerCore:
                 if self.main_server and hasattr(self.main_server, 'event_history'):
                     self.main_server.event_history.append(heartbeat_data)
                 
-                # Emit heartbeat to all connected clients
+                # Emit heartbeat to all connected clients (already using new schema)
                 await self.sio.emit("system_event", heartbeat_data)
                 
                 self.logger.info(

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -0,0 +1,189 @@
+"""EventBus integration for Socket.IO server.
+
+WHY this integration module:
+- Adds EventBus relay to Socket.IO server without modifying core
+- Maintains backward compatibility with existing server
+- Easy to enable/disable via configuration
+- Provides clean separation of concerns
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from claude_mpm.services.event_bus import EventBus, SocketIORelay
+from claude_mpm.services.event_bus.config import get_config
+
+logger = logging.getLogger(__name__)
+
+
+class EventBusIntegration:
+    """Integrates EventBus relay with Socket.IO server.
+    
+    WHY integration class:
+    - Encapsulates EventBus setup and teardown
+    - Provides lifecycle management for relay
+    - Handles configuration and error cases
+    - Can be easily added to existing server
+    """
+    
+    def __init__(self, server_instance=None):
+        """Initialize EventBus integration.
+        
+        Args:
+            server_instance: Optional Socket.IO server instance
+        """
+        self.server = server_instance
+        self.relay: Optional[SocketIORelay] = None
+        self.event_bus: Optional[EventBus] = None
+        self.config = get_config()
+        self.enabled = self.config.enabled and self.config.relay_enabled
+        
+    def setup(self, port: Optional[int] = None) -> bool:
+        """Set up EventBus and relay.
+        
+        Args:
+            port: Optional Socket.IO server port
+            
+        Returns:
+            bool: True if setup successful
+        """
+        if not self.enabled:
+            logger.info("EventBus integration disabled by configuration")
+            return False
+        
+        try:
+            # Get EventBus instance
+            self.event_bus = EventBus.get_instance()
+            
+            # Apply configuration
+            self.config.apply_to_eventbus(self.event_bus)
+            
+            # Create and configure relay
+            relay_port = port or self.config.relay_port
+            self.relay = SocketIORelay(relay_port)
+            self.config.apply_to_relay(self.relay)
+            
+            # Start the relay
+            self.relay.start()
+            
+            logger.info(f"EventBus integration setup complete (port: {relay_port})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to setup EventBus integration: {e}")
+            self.enabled = False
+            return False
+    
+    def teardown(self) -> None:
+        """Tear down EventBus integration."""
+        if self.relay:
+            try:
+                self.relay.stop()
+                logger.info("EventBus relay stopped")
+            except Exception as e:
+                logger.error(f"Error stopping relay: {e}")
+            finally:
+                self.relay = None
+    
+    def is_active(self) -> bool:
+        """Check if integration is active.
+        
+        Returns:
+            bool: True if relay is active and connected
+        """
+        return (
+            self.enabled and 
+            self.relay is not None and 
+            self.relay.enabled
+        )
+    
+    def get_stats(self) -> dict:
+        """Get integration statistics.
+        
+        Returns:
+            dict: Combined stats from EventBus and relay
+        """
+        stats = {
+            "enabled": self.enabled,
+            "active": self.is_active()
+        }
+        
+        if self.event_bus:
+            stats["eventbus"] = self.event_bus.get_stats()
+        
+        if self.relay:
+            stats["relay"] = self.relay.get_stats()
+        
+        return stats
+
+
+def integrate_with_server(server_instance, port: Optional[int] = None) -> EventBusIntegration:
+    """Helper function to integrate EventBus with a Socket.IO server.
+    
+    Args:
+        server_instance: Socket.IO server instance
+        port: Optional server port
+        
+    Returns:
+        EventBusIntegration: The integration instance
+    """
+    integration = EventBusIntegration(server_instance)
+    integration.setup(port or getattr(server_instance, 'port', 8765))
+    return integration
+
+
+# Monkey-patch helper for existing server
+def patch_socketio_server(server_class):
+    """Monkey-patch an existing Socket.IO server class to add EventBus.
+    
+    WHY monkey-patching:
+    - Allows integration without modifying existing code
+    - Can be applied selectively based on configuration
+    - Easy to remove or disable
+    
+    Args:
+        server_class: The server class to patch
+    """
+    original_init = server_class.__init__
+    original_start = getattr(server_class, 'start_sync', None) or getattr(server_class, 'start', None)
+    original_stop = getattr(server_class, 'stop_sync', None) or getattr(server_class, 'stop', None)
+    
+    def patched_init(self, *args, **kwargs):
+        """Patched __init__ that adds EventBus integration."""
+        original_init(self, *args, **kwargs)
+        self._eventbus_integration = EventBusIntegration(self)
+    
+    def patched_start(self, *args, **kwargs):
+        """Patched start method that sets up EventBus."""
+        # Call original start
+        if original_start:
+            result = original_start(self, *args, **kwargs)
+        else:
+            result = None
+        
+        # Setup EventBus integration
+        if hasattr(self, '_eventbus_integration'):
+            port = getattr(self, 'port', 8765)
+            self._eventbus_integration.setup(port)
+        
+        return result
+    
+    def patched_stop(self, *args, **kwargs):
+        """Patched stop method that tears down EventBus."""
+        # Teardown EventBus first
+        if hasattr(self, '_eventbus_integration'):
+            self._eventbus_integration.teardown()
+        
+        # Call original stop
+        if original_stop:
+            return original_stop(self, *args, **kwargs)
+    
+    # Apply patches
+    server_class.__init__ = patched_init
+    if original_start:
+        setattr(server_class, 'start_sync' if hasattr(server_class, 'start_sync') else 'start', patched_start)
+    if original_stop:
+        setattr(server_class, 'stop_sync' if hasattr(server_class, 'stop_sync') else 'stop', patched_stop)
+    
+    logger.info(f"Patched {server_class.__name__} with EventBus integration")

claude_mpm/services/socketio/server/main.py

@@ -43,6 +43,7 @@ from ...exceptions import SocketIOServerError as MPMConnectionError
 from ..handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler
 from .broadcaster import SocketIOEventBroadcaster
 from .core import SocketIOServerCore
+from .eventbus_integration import EventBusIntegration
 
 
 class SocketIOServer(SocketIOServiceInterface):
@@ -93,6 +94,9 @@ class SocketIOServer(SocketIOServiceInterface):
         
         # Active session tracking for heartbeat
         self.active_sessions: Dict[str, Dict[str, Any]] = {}
+        
+        # EventBus integration
+        self.eventbus_integration = None
 
     def start_sync(self):
         """Start the Socket.IO server in a background thread (synchronous version)."""
@@ -144,6 +148,19 @@ class SocketIOServer(SocketIOServiceInterface):
 
         # Register events
         self._register_events()
+        
+        # Setup EventBus integration
+        # WHY: This connects the EventBus to the Socket.IO server, allowing
+        # events from other parts of the system to be broadcast to dashboard
+        try:
+            self.eventbus_integration = EventBusIntegration(self)
+            if self.eventbus_integration.setup(self.port):
+                self.logger.info("EventBus integration setup successful")
+            else:
+                self.logger.warning("EventBus integration setup failed or disabled")
+        except Exception as e:
+            self.logger.error(f"Failed to setup EventBus integration: {e}")
+            self.eventbus_integration = None
 
         # Update running state
         self.running = self.core.running
@@ -159,6 +176,14 @@ class SocketIOServer(SocketIOServiceInterface):
         if self.broadcaster:
             self.broadcaster.stop_retry_processor()
         
+        # Teardown EventBus integration
+        if self.eventbus_integration:
+            try:
+                self.eventbus_integration.teardown()
+                self.logger.info("EventBus integration teardown complete")
+            except Exception as e:
+                self.logger.error(f"Error during EventBus teardown: {e}")
+        
         # Stop health monitoring in connection handler
         if self.event_registry:
             from ..handlers import ConnectionEventHandler

{claude_mpm-4.0.32.dist-info → claude_mpm-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.32
+Version: 4.1.0
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team
@@ -46,6 +46,7 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pyee>=13.0.0
 Requires-Dist: importlib-resources>=5.0; python_version < "3.9"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -53,6 +54,11 @@ Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
+Requires-Dist: flake8-import-order; extra == "dev"
+Requires-Dist: flake8-tidy-imports; extra == "dev"
+Requires-Dist: flake8-bugbear; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pylint>=3.0.0; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
@@ -116,7 +122,7 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 ## Features
 
 - 🤖 **Multi-Agent System**: 15 specialized agents for comprehensive project management
-- 🧠 **Agent Memory System**: Persistent learning with project-specific knowledge retention
+- 🧠 **Agent Memory System**: Simple list-based persistent learning with JSON response field updates
 - 🔄 **Session Management**: Resume previous sessions with `--resume` 
 - 📊 **Real-Time Monitoring**: Live dashboard with `--monitor` flag
 - 🔌 **MCP Gateway**: Model Context Protocol integration for extensible tool capabilities
@@ -132,6 +138,13 @@ A powerful orchestration framework for Claude Code that enables multi-agent work
 pip install claude-mpm
 ```
 
+Or with pipx (recommended for isolated installation):
+```bash
+pipx install claude-mpm
+# Configure MCP for pipx users:
+claude-mpm mcp-pipx-config
+```
+
 **That's it!** See [QUICKSTART.md](QUICKSTART.md) for immediate usage or [docs/user/installation.md](docs/user/installation.md) for advanced options.
 
 ## Quick Usage
@@ -156,15 +169,17 @@ claude-mpm cleanup-memory
 See [QUICKSTART.md](QUICKSTART.md) for complete usage examples.
 
 
-## Architecture (v3.8.2+)
+## Architecture (v4.1.0+)
 
-Following the TSK-0053 refactoring, Claude MPM features:
+Following continuous improvements through v4.1.0, Claude MPM features:
 
-- **Service-Oriented Architecture**: Five specialized service domains
+- **Service-Oriented Architecture**: Five specialized service domains with Socket.IO stability improvements
 - **Interface-Based Contracts**: All services implement explicit interfaces
 - **Dependency Injection**: Service container with automatic resolution
 - **50-80% Performance Improvement**: Through lazy loading and intelligent caching
 - **Enhanced Security**: Comprehensive input validation and sanitization framework
+- **Improved Monitoring**: Enhanced dashboard with hierarchical agent display
+- **Socket.IO Stability**: Major reliability improvements for real-time communication
 
 See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for detailed architecture information.
 
@@ -200,7 +215,7 @@ Claude MPM includes 15 specialized agents:
 - **Code Analyzer** - Static code analysis with AST and tree-sitter
 
 ### Agent Memory System
-Agents learn project-specific patterns and remember insights across sessions. Initialize with `claude-mpm memory init`.
+Agents learn project-specific patterns using a simple list format and can update memories via JSON response fields (`remember` for incremental updates, `MEMORIES` for complete replacement). Initialize with `claude-mpm memory init`.
 
 ### MCP Gateway (Model Context Protocol)
 
@@ -253,11 +268,15 @@ See [docs/MEMORY.md](docs/MEMORY.md) and [docs/developer/11-dashboard/README.md]
 ### API Documentation
 Comprehensive API documentation is available at [docs/api/](docs/api/) - build with `make html` in that directory.
 
-## Recent Updates (v3.8.2)
+## Recent Updates (v4.1.0)
+
+**Socket.IO Stability Improvements**: Major reliability enhancements for real-time communication with improved error handling and connection management.
+
+**Project Organization**: Comprehensive cleanup and reorganization with structured script directories for better maintainability.
 
-**Major Architecture Refactoring (TSK-0053)**: Complete service-oriented redesign with 50-80% performance improvements, enhanced security, and interface-based design.
+**Documentation Consolidation**: Streamlined documentation structure with consolidated guides and improved navigation.
 
-**Process Management Improvements**: Enhanced hook system reliability with automatic process cleanup, timeout protection, and orphan process monitoring to prevent resource leaks.
+**Agent Hierarchy Display**: Enhanced dashboard with hierarchical agent display showing PM at top level with visual distinction for implied vs explicit nodes.
 
 See [CHANGELOG.md](CHANGELOG.md) for full history and [docs/MIGRATION.md](docs/MIGRATION.md) for upgrade instructions.