claude-mpm 3.3.0__py3-none-any.whl → 3.4.0__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)')
@@ -352,6 +366,12 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
         metavar="SUBCOMMAND"
     )
     
+    # Init command
+    init_parser = memory_subparsers.add_parser(
+        MemoryCommands.INIT.value,
+        help="Initialize project-specific memories via PM agent"
+    )
+    
     # Status command
     status_parser = memory_subparsers.add_parser(
         MemoryCommands.STATUS.value,
@@ -365,7 +385,8 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
     )
     view_parser.add_argument(
         "agent_id",
-        help="Agent ID to view memory for"
+        nargs="?",
+        help="Agent ID to view memory for (optional - shows all agents if not provided)"
     )
     
     # Add command
@@ -393,6 +414,73 @@ 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"
+    )
+    show_parser.add_argument(
+        "--raw",
+        action="store_true",
+        help="Output raw memory content in JSON format for programmatic processing"
+    )
+    
     return parser
 
 

claude_mpm/constants.py

@@ -58,10 +58,16 @@ class AgentCommands(str, Enum):
 
 class MemoryCommands(str, Enum):
     """Memory subcommand constants."""
+    INIT = "init"
     STATUS = "status"
     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

@@ -13,10 +13,14 @@ import uuid
 try:
     from claude_mpm.services.agent_deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.core.config import Config
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 except ImportError:
     from claude_mpm.services.agent_deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.core.config import Config
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 
 
@@ -76,6 +80,11 @@ class ClaudeRunner:
                 self.ticket_manager = None
                 self.enable_tickets = False
         
+        # Initialize hook service and register memory hooks
+        self.config = Config()
+        self.hook_service = HookService(self.config)
+        self._register_memory_hooks()
+        
         # Load system instructions
         self.system_instructions = self._load_system_instructions()
         
@@ -95,7 +104,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 +161,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 +181,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 +339,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 +359,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
@@ -739,6 +750,58 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
     
+    def _register_memory_hooks(self):
+        """Register memory integration hooks with the hook service.
+        
+        WHY: This activates the memory system by registering hooks that automatically
+        inject agent memory before delegation and extract learnings after delegation.
+        This is the critical connection point between the memory system and the CLI.
+        
+        DESIGN DECISION: We register hooks here instead of in __init__ to ensure
+        all services are initialized first. Hooks are only registered if the memory
+        system is enabled in configuration.
+        """
+        try:
+            # Only register if memory system is enabled
+            if not self.config.get('memory.enabled', True):
+                self.logger.debug("Memory system disabled - skipping hook registration")
+                return
+            
+            # Import hook classes (lazy import to avoid circular dependencies)
+            from claude_mpm.hooks.memory_integration_hook import (
+                MemoryPreDelegationHook,
+                MemoryPostDelegationHook
+            )
+            
+            # Register pre-delegation hook for memory injection
+            pre_hook = MemoryPreDelegationHook(self.config)
+            success = self.hook_service.register_hook(pre_hook)
+            if success:
+                self.logger.info(f"✅ Registered memory pre-delegation hook (priority: {pre_hook.priority})")
+            else:
+                self.logger.warning("❌ Failed to register memory pre-delegation hook")
+            
+            # Register post-delegation hook if auto-learning is enabled
+            if self.config.get('memory.auto_learning', True):  # Default to True now
+                post_hook = MemoryPostDelegationHook(self.config)
+                success = self.hook_service.register_hook(post_hook)
+                if success:
+                    self.logger.info(f"✅ Registered memory post-delegation hook (priority: {post_hook.priority})")
+                else:
+                    self.logger.warning("❌ Failed to register memory post-delegation hook")
+            else:
+                self.logger.info("ℹ️  Auto-learning disabled - skipping post-delegation hook")
+            
+            # Log summary of registered hooks
+            hooks = self.hook_service.list_hooks()
+            pre_count = len(hooks.get('pre_delegation', []))
+            post_count = len(hooks.get('post_delegation', []))
+            self.logger.info(f"📋 Hook Service initialized: {pre_count} pre-delegation, {post_count} post-delegation hooks")
+            
+        except Exception as e:
+            self.logger.error(f"❌ Failed to register memory hooks: {e}")
+            # Don't fail the entire initialization - memory system is optional
+    
     def _launch_subprocess_interactive(self, cmd: list, env: dict):
         """Launch Claude as a subprocess with PTY for interactive mode."""
         import pty

claude_mpm/core/config.py

@@ -231,7 +231,7 @@ class Config:
             # Agent Memory System configuration
             "memory": {
                 "enabled": True,                    # Master switch for memory system
-                "auto_learning": False,             # Automatic learning extraction
+                "auto_learning": True,              # Automatic learning extraction (changed default to True)
                 "limits": {
                     "default_size_kb": 8,           # Default file size limit
                     "max_sections": 10,             # Maximum sections per file

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"