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

claude_mpm/cli/commands/run.py

@@ -11,12 +11,13 @@ import sys
 import time
 import webbrowser
 from pathlib import Path
+from datetime import datetime
 
 from ...core.logger import get_logger
 from ...constants import LogLevel
 from ..utils import get_user_input, list_agent_versions_at_startup
 from ...utils.dependency_manager import ensure_socketio_dependencies
-from ...deployment_paths import get_monitor_html_path, get_scripts_dir, get_package_root
+from ...deployment_paths import get_scripts_dir, get_package_root
 
 
 def filter_claude_mpm_args(claude_args):
@@ -80,10 +81,19 @@ def filter_claude_mpm_args(claude_args):
             # Also skip the next argument if this flag expects a value
             value_expecting_flags = {
                 '--websocket-port', '--launch-method', '--logging', '--log-dir', 
-                '--framework-path', '--agents-dir', '-i', '--input', '--resume'
+                '--framework-path', '--agents-dir', '-i', '--input'
             }
+            optional_value_flags = {
+                '--resume'  # These flags can have optional values (nargs="?")
+            }
+            
             if arg in value_expecting_flags and i < len(claude_args):
                 i += 1  # Skip the value too
+            elif arg in optional_value_flags and i < len(claude_args):
+                # For optional value flags, only skip next arg if it doesn't start with --
+                next_arg = claude_args[i]
+                if not next_arg.startswith('--'):
+                    i += 1  # Skip the value
         else:
             # This is not a claude-mpm flag, keep it
             filtered_args.append(arg)
@@ -92,6 +102,58 @@ def filter_claude_mpm_args(claude_args):
     return filtered_args
 
 
+def create_session_context(session_id, session_manager):
+    """
+    Create enhanced context for resumed sessions.
+    
+    WHY: When resuming a session, we want to provide Claude with context about
+    the previous session including what agents were used and when it was created.
+    This helps maintain continuity across session boundaries.
+    
+    Args:
+        session_id: Session ID being resumed
+        session_manager: SessionManager instance
+        
+    Returns:
+        Enhanced context string with session information
+    """
+    try:
+        from ...core.claude_runner import create_simple_context
+    except ImportError:
+        from claude_mpm.core.claude_runner import create_simple_context
+    
+    base_context = create_simple_context()
+    
+    session_data = session_manager.get_session_by_id(session_id)
+    if not session_data:
+        return base_context
+    
+    # Add session resumption information
+    session_info = f"""
+
+# Session Resumption
+
+You are resuming session {session_id[:8]}... which was:
+- Created: {session_data.get('created_at', 'unknown')}
+- Last used: {session_data.get('last_used', 'unknown')}
+- Context: {session_data.get('context', 'default')}
+- Use count: {session_data.get('use_count', 0)}
+"""
+    
+    # Add information about agents previously run in this session
+    agents_run = session_data.get('agents_run', [])
+    if agents_run:
+        session_info += "\n- Previous agent activity:\n"
+        for agent_info in agents_run[-5:]:  # Show last 5 agents
+            session_info += f"  • {agent_info.get('agent', 'unknown')}: {agent_info.get('task', 'no description')[:50]}...\n"
+        if len(agents_run) > 5:
+            session_info += f"  (and {len(agents_run) - 5} other agent interactions)\n"
+    
+    session_info += "\nContinue from where you left off in this session."
+    
+    return base_context + session_info
+
+
 def run_session(args):
     """
     Run a simplified Claude session.
@@ -112,8 +174,44 @@ def run_session(args):
     
     try:
         from ...core.claude_runner import ClaudeRunner, create_simple_context
+        from ...core.session_manager import SessionManager
     except ImportError:
         from claude_mpm.core.claude_runner import ClaudeRunner, create_simple_context
+        from claude_mpm.core.session_manager import SessionManager
+    
+    # Handle session resumption
+    session_manager = SessionManager()
+    resume_session_id = None
+    resume_context = None
+    
+    if hasattr(args, 'resume') and args.resume:
+        if args.resume == "last":
+            # Resume the last interactive session
+            resume_session_id = session_manager.get_last_interactive_session()
+            if resume_session_id:
+                session_data = session_manager.get_session_by_id(resume_session_id)
+                if session_data:
+                    resume_context = session_data.get("context", "default")
+                    logger.info(f"Resuming session {resume_session_id} (context: {resume_context})")
+                    print(f"🔄 Resuming session {resume_session_id[:8]}... (created: {session_data.get('created_at', 'unknown')})")
+                else:
+                    logger.warning(f"Session {resume_session_id} not found")
+            else:
+                logger.info("No recent interactive sessions found")
+                print("ℹ️  No recent interactive sessions found to resume")
+        else:
+            # Resume specific session by ID
+            resume_session_id = args.resume
+            session_data = session_manager.get_session_by_id(resume_session_id)
+            if session_data:
+                resume_context = session_data.get("context", "default")
+                logger.info(f"Resuming session {resume_session_id} (context: {resume_context})")
+                print(f"🔄 Resuming session {resume_session_id[:8]}... (context: {resume_context})")
+            else:
+                logger.error(f"Session {resume_session_id} not found")
+                print(f"❌ Session {resume_session_id} not found")
+                print("💡 Use 'claude-mpm sessions' to list available sessions")
+                return
     
     # Skip native agents if disabled
     if getattr(args, 'no_native_agents', False):
@@ -189,8 +287,19 @@ def run_session(args):
         # Pass information about whether we already opened the browser in run.py
         runner._browser_opened_by_cli = getattr(args, '_browser_opened_by_cli', False)
     
-    # Create basic context
-    context = create_simple_context()
+    # Create context - use resumed session context if available
+    if resume_session_id and resume_context:
+        # For resumed sessions, create enhanced context with session information
+        context = create_session_context(resume_session_id, session_manager)
+        # Update session usage
+        session_manager.active_sessions[resume_session_id]["last_used"] = datetime.now().isoformat()
+        session_manager.active_sessions[resume_session_id]["use_count"] += 1
+        session_manager._save_sessions()
+    else:
+        # Create a new session for tracking
+        new_session_id = session_manager.create_session("default")
+        context = create_simple_context()
+        logger.info(f"Created new session {new_session_id}")
     
     # For monitor mode, we handled everything in launch_socketio_monitor
     # No need for ClaudeRunner browser delegation
@@ -260,16 +369,8 @@ def launch_socketio_monitor(port, logger):
         
         socketio_port = port
         
-        # Get path to monitor HTML using deployment paths
-        html_file_path = get_monitor_html_path()
-        
-        if not html_file_path.exists():
-            logger.error(f"Monitor HTML file not found: {html_file_path}")
-            print(f"❌ Monitor HTML file not found: {html_file_path}")
-            return False, False
-        
-        # Create file:// URL with port parameter
-        dashboard_url = f'file://{html_file_path.absolute()}?port={socketio_port}'
+        # Use HTTP URL to access dashboard from Socket.IO server
+        dashboard_url = f'http://localhost:{socketio_port}'
         
         # Check if Socket.IO server is already running
         server_running = _check_socketio_server_running(socketio_port, logger)

claude_mpm/cli/parser.py

@@ -119,6 +119,13 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         default=8765,
         help="WebSocket server port (default: 8765)"
     )
+    run_group.add_argument(
+        "--resume",
+        type=str,
+        nargs="?",
+        const="last",
+        help="Resume a session (last session if no ID specified, or specific session ID)"
+    )
     
     # Input/output options
     io_group = parser.add_argument_group('input/output options')
@@ -214,6 +221,13 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
         default=8765,
         help="WebSocket server port (default: 8765)"
     )
+    run_group.add_argument(
+        "--resume",
+        type=str,
+        nargs="?",
+        const="last",
+        help="Resume a session (last session if no ID specified, or specific session ID)"
+    )
     
     # Input/output options
     io_group = parser.add_argument_group('input/output options (when no command specified)')
@@ -393,6 +407,68 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
         help="Clean up old/unused memory files"
     )
     
+    # Optimize command
+    optimize_parser = memory_subparsers.add_parser(
+        MemoryCommands.OPTIMIZE.value,
+        help="Optimize memory files by removing duplicates and consolidating similar items"
+    )
+    optimize_parser.add_argument(
+        "agent_id",
+        nargs="?",
+        help="Agent ID to optimize (optimize all if not specified)"
+    )
+    
+    # Build command
+    build_parser = memory_subparsers.add_parser(
+        MemoryCommands.BUILD.value,
+        help="Build agent memories from project documentation"
+    )
+    build_parser.add_argument(
+        "--force-rebuild",
+        action="store_true",
+        help="Force rebuild even if docs haven't changed"
+    )
+    
+    # Cross-reference command
+    cross_ref_parser = memory_subparsers.add_parser(
+        MemoryCommands.CROSS_REF.value,
+        help="Find cross-references and common patterns across agent memories"
+    )
+    cross_ref_parser.add_argument(
+        "--query",
+        type=str,
+        help="Optional search query to filter cross-references"
+    )
+    
+    # Route command
+    route_parser = memory_subparsers.add_parser(
+        MemoryCommands.ROUTE.value,
+        help="Test memory command routing logic"
+    )
+    route_parser.add_argument(
+        "--content",
+        type=str,
+        required=True,
+        help="Content to analyze for routing"
+    )
+    
+    # Show command
+    show_parser = memory_subparsers.add_parser(
+        MemoryCommands.SHOW.value,
+        help="Show agent memories in user-friendly format with cross-references"
+    )
+    show_parser.add_argument(
+        "agent_id",
+        nargs="?",
+        help="Agent ID to show memory for (show all if not specified)"
+    )
+    show_parser.add_argument(
+        "--format",
+        choices=["summary", "detailed", "full"],
+        default="summary",
+        help="Display format: summary (default), detailed, or full"
+    )
+    
     return parser
 
 

claude_mpm/constants.py

@@ -62,6 +62,11 @@ class MemoryCommands(str, Enum):
     VIEW = "view"
     ADD = "add"
     CLEAN = "clean"
+    OPTIMIZE = "optimize"
+    BUILD = "build"
+    CROSS_REF = "cross-ref"
+    ROUTE = "route"
+    SHOW = "show"
 
 
 class CLIFlags(str, Enum):

claude_mpm/core/claude_runner.py

@@ -95,7 +95,7 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to create session log file: {e}")
         
-        # Initialize WebSocket server reference
+        # Initialize Socket.IO server reference
         self.websocket_server = None
     
     def setup_agents(self) -> bool:
@@ -152,13 +152,14 @@ class ClaudeRunner:
     
     def run_interactive(self, initial_context: Optional[str] = None):
         """Run Claude in interactive mode."""
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -171,7 +172,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Get version
@@ -329,13 +330,14 @@ class ClaudeRunner:
         """Run Claude with a single prompt and return success status."""
         start_time = time.time()
         
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -348,7 +350,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Check for /mpm: commands

claude_mpm/core/session_manager.py

@@ -117,6 +117,52 @@ class SessionManager:
         if expired:
             self._save_sessions()
     
+    def get_recent_sessions(self, limit: int = 10, context: Optional[str] = None) -> list:
+        """Get recent sessions sorted by last used time.
+        
+        Args:
+            limit: Maximum number of sessions to return
+            context: Filter by context (optional)
+            
+        Returns:
+            List of session data dictionaries sorted by last_used descending
+        """
+        sessions = list(self.active_sessions.values())
+        
+        # Filter by context if specified
+        if context:
+            sessions = [s for s in sessions if s.get("context") == context]
+        
+        # Sort by last_used descending (most recent first)
+        sessions.sort(key=lambda s: datetime.fromisoformat(s["last_used"]), reverse=True)
+        
+        return sessions[:limit]
+    
+    def get_session_by_id(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session data by ID.
+        
+        Args:
+            session_id: Session ID to look up
+            
+        Returns:
+            Session data dictionary or None if not found
+        """
+        return self.active_sessions.get(session_id)
+    
+    def get_last_interactive_session(self) -> Optional[str]:
+        """Get the most recently used interactive session ID.
+        
+        WHY: For --resume without arguments, we want to resume the last
+        interactive session (context="default" for regular Claude runs).
+        
+        Returns:
+            Session ID of most recent interactive session, or None if none found
+        """
+        recent_sessions = self.get_recent_sessions(limit=1, context="default")
+        if recent_sessions:
+            return recent_sessions[0]["id"]
+        return None
+    
     def _save_sessions(self):
         """Save sessions to disk."""
         session_file = self.session_dir / "active_sessions.json"

claude_mpm/core/simple_runner.py

@@ -95,7 +95,7 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to create session log file: {e}")
         
-        # Initialize WebSocket server reference
+        # Initialize Socket.IO server reference
         self.websocket_server = None
     
     def setup_agents(self) -> bool:
@@ -152,13 +152,14 @@ class ClaudeRunner:
     
     def run_interactive(self, initial_context: Optional[str] = None):
         """Run Claude in interactive mode."""
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -171,7 +172,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Get version
@@ -329,13 +330,14 @@ class ClaudeRunner:
         """Run Claude with a single prompt and return success status."""
         start_time = time.time()
         
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -348,7 +350,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Check for /mpm: commands

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -31,13 +31,7 @@ except ImportError:
     SOCKETIO_AVAILABLE = False
     socketio = None
 
-# Fallback imports
-try:
-    from ...services.websocket_server import get_server_instance
-    SERVER_AVAILABLE = True
-except ImportError:
-    SERVER_AVAILABLE = False
-    get_server_instance = None
+# No fallback needed - we only use Socket.IO now
 
 
 class ClaudeHookHandler:
@@ -65,14 +59,7 @@ class ClaudeHookHandler:
         self._git_branch_cache = {}
         self._git_branch_cache_time = {}
         
-        # Initialize fallback server instance if available (but don't start it)
-        if SERVER_AVAILABLE:
-            try:
-                self.websocket_server = get_server_instance()
-            except:
-                self.websocket_server = None
-        else:
-            self.websocket_server = None
+        # No fallback server needed - we only use Socket.IO now
     
     def _track_delegation(self, session_id: str, agent_type: str):
         """Track a new agent delegation."""
@@ -291,17 +278,6 @@ class ClaudeHookHandler:
                     print(f"Socket.IO emit failed: {e}", file=sys.stderr)
                 # Mark as disconnected so next call will reconnect
                 self.sio_connected = False
-        
-        # Fallback to legacy WebSocket server
-        elif hasattr(self, 'websocket_server') and self.websocket_server:
-            try:
-                # Map to legacy event format
-                legacy_event = f"hook.{event}"
-                self.websocket_server.broadcast_event(legacy_event, data)
-                if DEBUG:
-                    print(f"Emitted legacy event: {legacy_event}", file=sys.stderr)
-            except:
-                pass  # Silent failure
     
     def _handle_user_prompt_fast(self, event):
         """Handle user prompt with comprehensive data capture.