claude-mpm 3.2.1__py3-none-any.whl → 3.3.2__py3-none-any.whl

claude_mpm/scripts/launch_socketio_dashboard.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""Socket.IO Dashboard Launcher for Claude MPM.
+
+WHY: This script provides a streamlined solution for launching the Socket.IO
+monitoring dashboard using only the Python Socket.IO server implementation.
+It handles server startup, dashboard creation, and browser opening.
+
+DESIGN DECISION: Uses only python-socketio and aiohttp for a clean,
+Node.js-free implementation. This simplifies deployment and reduces
+dependencies while maintaining full functionality.
+
+The script handles:
+1. Python Socket.IO server startup
+2. Dashboard HTML creation and serving
+3. Browser opening with proper URL construction
+4. Background/daemon mode operation
+5. Graceful error handling and user feedback
+"""
+
+import argparse
+import os
+import sys
+import time
+import webbrowser
+import signal
+from pathlib import Path
+from typing import Optional
+
+# Get script directory for relative paths  
+SCRIPT_DIR = Path(__file__).parent
+PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent  # Go up to project root from src/claude_mpm/scripts/
+
+def check_python_dependencies() -> bool:
+    """Check if Python Socket.IO dependencies are available.
+    
+    WHY: We need python-socketio and aiohttp packages for the server.
+    This function validates the environment and provides clear feedback.
+    
+    Returns:
+        bool: True if Python dependencies are ready, False otherwise
+    """
+    try:
+        import socketio
+        import aiohttp
+        socketio_version = getattr(socketio, '__version__', 'unknown')
+        aiohttp_version = getattr(aiohttp, '__version__', 'unknown')
+        print(f"✓ python-socketio v{socketio_version} detected")
+        print(f"✓ aiohttp v{aiohttp_version} detected")
+        return True
+    except ImportError as e:
+        print(f"❌ Required Python packages missing: {e}")
+        print("   Install with: pip install python-socketio aiohttp")
+        return False
+
+
+
+def check_dashboard_availability(port: int):
+    """Check if the modular dashboard is available.
+    
+    WHY: The new architecture uses a modular dashboard served by the Socket.IO server
+    instead of creating static HTML files. This validates the proper dashboard exists.
+    
+    Args:
+        port: Port number for the Socket.IO server
+    """
+    # Check if new modular dashboard is available
+    web_templates_dir = PROJECT_ROOT / "src" / "claude_mpm" / "web" / "templates"
+    modular_dashboard = web_templates_dir / "index.html"
+    if modular_dashboard.exists():
+        print(f"✓ Modular dashboard found at {modular_dashboard}")
+        return True
+    else:
+        print(f"⚠️  Modular dashboard not found at {modular_dashboard}")
+        print(f"   Expected path: {modular_dashboard}")
+        return False
+
+def check_server_running(port: int) -> bool:
+    """Check if a Socket.IO server is already running on the specified port.
+    
+    WHY: We want to avoid starting multiple servers on the same port
+    and provide clear feedback to users about existing servers.
+    
+    Args:
+        port: Port number to check
+        
+    Returns:
+        bool: True if server is running, False otherwise
+    """
+    try:
+        import socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            result = s.connect_ex(('127.0.0.1', port))
+            if result == 0:
+                print(f"✓ Socket.IO server already running on port {port}")
+                return True
+    except Exception:
+        pass
+    
+    return False
+
+def start_python_server(port: int, daemon: bool = False) -> Optional:
+    """Start the Python Socket.IO server.
+    
+    WHY: Uses python-socketio and aiohttp for a clean, Node.js-free
+    implementation that handles all Socket.IO functionality.
+    
+    Args:
+        port: Port number for the server
+        daemon: Whether to run in background mode
+        
+    Returns:
+        Thread object if successful, None otherwise
+    """
+    try:
+        # Import the existing Python Socket.IO server
+        sys.path.insert(0, str(PROJECT_ROOT / "src"))
+        from claude_mpm.services.socketio_server import SocketIOServer
+        
+        server = SocketIOServer(port=port)
+        
+        if daemon:
+            # Start in background thread
+            server.start()
+            print(f"🚀 Python Socket.IO server started on port {port}")
+            return server.thread
+        else:
+            # Start and block
+            print(f"🚀 Starting Python Socket.IO server on port {port}")
+            server.start()
+            
+            # Keep alive until interrupted
+            try:
+                while server.running:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("\\n🛑 Shutting down Python server...")
+                server.stop()
+            
+            return None
+            
+    except Exception as e:
+        print(f"❌ Failed to start Python server: {e}")
+        return None
+
+def open_dashboard(port: int, no_browser: bool = False):
+    """Open the Socket.IO dashboard in browser.
+    
+    WHY: Users need easy access to the monitoring dashboard. This function
+    handles URL construction and browser opening with fallback options.
+    Now uses the new modular dashboard location.
+    
+    Args:
+        port: Port number for the Socket.IO server
+        no_browser: Skip browser opening if True
+    """
+    if no_browser:
+        print(f"📊 Dashboard available at: http://localhost:{port}/dashboard")
+        return
+    
+    dashboard_url = f"http://localhost:{port}/dashboard?autoconnect=true&port={port}"
+    
+    try:
+        print(f"🌐 Opening dashboard: {dashboard_url}")
+        webbrowser.open(dashboard_url)
+        
+    except Exception as e:
+        print(f"⚠️  Failed to open browser automatically: {e}")
+        print(f"📊 Dashboard: {dashboard_url}")
+
+def cleanup_handler(signum, frame):
+    """Handle cleanup on shutdown signals.
+    
+    WHY: Proper cleanup ensures sockets are closed and resources freed
+    when the script is terminated.
+    """
+    print("\\n🛑 Shutting down Socket.IO launcher...")
+    sys.exit(0)
+
+def main():
+    """Main entry point for the Socket.IO dashboard launcher.
+    
+    WHY: This orchestrates the entire launch process, from dependency checking
+    to server startup and dashboard opening, with comprehensive error handling.
+    """
+    parser = argparse.ArgumentParser(
+        description="Launch Socket.IO dashboard for Claude MPM monitoring",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  python launch_socketio_dashboard.py                    # Start with default settings
+  python launch_socketio_dashboard.py --port 3000       # Use specific port
+  python launch_socketio_dashboard.py --daemon          # Run in background
+  python launch_socketio_dashboard.py --no-browser      # Don't open browser
+  python launch_socketio_dashboard.py --setup-only      # Just create files
+        '''
+    )
+    
+    parser.add_argument('--port', type=int, default=3000,
+                       help='Socket.IO server port (default: 3000)')
+    parser.add_argument('--daemon', action='store_true',
+                       help='Run server in background mode')
+    parser.add_argument('--no-browser', action='store_true',
+                       help='Skip opening browser automatically')
+    parser.add_argument('--setup-only', action='store_true',
+                       help='Create necessary files without starting server')
+    
+    args = parser.parse_args()
+    
+    # Setup signal handlers
+    signal.signal(signal.SIGINT, cleanup_handler)
+    signal.signal(signal.SIGTERM, cleanup_handler)
+    
+    print("🚀 Claude MPM Socket.IO Dashboard Launcher")
+    print("=" * 50)
+    
+    # Check dashboard availability (modular dashboard)
+    check_dashboard_availability(args.port)
+    
+    if args.setup_only:
+        # Just setup files, don't start server
+        print("📁 Setup complete - files created")
+        return
+    
+    # Check if server is already running
+    if check_server_running(args.port):
+        print(f"✅ Using existing server on port {args.port}")
+        open_dashboard(args.port, args.no_browser)
+        return
+    
+    # Check Python dependencies
+    if not check_python_dependencies():
+        print("❌ Required Python packages not available")
+        sys.exit(1)
+    
+    # Start Python Socket.IO server
+    print("🟢 Using Python Socket.IO server")
+    
+    try:
+        server_thread = start_python_server(args.port, args.daemon)
+        
+        if server_thread or not args.daemon:
+            # Server started or is starting
+            time.sleep(2)  # Give server time to start
+            open_dashboard(args.port, args.no_browser)
+            
+            if args.daemon and server_thread:
+                print(f"🔄 Python server running in background")
+                print(f"   Dashboard: http://localhost:{args.port}/dashboard")
+        else:
+            print("❌ Failed to start Socket.IO server")
+            sys.exit(1)
+            
+    except KeyboardInterrupt:
+        print("\\n✅ Socket.IO launcher stopped")
+    except Exception as e:
+        print(f"❌ Launcher error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

claude_mpm/services/agent_memory_manager.py

@@ -27,7 +27,7 @@ import logging
 from claude_mpm.core import LoggerMixin
 from claude_mpm.core.config import Config
 from claude_mpm.utils.paths import PathResolver
-from claude_mpm.services.websocket_server import get_websocket_server
+# Socket.IO notifications are optional - we'll skip them if server is not available
 
 
 class AgentMemoryManager(LoggerMixin):
@@ -164,15 +164,7 @@ class AgentMemoryManager(LoggerMixin):
         try:
             content = memory_file.read_text(encoding='utf-8')
             
-            # Emit WebSocket event for memory loaded
-            try:
-                ws_server = get_websocket_server()
-                file_size = len(content.encode('utf-8'))
-                # Count sections by looking for lines starting with ##
-                sections_count = sum(1 for line in content.split('\n') if line.startswith('## '))
-                ws_server.memory_loaded(agent_id, file_size, sections_count)
-            except Exception as ws_error:
-                self.logger.debug(f"WebSocket notification failed: {ws_error}")
+            # Socket.IO notifications removed - memory manager works independently
             
             return self._validate_and_repair(content, agent_id)
         except Exception as e:
@@ -241,13 +233,7 @@ class AgentMemoryManager(LoggerMixin):
         section = section_mapping.get(learning_type, 'Recent Learnings')
         success = self.update_agent_memory(agent_id, section, content)
         
-        # Emit WebSocket event for memory updated
-        if success:
-            try:
-                ws_server = get_websocket_server()
-                ws_server.memory_updated(agent_id, learning_type, content, section)
-            except Exception as ws_error:
-                self.logger.debug(f"WebSocket notification failed: {ws_error}")
+        # Socket.IO notifications removed - memory manager works independently
         
         return success
     
@@ -323,12 +309,7 @@ class AgentMemoryManager(LoggerMixin):
             memory_file.write_text(template, encoding='utf-8')
             self.logger.info(f"Created default memory file for {agent_id}")
             
-            # Emit WebSocket event for memory created
-            try:
-                ws_server = get_websocket_server()
-                ws_server.memory_created(agent_id, "default")
-            except Exception as ws_error:
-                self.logger.debug(f"WebSocket notification failed: {ws_error}")
+            # Socket.IO notifications removed - memory manager works independently
         except Exception as e:
             self.logger.error(f"Error saving default memory for {agent_id}: {e}")
         
@@ -609,6 +590,266 @@ class AgentMemoryManager(LoggerMixin):
             self.logger.error(f"Error saving memory for {agent_id}: {e}")
             return False
     
+    def optimize_memory(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """Optimize agent memory by consolidating/cleaning memories.
+        
+        WHY: Over time, memory files accumulate redundant or outdated information.
+        This method delegates to the memory optimizer service to clean up and
+        consolidate memories while preserving important information.
+        
+        Args:
+            agent_id: Optional specific agent ID. If None, optimizes all agents.
+            
+        Returns:
+            Dict containing optimization results and statistics
+        """
+        try:
+            from claude_mpm.services.memory_optimizer import MemoryOptimizer
+            optimizer = MemoryOptimizer(self.config)
+            
+            if agent_id:
+                result = optimizer.optimize_agent_memory(agent_id)
+                self.logger.info(f"Optimized memory for agent: {agent_id}")
+            else:
+                result = optimizer.optimize_all_memories()
+                self.logger.info("Optimized all agent memories")
+            
+            return result
+        except Exception as e:
+            self.logger.error(f"Error optimizing memory: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def build_memories_from_docs(self, force_rebuild: bool = False) -> Dict[str, Any]:
+        """Build agent memories from project documentation.
+        
+        WHY: Project documentation contains valuable knowledge that should be
+        extracted and assigned to appropriate agents for better context awareness.
+        
+        Args:
+            force_rebuild: If True, rebuilds even if docs haven't changed
+            
+        Returns:
+            Dict containing build results and statistics
+        """
+        try:
+            from claude_mpm.services.memory_builder import MemoryBuilder
+            builder = MemoryBuilder(self.config)
+            
+            result = builder.build_from_documentation(force_rebuild)
+            self.logger.info("Built memories from documentation")
+            
+            return result
+        except Exception as e:
+            self.logger.error(f"Error building memories from docs: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def route_memory_command(self, content: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """Route memory command to appropriate agent via PM delegation.
+        
+        WHY: Memory commands like "remember this for next time" need to be analyzed
+        to determine which agent should store the information. This method provides
+        routing logic for PM agent delegation.
+        
+        Args:
+            content: The content to be remembered
+            context: Optional context for routing decisions
+            
+        Returns:
+            Dict containing routing decision and reasoning
+        """
+        try:
+            from claude_mpm.services.memory_router import MemoryRouter
+            router = MemoryRouter(self.config)
+            
+            routing_result = router.analyze_and_route(content, context)
+            self.logger.debug(f"Routed memory command: {routing_result['target_agent']}")
+            
+            return routing_result
+        except Exception as e:
+            self.logger.error(f"Error routing memory command: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def get_memory_status(self) -> Dict[str, Any]:
+        """Get comprehensive memory system status.
+        
+        WHY: Provides detailed overview of memory system health, file sizes,
+        optimization opportunities, and agent-specific statistics for monitoring
+        and maintenance purposes.
+        
+        Returns:
+            Dict containing comprehensive memory system status
+        """
+        try:
+            status = {
+                "system_enabled": self.memory_enabled,
+                "auto_learning": self.auto_learning,
+                "memory_directory": str(self.memories_dir),
+                "total_agents": 0,
+                "total_size_kb": 0,
+                "agents": {},
+                "optimization_opportunities": [],
+                "system_health": "healthy"
+            }
+            
+            if not self.memories_dir.exists():
+                status["system_health"] = "no_memory_dir"
+                return status
+            
+            memory_files = list(self.memories_dir.glob("*_agent.md"))
+            status["total_agents"] = len(memory_files)
+            
+            total_size = 0
+            for file_path in memory_files:
+                stat = file_path.stat()
+                size_kb = stat.st_size / 1024
+                total_size += stat.st_size
+                
+                agent_id = file_path.stem.replace('_agent', '')
+                limits = self._get_agent_limits(agent_id)
+                
+                # Analyze file content
+                try:
+                    content = file_path.read_text()
+                    section_count = len([line for line in content.splitlines() if line.startswith('## ')])
+                    learning_count = len([line for line in content.splitlines() if line.strip().startswith('- ')])
+                    
+                    agent_status = {
+                        "size_kb": round(size_kb, 2),
+                        "size_limit_kb": limits['max_file_size_kb'],
+                        "size_utilization": min(100, round((size_kb / limits['max_file_size_kb']) * 100, 1)),
+                        "sections": section_count,
+                        "items": learning_count,
+                        "last_modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                        "auto_learning": self._get_agent_auto_learning(agent_id)
+                    }
+                    
+                    # Check for optimization opportunities
+                    if size_kb > limits['max_file_size_kb'] * 0.8:
+                        status["optimization_opportunities"].append(f"{agent_id}: High memory usage ({size_kb:.1f}KB)")
+                    
+                    if section_count > limits['max_sections'] * 0.8:
+                        status["optimization_opportunities"].append(f"{agent_id}: Many sections ({section_count})")
+                    
+                    status["agents"][agent_id] = agent_status
+                    
+                except Exception as e:
+                    status["agents"][agent_id] = {"error": str(e)}
+            
+            status["total_size_kb"] = round(total_size / 1024, 2)
+            
+            # Determine overall system health
+            if len(status["optimization_opportunities"]) > 3:
+                status["system_health"] = "needs_optimization"
+            elif status["total_size_kb"] > 100:  # More than 100KB total
+                status["system_health"] = "high_usage"
+            
+            return status
+            
+        except Exception as e:
+            self.logger.error(f"Error getting memory status: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def cross_reference_memories(self, query: Optional[str] = None) -> Dict[str, Any]:
+        """Find common patterns and cross-references across agent memories.
+        
+        WHY: Different agents may have learned similar or related information.
+        Cross-referencing helps identify knowledge gaps, redundancies, and
+        opportunities for knowledge sharing between agents.
+        
+        Args:
+            query: Optional query to filter cross-references
+            
+        Returns:
+            Dict containing cross-reference analysis results
+        """
+        try:
+            cross_refs = {
+                "common_patterns": [],
+                "knowledge_gaps": [],
+                "redundancies": [],
+                "agent_correlations": {},
+                "query_matches": [] if query else None
+            }
+            
+            if not self.memories_dir.exists():
+                return cross_refs
+            
+            memory_files = list(self.memories_dir.glob("*_agent.md"))
+            agent_memories = {}
+            
+            # Load all agent memories
+            for file_path in memory_files:
+                agent_id = file_path.stem.replace('_agent', '')
+                try:
+                    content = file_path.read_text()
+                    agent_memories[agent_id] = content
+                except Exception as e:
+                    self.logger.warning(f"Error reading memory for {agent_id}: {e}")
+                    continue
+            
+            # Find common patterns across agents
+            all_lines = []
+            agent_lines = {}
+            
+            for agent_id, content in agent_memories.items():
+                lines = [line.strip() for line in content.splitlines() 
+                        if line.strip().startswith('- ')]
+                agent_lines[agent_id] = lines
+                all_lines.extend([(line, agent_id) for line in lines])
+            
+            # Look for similar content (basic similarity check)
+            line_counts = {}
+            for line, agent_id in all_lines:
+                # Normalize line for comparison
+                normalized = line.lower().replace('- ', '').strip()
+                if len(normalized) > 20:  # Only check substantial lines
+                    if normalized not in line_counts:
+                        line_counts[normalized] = []
+                    line_counts[normalized].append(agent_id)
+            
+            # Find patterns appearing in multiple agents
+            for line, agents in line_counts.items():
+                if len(set(agents)) > 1:  # Appears in multiple agents
+                    cross_refs["common_patterns"].append({
+                        "pattern": line[:100] + "..." if len(line) > 100 else line,
+                        "agents": list(set(agents)),
+                        "count": len(agents)
+                    })
+            
+            # Query-specific matches
+            if query:
+                query_lower = query.lower()
+                for agent_id, content in agent_memories.items():
+                    matches = []
+                    for line in content.splitlines():
+                        if query_lower in line.lower():
+                            matches.append(line.strip())
+                    
+                    if matches:
+                        cross_refs["query_matches"].append({
+                            "agent": agent_id,
+                            "matches": matches[:5]  # Limit to first 5 matches
+                        })
+            
+            # Calculate agent correlations (agents with similar knowledge domains)
+            for agent_a in agent_memories:
+                for agent_b in agent_memories:
+                    if agent_a < agent_b:  # Avoid duplicates
+                        common_count = len([
+                            line for line in line_counts.values()
+                            if agent_a in line and agent_b in line
+                        ])
+                        
+                        if common_count > 0:
+                            correlation_key = f"{agent_a}+{agent_b}"
+                            cross_refs["agent_correlations"][correlation_key] = common_count
+            
+            return cross_refs
+            
+        except Exception as e:
+            self.logger.error(f"Error cross-referencing memories: {e}")
+            return {"success": False, "error": str(e)}
+
     def _ensure_memories_directory(self):
         """Ensure memories directory exists with README.