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

claude_mpm/cli/commands/ui.py

@@ -5,10 +5,7 @@ WHY: This module provides terminal UI functionality for users who prefer a
 visual interface over command-line interaction.
 """
 
-from claude_mpm.utils.imports import safe_import
-
-# Import logger using safe_import pattern
-get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+from ...core.logger import get_logger
 
 
 def run_terminal_ui(args):
@@ -32,45 +29,26 @@ def run_terminal_ui(args):
     
     try:
         if ui_mode == 'terminal':
-            # Try rich UI first using safe_import
-            run_rich_ui = safe_import(
-                '...ui.rich_terminal_ui',
-                'claude_mpm.ui.rich_terminal_ui',
-                ['main']
-            )
-            
-            if run_rich_ui:
+            # Try rich UI first
+            try:
+                from ...ui.rich_terminal_ui import main as run_rich_ui
                 logger.info("Starting rich terminal UI...")
                 run_rich_ui()
-            else:
+            except ImportError:
                 # Fallback to curses UI
                 logger.info("Rich not available, falling back to curses UI...")
-                TerminalUI = safe_import(
-                    '...ui.terminal_ui',
-                    'claude_mpm.ui.terminal_ui',
-                    ['TerminalUI']
-                )
-                if TerminalUI:
-                    ui = TerminalUI()
-                    ui.run()
-                else:
-                    logger.error("UI module not found")
-                    print("Error: Terminal UI requires 'curses' (built-in) or 'rich' (pip install rich)")
-                    return 1
-        else:
-            # Use curses UI explicitly
-            TerminalUI = safe_import(
-                '...ui.terminal_ui',
-                'claude_mpm.ui.terminal_ui',
-                ['TerminalUI']
-            )
-            if TerminalUI:
+                from ...ui.terminal_ui import TerminalUI
                 ui = TerminalUI()
                 ui.run()
-            else:
-                logger.error("UI module not found")
-                print("Error: Terminal UI not available")
-                return 1
+        else:
+            # Use curses UI explicitly
+            from ...ui.terminal_ui import TerminalUI
+            ui = TerminalUI()
+            ui.run()
+    except ImportError as e:
+        logger.error(f"UI module not found: {e}")
+        print(f"Error: Terminal UI requires 'curses' (built-in) or 'rich' (pip install rich)")
+        return 1
     except Exception as e:
         logger.error(f"Error running terminal UI: {e}")
         print(f"Error: {e}")

claude_mpm/cli/parser.py

@@ -14,7 +14,7 @@ import argparse
 from pathlib import Path
 from typing import Optional, List
 
-from ..constants import CLICommands, CLIPrefix, AgentCommands, LogLevel
+from ..constants import CLICommands, CLIPrefix, AgentCommands, MemoryCommands, LogLevel
 
 
 def add_common_arguments(parser: argparse.ArgumentParser, version: str = None) -> None:
@@ -101,6 +101,24 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Disable deployment of Claude Code native agents"
     )
+    run_group.add_argument(
+        "--launch-method",
+        choices=["exec", "subprocess"],
+        default="exec",
+        help="Method to launch Claude: exec (replace process) or subprocess (child process)"
+    )
+    # Monitor options - consolidated monitoring and management interface
+    run_group.add_argument(
+        "--monitor",
+        action="store_true",
+        help="Enable monitoring and management interface with WebSocket server and dashboard (default port: 8765)"
+    )
+    run_group.add_argument(
+        "--websocket-port",
+        type=int,
+        default=8765,
+        help="WebSocket server port (default: 8765)"
+    )
     
     # Input/output options
     io_group = parser.add_argument_group('input/output options')
@@ -178,6 +196,24 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
         action="store_true",
         help="Disable deployment of Claude Code native agents"
     )
+    run_group.add_argument(
+        "--launch-method",
+        choices=["exec", "subprocess"],
+        default="exec",
+        help="Method to launch Claude: exec (replace process) or subprocess (child process)"
+    )
+    # Monitor options - consolidated monitoring and management interface
+    run_group.add_argument(
+        "--monitor",
+        action="store_true",
+        help="Enable monitoring and management interface with WebSocket server and dashboard (default port: 8765)"
+    )
+    run_group.add_argument(
+        "--websocket-port",
+        type=int,
+        default=8765,
+        help="WebSocket server port (default: 8765)"
+    )
     
     # Input/output options
     io_group = parser.add_argument_group('input/output options (when no command specified)')
@@ -303,6 +339,60 @@ def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argp
         help="Target directory (default: .claude/)"
     )
     
+    # Memory command with subcommands
+    memory_parser = subparsers.add_parser(
+        CLICommands.MEMORY.value,
+        help="Manage agent memory files"
+    )
+    add_common_arguments(memory_parser)
+    
+    memory_subparsers = memory_parser.add_subparsers(
+        dest="memory_command",
+        help="Memory commands",
+        metavar="SUBCOMMAND"
+    )
+    
+    # Status command
+    status_parser = memory_subparsers.add_parser(
+        MemoryCommands.STATUS.value,
+        help="Show memory file status"
+    )
+    
+    # View command
+    view_parser = memory_subparsers.add_parser(
+        MemoryCommands.VIEW.value,
+        help="View agent memory file"
+    )
+    view_parser.add_argument(
+        "agent_id",
+        help="Agent ID to view memory for"
+    )
+    
+    # Add command
+    add_parser = memory_subparsers.add_parser(
+        MemoryCommands.ADD.value,
+        help="Manually add learning to agent memory"
+    )
+    add_parser.add_argument(
+        "agent_id",
+        help="Agent ID to add learning to"
+    )
+    add_parser.add_argument(
+        "learning_type",
+        choices=["pattern", "error", "optimization", "preference", "context"],
+        help="Type of learning to add"
+    )
+    add_parser.add_argument(
+        "content",
+        help="Learning content to add"
+    )
+    
+    # Clean command
+    clean_memory_parser = memory_subparsers.add_parser(
+        MemoryCommands.CLEAN.value,
+        help="Clean up old/unused memory files"
+    )
+    
     return parser
 
 

claude_mpm/cli/utils.py

@@ -10,10 +10,7 @@ import sys
 from pathlib import Path
 from typing import Optional
 
-from claude_mpm.utils.imports import safe_import
-
-# Import logger using safe_import pattern
-get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+from ..core.logger import get_logger
 
 
 def get_user_input(input_arg: Optional[str], logger) -> str:
@@ -62,17 +59,8 @@ def get_agent_versions_display() -> Optional[str]:
     Returns:
         Formatted string containing agent version information, or None if failed
     """
-    # Import AgentDeploymentService using safe_import pattern
-    AgentDeploymentService = safe_import(
-        'claude_mpm.services.agent_deployment',
-        None,
-        ['AgentDeploymentService']
-    )
-    
-    if not AgentDeploymentService:
-        return None
-        
     try:
+        from ..services.agent_deployment import AgentDeploymentService
         deployment_service = AgentDeploymentService()
         
         # Get deployed agents
@@ -174,17 +162,10 @@ def ensure_directories() -> None:
     failing when they don't exist, we create them automatically for a better
     user experience.
     """
-    # Import ensure_directories using safe_import pattern
-    init_ensure_directories = safe_import(
-        'claude_mpm.init',
-        None,
-        ['ensure_directories']
-    )
-    
-    if init_ensure_directories:
-        try:
-            init_ensure_directories()
-        except Exception:
-            # Continue even if initialization fails
-            # The individual commands will handle missing directories as needed
-            pass
+    try:
+        from ..init import ensure_directories as init_ensure_directories
+        init_ensure_directories()
+    except Exception:
+        # Continue even if initialization fails
+        # The individual commands will handle missing directories as needed
+        pass

claude_mpm/config/socketio_config.py

@@ -0,0 +1,256 @@
+"""Socket.IO server configuration for different deployment scenarios.
+
+This module provides configuration management for Socket.IO servers
+across different deployment environments and installation methods.
+
+WHY configuration management:
+- Enables different settings for development vs production
+- Supports multiple deployment scenarios (local, PyPI, Docker, etc.)
+- Provides environment-specific defaults
+- Allows runtime configuration overrides
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+
+@dataclass
+class SocketIOConfig:
+    """Configuration for Socket.IO server instances."""
+    
+    # Server settings
+    host: str = "localhost"
+    port: int = 8765
+    server_id: Optional[str] = None
+    
+    # Connection settings
+    cors_allowed_origins: str = "*"  # Configure properly for production
+    ping_timeout: int = 60
+    ping_interval: int = 25
+    max_http_buffer_size: int = 1000000
+    
+    # Compatibility settings
+    min_client_version: str = "0.7.0"
+    max_history_size: int = 10000
+    
+    # Deployment settings
+    deployment_mode: str = "auto"  # auto, standalone, embedded, client
+    auto_start: bool = True
+    persistent: bool = True
+    
+    # Logging settings
+    log_level: str = "INFO"
+    log_to_file: bool = False
+    log_file_path: Optional[str] = None
+    
+    # Health monitoring
+    health_check_interval: int = 30
+    max_connection_attempts: int = 3
+    reconnection_delay: int = 1
+    
+    @classmethod
+    def from_env(cls) -> 'SocketIOConfig':
+        """Create configuration from environment variables."""
+        return cls(
+            host=os.getenv('CLAUDE_MPM_SOCKETIO_HOST', 'localhost'),
+            port=int(os.getenv('CLAUDE_MPM_SOCKETIO_PORT', '8765')),
+            server_id=os.getenv('CLAUDE_MPM_SOCKETIO_SERVER_ID'),
+            cors_allowed_origins=os.getenv('CLAUDE_MPM_SOCKETIO_CORS', '*'),
+            ping_timeout=int(os.getenv('CLAUDE_MPM_SOCKETIO_PING_TIMEOUT', '60')),
+            ping_interval=int(os.getenv('CLAUDE_MPM_SOCKETIO_PING_INTERVAL', '25')),
+            deployment_mode=os.getenv('CLAUDE_MPM_SOCKETIO_MODE', 'auto'),
+            auto_start=os.getenv('CLAUDE_MPM_SOCKETIO_AUTO_START', 'true').lower() == 'true',
+            persistent=os.getenv('CLAUDE_MPM_SOCKETIO_PERSISTENT', 'true').lower() == 'true',
+            log_level=os.getenv('CLAUDE_MPM_SOCKETIO_LOG_LEVEL', 'INFO'),
+            max_history_size=int(os.getenv('CLAUDE_MPM_SOCKETIO_HISTORY_SIZE', '10000'))
+        )
+    
+    @classmethod
+    def for_development(cls) -> 'SocketIOConfig':
+        """Configuration optimized for development."""
+        return cls(
+            host="localhost",
+            port=8765,
+            deployment_mode="auto",
+            log_level="DEBUG",
+            ping_timeout=30,
+            ping_interval=10,
+            max_history_size=5000
+        )
+    
+    @classmethod
+    def for_production(cls) -> 'SocketIOConfig':
+        """Configuration optimized for production."""
+        return cls(
+            host="0.0.0.0",  # Bind to all interfaces in production
+            port=8765,
+            cors_allowed_origins="https://your-domain.com",  # Restrict CORS
+            deployment_mode="standalone",
+            persistent=True,
+            log_level="INFO",
+            log_to_file=True,
+            log_file_path="/var/log/claude-mpm-socketio.log",
+            ping_timeout=120,
+            ping_interval=30,
+            max_history_size=20000
+        )
+    
+    @classmethod
+    def for_docker(cls) -> 'SocketIOConfig':
+        """Configuration optimized for Docker deployment."""
+        return cls(
+            host="0.0.0.0",
+            port=8765,
+            deployment_mode="standalone",
+            persistent=True,
+            log_level="INFO",
+            ping_timeout=90,
+            ping_interval=25,
+            max_history_size=15000
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return {
+            'host': self.host,
+            'port': self.port,
+            'server_id': self.server_id,
+            'cors_allowed_origins': self.cors_allowed_origins,
+            'ping_timeout': self.ping_timeout,
+            'ping_interval': self.ping_interval,
+            'max_http_buffer_size': self.max_http_buffer_size,
+            'min_client_version': self.min_client_version,
+            'max_history_size': self.max_history_size,
+            'deployment_mode': self.deployment_mode,
+            'auto_start': self.auto_start,
+            'persistent': self.persistent,
+            'log_level': self.log_level,
+            'log_to_file': self.log_to_file,
+            'log_file_path': self.log_file_path,
+            'health_check_interval': self.health_check_interval,
+            'max_connection_attempts': self.max_connection_attempts,
+            'reconnection_delay': self.reconnection_delay
+        }
+
+
+class ConfigManager:
+    """Manages Socket.IO configuration across different environments."""
+    
+    def __init__(self):
+        self.config_file_name = "socketio_config.json"
+        self.config_search_paths = [
+            Path.cwd() / self.config_file_name,  # Current directory
+            Path.home() / ".claude-mpm" / self.config_file_name,  # User home
+            Path("/etc/claude-mpm") / self.config_file_name,  # System config
+        ]
+    
+    def detect_environment(self) -> str:
+        """Detect the current deployment environment."""
+        # Check for Docker
+        if os.path.exists('/.dockerenv') or os.getenv('DOCKER_CONTAINER'):
+            return "docker"
+        
+        # Check for production indicators
+        if os.getenv('ENVIRONMENT') == 'production' or os.getenv('NODE_ENV') == 'production':
+            return "production"
+        
+        # Check if running from installed package
+        try:
+            import claude_mpm
+            pkg_path = Path(claude_mpm.__file__).parent
+            if 'site-packages' in str(pkg_path) or 'dist-packages' in str(pkg_path):
+                return "installed"
+        except ImportError:
+            pass
+        
+        # Default to development
+        return "development"
+    
+    def get_config(self, environment: str = None) -> SocketIOConfig:
+        """Get configuration for the specified environment."""
+        if environment is None:
+            environment = self.detect_environment()
+        
+        # Start with environment-specific defaults
+        if environment == "production":
+            config = SocketIOConfig.for_production()
+        elif environment == "docker":
+            config = SocketIOConfig.for_docker()
+        elif environment == "development":
+            config = SocketIOConfig.for_development()
+        else:
+            config = SocketIOConfig()
+        
+        # Override with environment variables
+        env_config = SocketIOConfig.from_env()
+        for field in config.__dataclass_fields__:
+            env_value = getattr(env_config, field)
+            if env_value != getattr(SocketIOConfig(), field):  # Only if different from default
+                setattr(config, field, env_value)
+        
+        # Override with config file if available
+        config_file_data = self._load_config_file()
+        if config_file_data:
+            for key, value in config_file_data.items():
+                if hasattr(config, key):
+                    setattr(config, key, value)
+        
+        return config
+    
+    def _load_config_file(self) -> Optional[Dict[str, Any]]:
+        """Load configuration from file if available."""
+        import json
+        
+        for config_path in self.config_search_paths:
+            if config_path.exists():
+                try:
+                    with open(config_path, 'r') as f:
+                        return json.load(f)
+                except Exception as e:
+                    print(f"Warning: Failed to load config from {config_path}: {e}")
+        
+        return None
+    
+    def save_config(self, config: SocketIOConfig, path: str = None) -> bool:
+        """Save configuration to file."""
+        import json
+        
+        if path is None:
+            # Use user config directory
+            config_dir = Path.home() / ".claude-mpm"
+            config_dir.mkdir(exist_ok=True)
+            path = config_dir / self.config_file_name
+        
+        try:
+            with open(path, 'w') as f:
+                json.dump(config.to_dict(), f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving config to {path}: {e}")
+            return False
+
+
+# Global configuration manager instance
+_config_manager = ConfigManager()
+
+
+def get_config(environment: str = None) -> SocketIOConfig:
+    """Get Socket.IO configuration for the current or specified environment."""
+    return _config_manager.get_config(environment)
+
+
+def get_server_ports(config: SocketIOConfig) -> List[int]:
+    """Get list of ports to try for server discovery."""
+    base_port = config.port
+    return [base_port, base_port + 1, base_port + 2, base_port + 3, base_port + 4]
+
+
+def get_discovery_hosts(config: SocketIOConfig) -> List[str]:
+    """Get list of hosts to try for server discovery."""
+    if config.host == "0.0.0.0":
+        # If server binds to all interfaces, try localhost and 127.0.0.1 for discovery
+        return ["localhost", "127.0.0.1"]
+    else:
+        return [config.host, "localhost", "127.0.0.1"]

claude_mpm/constants.py

@@ -27,6 +27,7 @@ class CLICommands(str, Enum):
     INFO = "info"
     AGENTS = "agents"
     UI = "ui"
+    MEMORY = "memory"
     
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""
@@ -55,6 +56,14 @@ class AgentCommands(str, Enum):
     CLEAN = "clean"
 
 
+class MemoryCommands(str, Enum):
+    """Memory subcommand constants."""
+    STATUS = "status"
+    VIEW = "view"
+    ADD = "add"
+    CLEAN = "clean"
+
+
 class CLIFlags(str, Enum):
     """CLI flag constants (without prefix)."""
     # Logging flags

claude_mpm/core/__init__.py

@@ -1,6 +1,6 @@
 """Core components for Claude MPM."""
 
-from .simple_runner import SimpleClaudeRunner
+from .claude_runner import ClaudeRunner
 from .mixins import LoggerMixin
 
 # Import config components if needed
@@ -24,7 +24,7 @@ except ImportError:
     pass
 
 __all__ = [
-    "SimpleClaudeRunner",
+    "ClaudeRunner",
     "LoggerMixin",
     "Config",
     "ConfigAliases",

claude_mpm/core/agent_registry.py

@@ -20,10 +20,10 @@ import importlib.util
 from datetime import datetime
 from dataclasses import dataclass
 
-from claude_mpm.utils.imports import safe_import
-
-# Import logger using safe_import pattern
-get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+try:
+    from ..core.logger import get_logger
+except ImportError:
+    from core.logger import get_logger
 
 
 @dataclass