claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/config/socketio_config.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """Socket.IO server configuration for different deployment scenarios.
 
 This module provides configuration management for Socket.IO servers
@@ -12,66 +14,69 @@ WHY configuration management:
 
 import os
 from dataclasses import dataclass
-from pathlib import Path
-from typing import Dict, Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 # Import constants for default values
-from claude_mpm.core.constants import NetworkConfig, SystemLimits, RetryConfig
+from claude_mpm.core.constants import NetworkConfig, RetryConfig, SystemLimits
 
 
 @dataclass
 class SocketIOConfig:
     """Configuration for Socket.IO server instances."""
-    
+
     # Server settings
     host: str = "localhost"
     port: int = NetworkConfig.DEFAULT_DASHBOARD_PORT
     server_id: Optional[str] = None
-    
+
     # Connection settings
     cors_allowed_origins: str = "*"  # Configure properly for production
     ping_timeout: int = NetworkConfig.PING_TIMEOUT_STANDARD
     ping_interval: int = NetworkConfig.PING_INTERVAL_STANDARD
     max_http_buffer_size: int = 1000000
-    
+
     # Compatibility settings
     min_client_version: str = "0.7.0"
     max_history_size: int = SystemLimits.MAX_EVENT_HISTORY
-    
+
     # 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 = RetryConfig.MAX_CONNECTION_RETRIES
     reconnection_delay: int = 1
-    
+
     @classmethod
-    def from_env(cls) -> 'SocketIOConfig':
+    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'))
+            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':
+    def for_development(cls) -> "SocketIOConfig":
         """Configuration optimized for development."""
         return cls(
             host="localhost",
@@ -80,11 +85,11 @@ class SocketIOConfig:
             log_level="DEBUG",
             ping_timeout=30,
             ping_interval=10,
-            max_history_size=5000
+            max_history_size=5000,
         )
-    
+
     @classmethod
-    def for_production(cls) -> 'SocketIOConfig':
+    def for_production(cls) -> "SocketIOConfig":
         """Configuration optimized for production."""
         return cls(
             host="0.0.0.0",  # Bind to all interfaces in production
@@ -97,11 +102,11 @@ class SocketIOConfig:
             log_file_path="/var/log/claude-mpm-socketio.log",
             ping_timeout=120,
             ping_interval=30,
-            max_history_size=20000
+            max_history_size=20000,
         )
-    
+
     @classmethod
-    def for_docker(cls) -> 'SocketIOConfig':
+    def for_docker(cls) -> "SocketIOConfig":
         """Configuration optimized for Docker deployment."""
         return cls(
             host="0.0.0.0",
@@ -111,36 +116,36 @@ class SocketIOConfig:
             log_level="INFO",
             ping_timeout=90,
             ping_interval=25,
-            max_history_size=15000
+            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
+            "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 = [
@@ -148,34 +153,38 @@ class ConfigManager:
             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'):
+        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':
+        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):
+            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()
@@ -185,49 +194,51 @@ class ConfigManager:
             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
+            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:
+                    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:
+            with open(path, "w") as f:
                 json.dump(config.to_dict(), f, indent=2)
             return True
         except Exception as e:
@@ -256,4 +267,4 @@ def get_discovery_hosts(config: SocketIOConfig) -> List[str]:
         # 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"]
+        return [config.host, "localhost", "127.0.0.1"]

claude_mpm/constants.py

@@ -1,16 +1,18 @@
 """Constants for Claude MPM."""
 
 from enum import Enum
+from pathlib import Path
 
 
 class CLIPrefix(str, Enum):
     """CLI command prefix constants."""
+
     MPM = "--mpm:"
-    
+
     def __add__(self, other: str) -> str:
         """Allow prefix + command concatenation."""
         return self.value + other
-    
+
     def wrap(self, flag: str) -> str:
         """Wrap a flag with the prefix."""
         if flag.startswith("--"):
@@ -22,6 +24,7 @@ class CLIPrefix(str, Enum):
 
 class CLICommands(str, Enum):
     """CLI command constants."""
+
     RUN = "run"
     RUN_GUARDED = "run-guarded"
     TICKETS = "tickets"
@@ -33,28 +36,29 @@ class CLICommands(str, Enum):
     AGGREGATE = "aggregate"
     CLEANUP = "cleanup-memory"
     MCP = "mcp"
-    
+
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""
         return prefix + self.value
-    
+
     @classmethod
     def get_mpm_commands(cls) -> list[str]:
         """Get list of MPM-specific commands with prefix."""
         return [cmd.with_prefix() for cmd in cls]
-    
+
     @classmethod
     def is_mpm_command(cls, command: str) -> bool:
         """Check if a command is an MPM command."""
         # Check both with and without prefix
         if command.startswith(CLIPrefix.MPM.value):
-            base_command = command[len(CLIPrefix.MPM.value):]
+            base_command = command[len(CLIPrefix.MPM.value) :]
             return base_command in [cmd.value for cmd in cls]
         return command in [cmd.value for cmd in cls]
 
 
 class AgentCommands(str, Enum):
     """Agent subcommand constants."""
+
     LIST = "list"
     VIEW = "view"
     FIX = "fix"
@@ -65,6 +69,7 @@ class AgentCommands(str, Enum):
 
 class MemoryCommands(str, Enum):
     """Memory subcommand constants."""
+
     INIT = "init"
     STATUS = "status"
     VIEW = "view"
@@ -79,14 +84,17 @@ class MemoryCommands(str, Enum):
 
 class MonitorCommands(str, Enum):
     """Monitor subcommand constants."""
+
     START = "start"
     STOP = "stop"
     RESTART = "restart"
+    STATUS = "status"
     PORT = "port"
 
 
 class ConfigCommands(str, Enum):
     """Config subcommand constants."""
+
     VALIDATE = "validate"
     VIEW = "view"
     STATUS = "status"
@@ -94,6 +102,7 @@ class ConfigCommands(str, Enum):
 
 class AggregateCommands(str, Enum):
     """Event aggregator subcommand constants."""
+
     START = "start"
     STOP = "stop"
     STATUS = "status"
@@ -104,6 +113,7 @@ class AggregateCommands(str, Enum):
 
 class MCPCommands(str, Enum):
     """MCP Gateway subcommand constants."""
+
     INSTALL = "install"
     START = "start"
     STOP = "stop"
@@ -116,6 +126,7 @@ class MCPCommands(str, Enum):
 
 class TicketCommands(str, Enum):
     """Ticket subcommand constants."""
+
     CREATE = "create"
     LIST = "list"
     VIEW = "view"
@@ -129,33 +140,34 @@ class TicketCommands(str, Enum):
 
 class CLIFlags(str, Enum):
     """CLI flag constants (without prefix)."""
+
     # Logging flags
     DEBUG = "debug"
     LOGGING = "logging"
     LOG_DIR = "log-dir"
-    
+
     # Framework flags
     FRAMEWORK_PATH = "framework-path"
     AGENTS_DIR = "agents-dir"
-    
+
     # Hook flags
     NO_HOOKS = "no-hooks"
-    
+
     # Ticket flags
     NO_TICKETS = "no-tickets"
-    
+
     # Input/output flags
     INPUT = "input"
     NON_INTERACTIVE = "non-interactive"
-    
+
     # Orchestration flags
     SUBPROCESS = "subprocess"
     INTERACTIVE_SUBPROCESS = "interactive-subprocess"
     TODO_HIJACK = "todo-hijack"
-    
+
     # Agent flags
     NO_NATIVE_AGENTS = "no-native-agents"
-    
+
     def with_prefix(self, short: bool = False) -> str:
         """Get flag with MPM prefix."""
         prefix = CLIPrefix.MPM.value
@@ -167,6 +179,7 @@ class CLIFlags(str, Enum):
 
 class LogLevel(str, Enum):
     """Logging level constants."""
+
     OFF = "OFF"
     INFO = "INFO"
     DEBUG = "DEBUG"
@@ -174,6 +187,7 @@ class LogLevel(str, Enum):
 
 class OrchestratorMode(str, Enum):
     """Orchestrator mode constants."""
+
     SYSTEM_PROMPT = "system_prompt"
     SUBPROCESS = "subprocess"
     INTERACTIVE_SUBPROCESS = "interactive_subprocess"
@@ -181,11 +195,12 @@ class OrchestratorMode(str, Enum):
 
 class EnvironmentVars(str, Enum):
     """Environment variable constants."""
+
     CLAUDE_CONFIG_DIR = "CLAUDE_CONFIG_DIR"
     CLAUDE_MAX_PARALLEL_SUBAGENTS = "CLAUDE_MAX_PARALLEL_SUBAGENTS"
     CLAUDE_TIMEOUT = "CLAUDE_TIMEOUT"
     CLAUDE_MPM_DEBUG = "CLAUDE_MPM_DEBUG"
-    
+
     # Default values
     DEFAULT_MAX_AGENTS = "10"
     DEFAULT_TIMEOUT = "600000"  # 10 minutes in milliseconds
@@ -193,15 +208,17 @@ class EnvironmentVars(str, Enum):
 
 class Paths(str, Enum):
     """Path constants."""
+
     CLAUDE_AGENTS_DIR = ".claude/agents"
     CLAUDE_CONFIG_DIR = ".claude"
     MPM_LOG_DIR = ".claude-mpm/logs"
     MPM_SESSION_DIR = ".claude-mpm/session"
     MPM_PROMPTS_DIR = ".claude-mpm/prompts"
-    
-    
+
+
 class AgentMetadata(str, Enum):
     """Agent metadata field constants."""
+
     NAME = "name"
     DESCRIPTION = "description"
     VERSION = "version"
@@ -212,11 +229,11 @@ class AgentMetadata(str, Enum):
     TIMEOUT = "timeout"
     MAX_TOKENS = "max_tokens"
     TEMPERATURE = "temperature"
-    
+
     # Default values
     DEFAULT_AUTHOR = "claude-mpm"
     DEFAULT_VERSION = "1.0.0"
     DEFAULT_PRIORITY = "medium"
     DEFAULT_TIMEOUT = 600
     DEFAULT_MAX_TOKENS = 8192
-    DEFAULT_TEMPERATURE = 0.5
+    DEFAULT_TEMPERATURE = 0.5

claude_mpm/core/__init__.py

@@ -1,17 +1,20 @@
 """Core components for Claude MPM."""
 
 from .claude_runner import ClaudeRunner
-from .mixins import LoggerMixin
 from .config import Config
 
 # Import DI components
 from .container import DIContainer, ServiceLifetime, get_container
-from .service_registry import ServiceRegistry, get_service_registry, initialize_services
-from .injectable_service import InjectableService
 from .factories import (
-    ServiceFactory, AgentServiceFactory, SessionManagerFactory, 
-    ConfigurationFactory, get_factory_registry
+    AgentServiceFactory,
+    ConfigurationFactory,
+    ServiceFactory,
+    SessionManagerFactory,
+    get_factory_registry,
 )
+from .injectable_service import InjectableService
+from .mixins import LoggerMixin
+from .service_registry import ServiceRegistry, get_service_registry, initialize_services
 
 __all__ = [
     "ClaudeRunner",
@@ -29,4 +32,4 @@ __all__ = [
     "SessionManagerFactory",
     "ConfigurationFactory",
     "get_factory_registry",
-]
+]