claude-mpm 4.0.20__py3-none-any.whl → 4.0.22__py3-none-any.whl

claude_mpm/cli/commands/mcp_install_commands.py

@@ -18,17 +18,17 @@ class MCPInstallCommands:
 
     def install_gateway(self, args):
         """Install and configure MCP gateway.
-        
+
         WHY: This command installs the MCP package dependencies and configures
-        Claude Desktop to use the MCP gateway server.
-        
+        Claude Desktop to use the MCP gateway server directly via the CLI command.
+
         DESIGN DECISION: We handle both package installation and configuration
-        in one command for user convenience.
+        in one command for user convenience, using the new direct CLI approach.
         """
         self.logger.info("MCP gateway installation command called")
         print("📦 Installing and Configuring MCP Gateway")
         print("=" * 50)
-        
+
         # Step 1: Install MCP package if needed
         print("\n1️⃣  Checking MCP package installation...")
         try:
@@ -43,35 +43,216 @@ class MCPInstallCommands:
                 print(f"❌ Error installing MCP package: {e}")
                 print("\nPlease install manually with: pip install mcp")
                 return 1
-        
-        # Step 2: Run the configuration script
+
+        # Step 2: Configure Claude Desktop with the new CLI command
         print("\n2️⃣  Configuring Claude Desktop...")
-        project_root = Path(__file__).parent.parent.parent.parent.parent
-        config_script = project_root / "scripts" / "configure_mcp_server.py"
-        
-        if not config_script.exists():
-            print(f"⚠️  Configuration script not found at {config_script}")
-            print("\nPlease configure manually. See:")
-            print("  claude-mpm mcp start --instructions")
-            return 1
-        
         try:
-            result = subprocess.run(
-                [sys.executable, str(config_script)],
-                cwd=str(project_root)
-            )
-            
-            if result.returncode == 0:
+            success = self._configure_claude_desktop(args.force)
+            if success:
                 print("✅ Configuration completed successfully")
                 print("\n🎉 MCP Gateway is ready to use!")
                 print("\nNext steps:")
                 print("1. Restart Claude Desktop")
-                print("2. Check process status: python scripts/check_mcp_processes.py")
+                print("2. Test the server: claude-mpm mcp server --test")
+                print("3. Check status: claude-mpm mcp status")
                 return 0
             else:
-                print("❌ Configuration script failed")
+                print("❌ Configuration failed")
                 return 1
-                
+
         except Exception as e:
-            print(f"❌ Error running configuration: {e}")
+            print(f"❌ Error during configuration: {e}")
             return 1
+
+    def _configure_claude_desktop(self, force=False):
+        """Configure Claude Desktop to use the MCP gateway via CLI command.
+
+        Args:
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            bool: True if configuration was successful
+        """
+        import json
+        import platform
+        from pathlib import Path
+        from datetime import datetime
+
+        # Determine Claude Desktop config path based on platform
+        config_path = self._get_claude_config_path()
+        if not config_path:
+            print("❌ Could not determine Claude Desktop configuration path")
+            return False
+
+        print(f"   Configuration path: {config_path}")
+
+        # Load existing configuration or create new one
+        config = self._load_or_create_config(config_path, force)
+        if config is None:
+            return False
+
+        # Configure the claude-mpm-gateway server using the CLI command
+        claude_mpm_path = self._find_claude_mpm_executable()
+        if not claude_mpm_path:
+            print("❌ Could not find claude-mpm executable")
+            return False
+
+        mcp_config = {
+            "command": claude_mpm_path,
+            "args": ["mcp", "server"],
+            "env": {
+                "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                "MCP_MODE": "production"
+            }
+        }
+
+        # Update configuration
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        config["mcpServers"]["claude-mpm-gateway"] = mcp_config
+
+        print("\n✅ Configured claude-mpm-gateway server:")
+        print(f"   Command: {mcp_config['command']}")
+        print(f"   Args: {mcp_config['args']}")
+        print(f"   Environment variables: {list(mcp_config['env'].keys())}")
+
+        # Save configuration
+        return self._save_config(config, config_path)
+
+    def _get_claude_config_path(self):
+        """Get the Claude Desktop configuration file path based on platform.
+
+        Returns:
+            Path or None: Path to Claude Desktop config file
+        """
+        import platform
+        from pathlib import Path
+
+        system = platform.system()
+
+        if system == "Darwin":  # macOS
+            return Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+        elif system == "Windows":
+            return Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
+        elif system == "Linux":
+            return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+        else:
+            print(f"❌ Unsupported platform: {system}")
+            return None
+
+    def _find_claude_mpm_executable(self):
+        """Find the claude-mpm executable path.
+
+        Returns:
+            str or None: Path to claude-mpm executable
+        """
+        import shutil
+        import sys
+
+        # Try to find claude-mpm in PATH
+        claude_mpm_path = shutil.which("claude-mpm")
+        if claude_mpm_path:
+            return claude_mpm_path
+
+        # If not in PATH, try using python -m claude_mpm
+        # This works if claude-mpm is installed in the current Python environment
+        try:
+            import claude_mpm
+            return f"{sys.executable} -m claude_mpm"
+        except ImportError:
+            pass
+
+        # Last resort: try relative to current script
+        project_root = Path(__file__).parent.parent.parent.parent.parent
+        local_script = project_root / "scripts" / "claude-mpm"
+        if local_script.exists():
+            return str(local_script)
+
+        return None
+
+    def _load_or_create_config(self, config_path, force=False):
+        """Load existing configuration or create a new one.
+
+        Args:
+            config_path: Path to configuration file
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            dict or None: Configuration dictionary
+        """
+        import json
+        from datetime import datetime
+
+        config = {}
+
+        if config_path.exists():
+            if not force:
+                # Check if claude-mpm-gateway already exists
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+
+                    if (existing_config.get("mcpServers", {}).get("claude-mpm-gateway") and
+                        not force):
+                        print("⚠️  claude-mpm-gateway is already configured")
+                        response = input("Do you want to overwrite it? (y/N): ").strip().lower()
+                        if response not in ['y', 'yes']:
+                            print("❌ Configuration cancelled")
+                            return None
+
+                    config = existing_config
+
+                except (json.JSONDecodeError, IOError) as e:
+                    print(f"⚠️  Error reading existing config: {e}")
+                    print("Creating backup and starting fresh...")
+
+                    # Create backup
+                    backup_path = config_path.with_suffix(f'.backup.{datetime.now().strftime("%Y%m%d_%H%M%S")}.json')
+                    try:
+                        config_path.rename(backup_path)
+                        print(f"   Backup created: {backup_path}")
+                    except Exception as backup_error:
+                        print(f"   Warning: Could not create backup: {backup_error}")
+            else:
+                # Force mode - create backup but proceed
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+                    config = existing_config
+                    print("   Force mode: Overwriting existing configuration")
+                except:
+                    pass  # File doesn't exist or is invalid, start fresh
+
+        # Ensure mcpServers section exists
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        return config
+
+    def _save_config(self, config, config_path):
+        """Save configuration to file.
+
+        Args:
+            config: Configuration dictionary
+            config_path: Path to save configuration
+
+        Returns:
+            bool: True if successful
+        """
+        import json
+
+        try:
+            # Ensure directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write configuration with nice formatting
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+
+            print(f"\n✅ Configuration saved to {config_path}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Error saving configuration: {e}")
+            return False

claude_mpm/cli/parsers/mcp_parser.py

@@ -149,4 +149,27 @@ def add_mcp_subparser(subparsers) -> argparse.ArgumentParser:
         help="Configuration action (default: view)",
     )
 
+    # MCP Server command (direct server execution)
+    server_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.SERVER.value, help="Run the MCP Gateway server directly"
+    )
+    server_mcp_parser.add_argument(
+        "--mode",
+        choices=["stdio", "standalone"],
+        default="stdio",
+        help="Server mode: stdio for Claude integration, standalone for testing (default: stdio)",
+    )
+    server_mcp_parser.add_argument(
+        "--port",
+        type=int,
+        default=8766,
+        help="Port for standalone mode (default: 8766)",
+    )
+    server_mcp_parser.add_argument(
+        "--config-file", type=Path, help="Path to MCP configuration file"
+    )
+    server_mcp_parser.add_argument(
+        "--test", action="store_true", help="Run in test mode with debug output"
+    )
+
     return mcp_parser

claude_mpm/constants.py

@@ -125,6 +125,7 @@ class MCPCommands(str, Enum):
     REGISTER = "register"
     TEST = "test"
     CONFIG = "config"
+    SERVER = "server"
 
 
 class TicketCommands(str, Enum):

claude_mpm/core/base_service.py

@@ -120,7 +120,13 @@ class BaseService(LoggerMixin, ABC):
             container: Optional service container for dependency injection
         """
         self.name = name
-        self.config = Config(config or {}, config_path)
+        # Use singleton Config instance to prevent duplicate configuration loading
+        # Only pass config_path if it's different from what might already be loaded
+        if config_path:
+            self.config = Config(config or {}, config_path)
+        else:
+            # Use existing singleton instance without forcing reload
+            self.config = Config(config or {})
         self._enable_enhanced = enable_enhanced_features
         self._container = container
 

claude_mpm/core/config.py

@@ -8,6 +8,7 @@ and default values with proper validation and type conversion.
 import json
 import logging
 import os
+import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -37,16 +38,23 @@ class Config:
     _instance = None
     _initialized = False
     _success_logged = False  # Class-level flag to track if success message was already logged
+    _lock = threading.Lock()  # Thread safety for singleton initialization
 
     def __new__(cls, *args, **kwargs):
         """Implement singleton pattern to ensure single configuration instance.
         
         WHY: Configuration was being loaded 11 times during startup, once for each service.
         This singleton pattern ensures configuration is loaded only once and reused.
+        Thread-safe implementation prevents race conditions during concurrent initialization.
         """
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            logger.info("Creating new Config singleton instance")
+            with cls._lock:
+                # Double-check locking pattern for thread safety
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    logger.info("Creating new Config singleton instance")
+                else:
+                    logger.debug("Reusing existing Config singleton instance (concurrent init)")
         else:
             logger.debug("Reusing existing Config singleton instance")
         return cls._instance
@@ -66,6 +74,7 @@ class Config:
             env_prefix: Prefix for environment variables
         """
         # Skip initialization if already done (singleton pattern)
+        # Use thread-safe check to prevent concurrent initialization
         if Config._initialized:
             logger.debug("Config already initialized, skipping re-initialization")
             # If someone tries to load a different config file after initialization,
@@ -77,45 +86,52 @@ class Config:
                 )
             return
         
-        Config._initialized = True
-        logger.info("Initializing Config singleton for the first time")
-        
-        self._config: Dict[str, Any] = {}
-        self._env_prefix = env_prefix
-        self._config_mgr = ConfigurationManager(cache_enabled=True)
-
-        # Load base configuration
-        if config:
-            self._config.update(config)
-
-        # Track where configuration was loaded from
-        self._loaded_from = None
-        # Track the actual file we loaded from to prevent re-loading
-        self._actual_loaded_file = None
-
-        # Load from file if provided
-        if config_file:
-            self.load_file(config_file, is_initial_load=True)
-            self._loaded_from = str(config_file)
-        else:
-            # Try to load from standard location: .claude-mpm/configuration.yaml
-            default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
-            if default_config.exists():
-                self.load_file(default_config, is_initial_load=True)
-                self._loaded_from = str(default_config)
+        # Thread-safe initialization - acquire lock for ENTIRE initialization process
+        with Config._lock:
+            # Double-check pattern - check again inside the lock
+            if Config._initialized:
+                logger.debug("Config already initialized (concurrent), skipping re-initialization")
+                return
+            
+            Config._initialized = True
+            logger.info("Initializing Config singleton for the first time")
+            
+            # Initialize instance variables inside the lock to ensure thread safety
+            self._config: Dict[str, Any] = {}
+            self._env_prefix = env_prefix
+            self._config_mgr = ConfigurationManager(cache_enabled=True)
+
+            # Load base configuration
+            if config:
+                self._config.update(config)
+
+            # Track where configuration was loaded from
+            self._loaded_from = None
+            # Track the actual file we loaded from to prevent re-loading
+            self._actual_loaded_file = None
+
+            # Load from file if provided
+            # Note: Only ONE config file should be loaded, and success message shown only once
+            if config_file:
+                self.load_file(config_file, is_initial_load=True)
+                self._loaded_from = str(config_file)
             else:
-                # Also try .yml extension
-                alt_config = Path.cwd() / ".claude-mpm" / "configuration.yml"
-                if alt_config.exists():
+                # Try to load from standard location: .claude-mpm/configuration.yaml
+                default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+                if default_config.exists():
+                    self.load_file(default_config, is_initial_load=True)
+                    self._loaded_from = str(default_config)
+                elif (alt_config := Path.cwd() / ".claude-mpm" / "configuration.yml").exists():
+                    # Also try .yml extension (using walrus operator for cleaner code)
                     self.load_file(alt_config, is_initial_load=True)
                     self._loaded_from = str(alt_config)
 
-        # Load from environment variables (new and legacy prefixes)
-        self._load_env_vars()
-        self._load_legacy_env_vars()
+            # Load from environment variables (new and legacy prefixes)
+            self._load_env_vars()
+            self._load_legacy_env_vars()
 
-        # Apply defaults
-        self._apply_defaults()
+            # Apply defaults
+            self._apply_defaults()
 
     def load_file(self, file_path: Union[str, Path], is_initial_load: bool = True) -> None:
         """Load configuration from file with enhanced error handling.
@@ -161,11 +177,20 @@ class Config:
                 self._config = self._config_mgr.merge_configs(self._config, file_config)
                 # Track that we've successfully loaded from this file
                 self._actual_loaded_file = str(file_path)
+                
                 # Only log success message once using class-level flag to avoid duplicate messages
-                if is_initial_load and not Config._success_logged:
-                    logger.info(f"✓ Successfully loaded configuration from {file_path}")
-                    Config._success_logged = True
+                # Check if we should log success message (thread-safe for reads after initialization)
+                if is_initial_load:
+                    if not Config._success_logged:
+                        # Set flag IMMEDIATELY before logging to prevent any possibility of duplicate
+                        # messages. No lock needed here since we're already inside __init__ lock
+                        Config._success_logged = True
+                        logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                    else:
+                        # Configuration already successfully loaded before, just debug log
+                        logger.debug(f"Configuration already loaded, skipping success message for {file_path}")
                 else:
+                    # Not initial load (shouldn't happen in normal flow, but handle gracefully)
                     logger.debug(f"Configuration reloaded from {file_path}")
 
                 # Log important configuration values for debugging

claude_mpm/core/framework_loader.py

@@ -489,9 +489,25 @@ class FrameworkLoader:
                 memory_size = len(memory_content.encode('utf-8'))
                 self.logger.debug(f"Aggregated {agent_name} memory: {memory_size:,} bytes")
         
-        # Log summary
+        # Log detailed summary
         if loaded_count > 0 or skipped_count > 0:
-            self.logger.info(f"Memory loading complete: {loaded_count} memories loaded, {skipped_count} skipped")
+            # Count unique agents with memories
+            agent_count = len(agent_memories_dict) if agent_memories_dict else 0
+            pm_loaded = bool(content.get("actual_memories"))
+            
+            summary_parts = []
+            if pm_loaded:
+                summary_parts.append("PM memory loaded")
+            if agent_count > 0:
+                summary_parts.append(f"{agent_count} agent memories loaded")
+            if skipped_count > 0:
+                summary_parts.append(f"{skipped_count} non-deployed agent memories skipped")
+            
+            self.logger.info(f"Memory loading complete: {' | '.join(summary_parts)}")
+            
+            # Log deployed agents for reference
+            if len(deployed_agents) > 0:
+                self.logger.debug(f"Deployed agents available for memory loading: {', '.join(sorted(deployed_agents))}")
     
     def _load_memories_from_directory(
         self,
@@ -544,36 +560,36 @@ class FrameworkLoader:
                 self.logger.info(f"Loaded {source} PM memory: {pm_memory_path} ({memory_size:,} bytes)")
                 loaded_count += 1
         
-        # Load agent memories (only for deployed agents)
-        for memory_file in memories_dir.glob("*.md"):
-            # Skip PM_memories.md and PM.md as we already handled them
-            if memory_file.name in ["PM_memories.md", "PM.md"]:
+        # First, migrate any old format memory files to new format
+        # This handles backward compatibility for existing installations
+        for old_file in memories_dir.glob("*.md"):
+            # Skip files already in correct format and special files
+            if old_file.name.endswith("_memories.md") or old_file.name in ["PM.md", "README.md"]:
                 continue
             
-            # Extract agent name from file
-            # Support migration from old formats to new {agent_name}_memories.md format
-            agent_name = memory_file.stem
-            new_path = None
-            
-            if agent_name.endswith("_agent"):
-                # Old format: {agent_name}_agent.md
-                agent_name = agent_name[:-6]  # Remove "_agent" suffix
+            # Determine new name based on old format
+            if old_file.stem.endswith("_agent"):
+                # Old format: {agent_name}_agent.md -> {agent_name}_memories.md
+                agent_name = old_file.stem[:-6]  # Remove "_agent" suffix
                 new_path = memories_dir / f"{agent_name}_memories.md"
-            elif agent_name.endswith("_memories"):
-                # Already in new format: {agent_name}_memories.md
-                agent_name = agent_name[:-9]  # Remove "_memories" suffix
-            elif memory_file.name != "README.md":
-                # Intermediate format: {agent_name}.md
-                # agent_name already set from stem
+                if not new_path.exists():
+                    self._migrate_memory_file(old_file, new_path)
+            else:
+                # Intermediate format: {agent_name}.md -> {agent_name}_memories.md
+                agent_name = old_file.stem
                 new_path = memories_dir / f"{agent_name}_memories.md"
-            
-            # Skip README.md
-            if memory_file.name == "README.md":
+                if not new_path.exists():
+                    self._migrate_memory_file(old_file, new_path)
+        
+        # Load agent memories (only for deployed agents)
+        # Only process *_memories.md files to avoid README.md and other docs
+        for memory_file in memories_dir.glob("*_memories.md"):
+            # Skip PM_memories.md as we already handled it
+            if memory_file.name == "PM_memories.md":
                 continue
-                
-            # Migrate if needed
-            if new_path and not new_path.exists():
-                self._migrate_memory_file(memory_file, new_path)
+            
+            # Extract agent name from file (remove "_memories" suffix)
+            agent_name = memory_file.stem[:-9]  # Remove "_memories" suffix
             
             # Check if agent is deployed
             if agent_name in deployed_agents:
@@ -597,7 +613,17 @@ class FrameworkLoader:
                     self.logger.info(f"Loaded {source} memory for {agent_name}: {memory_file.name} ({memory_size:,} bytes)")
                     loaded_count += 1
             else:
-                self.logger.info(f"Skipped {source} memory: {memory_file.name} (agent not deployed)")
+                # Provide more detailed logging about why the memory was skipped
+                self.logger.info(f"Skipped {source} memory: {memory_file.name} (agent '{agent_name}' not deployed)")
+                # Also log a debug message with available agents for diagnostics
+                if agent_name.replace('_', '-') in deployed_agents or agent_name.replace('-', '_') in deployed_agents:
+                    # Detect naming mismatches
+                    alt_name = agent_name.replace('_', '-') if '_' in agent_name else agent_name.replace('-', '_')
+                    if alt_name in deployed_agents:
+                        self.logger.warning(
+                            f"Naming mismatch detected: Memory file uses '{agent_name}' but deployed agent is '{alt_name}'. "
+                            f"Consider renaming {memory_file.name} to {alt_name}_memories.md"
+                        )
                 skipped_count += 1
         
         # After loading all memories for this directory, aggregate agent memories
@@ -1075,6 +1101,20 @@ class FrameworkLoader:
                 instructions += "**The following are your accumulated memories and knowledge from this project:**\n\n"
                 instructions += self.framework_content["actual_memories"]
                 instructions += "\n"
+            
+            # Add agent memories if available
+            if self.framework_content.get("agent_memories"):
+                agent_memories = self.framework_content["agent_memories"]
+                if agent_memories:
+                    instructions += "\n\n## Agent Memories\n\n"
+                    instructions += "**The following are accumulated memories from specialized agents:**\n\n"
+                    
+                    for agent_name in sorted(agent_memories.keys()):
+                        memory_content = agent_memories[agent_name]
+                        if memory_content:
+                            instructions += f"### {agent_name.replace('_', ' ').title()} Agent Memory\n\n"
+                            instructions += memory_content
+                            instructions += "\n\n"
 
             # Add dynamic agent capabilities section
             instructions += self._generate_agent_capabilities_section()

claude_mpm/core/interactive_session.py

@@ -344,25 +344,36 @@ class InteractiveSession:
 
     def _build_claude_command(self) -> list:
         """Build the Claude command with all necessary arguments."""
-        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        # Check if --resume flag is present
+        has_resume = self.runner.claude_args and "--resume" in self.runner.claude_args
 
-        # Add custom arguments
-        if self.runner.claude_args:
-            # Enhanced debug logging for --resume flag verification
-            self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
-            
-            # Check explicitly for --resume flag
-            has_resume = "--resume" in self.runner.claude_args
-            self.logger.info(f"--resume flag present in claude_args: {has_resume}")
-            
-            cmd.extend(self.runner.claude_args)
-            
-        # Add system instructions
-        from claude_mpm.core.claude_runner import create_simple_context
+        if has_resume:
+            # When resuming, use minimal command to avoid interfering with conversation selection
+            self.logger.info("🔄 Resume mode detected - using minimal Claude command to preserve conversation selection")
+            cmd = ["claude"]
+
+            # Add only the claude_args (which includes --resume)
+            if self.runner.claude_args:
+                cmd.extend(self.runner.claude_args)
+                self.logger.info(f"Resume command: {cmd}")
+
+            return cmd
+        else:
+            # Normal mode - full command with all claude-mpm enhancements
+            cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+
+            # Add custom arguments
+            if self.runner.claude_args:
+                # Enhanced debug logging for --resume flag verification
+                self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
+                cmd.extend(self.runner.claude_args)
+
+            # Add system instructions
+            from claude_mpm.core.claude_runner import create_simple_context
 
-        system_prompt = self.runner._create_system_prompt()
-        if system_prompt and system_prompt != create_simple_context():
-            cmd.extend(["--append-system-prompt", system_prompt])
+            system_prompt = self.runner._create_system_prompt()
+            if system_prompt and system_prompt != create_simple_context():
+                cmd.extend(["--append-system-prompt", system_prompt])
 
         # Final command verification
         # self.logger.info(f"Final Claude command built: {' '.join(cmd)}")