claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -20,34 +20,33 @@ DESIGN DECISIONS:
 import json
 import os
 import sys
-import time
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Dict, Any, Tuple
+from typing import Any, Dict, Optional
 
-from claude_mpm.core.logger import get_logger
 from claude_mpm.config.paths import paths
+from claude_mpm.core.logger import get_logger
 
 
 class MCPAutoConfigurator:
     """
     Handles automatic MCP configuration for pipx installations.
-    
+
     Provides a one-time prompt to configure MCP Gateway with user consent,
     making the experience seamless for pipx users while respecting choice.
     """
-    
+
     def __init__(self):
         """Initialize the auto-configurator."""
         self.logger = get_logger("MCPAutoConfig")
         self.config_dir = paths.claude_mpm_dir_hidden
         self.preference_file = self.config_dir / "mcp_auto_config_preference.json"
         self.claude_config_path = Path.home() / ".claude.json"
-        
+
     def should_auto_configure(self) -> bool:
         """
         Check if auto-configuration should be attempted.
-        
+
         Returns:
             True if auto-configuration should be offered, False otherwise
         """
@@ -55,120 +54,118 @@ class MCPAutoConfigurator:
         if os.environ.get("CLAUDE_MPM_NO_AUTO_CONFIG"):
             self.logger.debug("Auto-configuration disabled via environment variable")
             return False
-        
+
         # Check if already configured
         if self._is_mcp_configured():
             self.logger.debug("MCP already configured")
             return False
-        
+
         # Check if this is a pipx installation
         if not self._is_pipx_installation():
             self.logger.debug("Not a pipx installation")
             return False
-        
+
         # Check if we've already asked
         if self._has_user_preference():
             self.logger.debug("User preference already saved")
             return False
-        
+
         return True
-    
+
     def _is_mcp_configured(self) -> bool:
         """Check if MCP is already configured in Claude Code."""
         if not self.claude_config_path.exists():
             return False
-        
+
         try:
-            with open(self.claude_config_path, 'r') as f:
+            with open(self.claude_config_path) as f:
                 config = json.load(f)
-            
+
             # Check if claude-mpm-gateway is configured
             mcp_servers = config.get("mcpServers", {})
             return "claude-mpm-gateway" in mcp_servers
-            
-        except (json.JSONDecodeError, IOError):
+
+        except (OSError, json.JSONDecodeError):
             return False
-    
+
     def _is_pipx_installation(self) -> bool:
         """Check if claude-mpm is installed via pipx."""
         # Check if running from pipx virtual environment
         if "pipx" in sys.executable.lower():
             return True
-        
+
         # Check module path
         try:
             import claude_mpm
+
             module_path = Path(claude_mpm.__file__).parent
             if "pipx" in str(module_path):
                 return True
         except Exception:
             pass
-        
+
         # Check for pipx in PATH for claude-mpm command
         try:
-            import subprocess
             import platform
-            
+            import subprocess
+
             # Use appropriate command for OS
             if platform.system() == "Windows":
                 cmd = ["where", "claude-mpm"]
             else:
                 cmd = ["which", "claude-mpm"]
-            
+
             result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=2
+                cmd, capture_output=True, text=True, timeout=2, check=False
             )
             if result.returncode == 0 and "pipx" in result.stdout:
                 return True
         except Exception:
             pass
-        
+
         return False
-    
+
     def _has_user_preference(self) -> bool:
         """Check if user has already been asked about auto-configuration."""
         if not self.preference_file.exists():
             return False
-        
+
         try:
-            with open(self.preference_file, 'r') as f:
+            with open(self.preference_file) as f:
                 prefs = json.load(f)
             return prefs.get("asked", False)
-        except (json.JSONDecodeError, IOError):
+        except (OSError, json.JSONDecodeError):
             return False
-    
+
     def _save_user_preference(self, choice: str):
         """Save user's preference to avoid asking again."""
         self.config_dir.mkdir(parents=True, exist_ok=True)
-        
+
         prefs = {
             "asked": True,
             "choice": choice,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
-        
+
         try:
-            with open(self.preference_file, 'w') as f:
+            with open(self.preference_file, "w") as f:
                 json.dump(prefs, f, indent=2)
         except Exception as e:
             self.logger.debug(f"Could not save preference: {e}")
-    
+
     def prompt_user(self, timeout: int = 10) -> Optional[bool]:
         """
         Prompt user for auto-configuration with timeout.
-        
+
         Args:
             timeout: Seconds to wait for response (default 10)
-            
+
         Returns:
             True if user agrees, False if declines, None if timeout
         """
-        print("\n" + "="*60)
+        print("\n" + "=" * 60)
         print("🔧 MCP Gateway Configuration")
-        print("="*60)
+        print("=" * 60)
         print("\nClaude MPM can automatically configure MCP Gateway for")
         print("Claude Code integration. This enables advanced features:")
         print("  • File analysis and summarization")
@@ -177,48 +174,45 @@ class MCPAutoConfigurator:
         print("  • And more...")
         print("\nWould you like to configure it now? (y/n)")
         print(f"(Auto-declining in {timeout} seconds)")
-        
+
         # Use threading for cross-platform timeout support
         import threading
+
         try:
             # Python 3.7+ has queue built-in
             import queue
         except ImportError:
             # Python 2.x fallback
-            import Queue as queue
-        
+            pass
+
         user_input = None
-        
+
         def get_input():
             nonlocal user_input
             try:
                 user_input = input("> ").strip().lower()
             except (EOFError, KeyboardInterrupt):
-                user_input = 'n'
-        
+                user_input = "n"
+
         # Start input thread
         input_thread = threading.Thread(target=get_input)
         input_thread.daemon = True
         input_thread.start()
-        
+
         # Wait for input or timeout
         input_thread.join(timeout)
-        
+
         if input_thread.is_alive():
             # Timed out
             print("\n(Timed out - declining)")
             return None
-        else:
-            # Got input
-            if user_input in ['y', 'yes']:
-                return True
-            else:
-                return False
-    
+        # Got input
+        return user_input in ["y", "yes"]
+
     def auto_configure(self) -> bool:
         """
         Perform automatic MCP configuration.
-        
+
         Returns:
             True if configuration successful, False otherwise
         """
@@ -228,145 +222,143 @@ class MCPAutoConfigurator:
                 backup_path = self._create_backup()
                 if backup_path:
                     print(f"✅ Backup created: {backup_path}")
-            
+
             # Load or create configuration
             config = self._load_or_create_config()
-            
+
             # Add MCP Gateway configuration
             if "mcpServers" not in config:
                 config["mcpServers"] = {}
-            
+
             # Find claude-mpm executable
             executable = self._find_claude_mpm_executable()
             if not executable:
                 print("❌ Could not find claude-mpm executable")
                 return False
-            
+
             # Configure MCP server
             config["mcpServers"]["claude-mpm-gateway"] = {
                 "command": str(executable),
                 "args": ["mcp", "server"],
-                "env": {
-                    "MCP_MODE": "production"
-                }
+                "env": {"MCP_MODE": "production"},
             }
-            
+
             # Save configuration
-            with open(self.claude_config_path, 'w') as f:
+            with open(self.claude_config_path, "w") as f:
                 json.dump(config, f, indent=2)
-            
+
             print(f"✅ Configuration saved to: {self.claude_config_path}")
             print("\n🎉 MCP Gateway configured successfully!")
             print("\nNext steps:")
             print("1. Restart Claude Code (if running)")
             print("2. Look for the MCP icon in the interface")
             print("3. Try @claude-mpm-gateway in a conversation")
-            
+
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Auto-configuration failed: {e}")
             print(f"❌ Configuration failed: {e}")
             print("\nYou can configure manually with:")
             print("  claude-mpm mcp install")
             return False
-    
+
     def _create_backup(self) -> Optional[Path]:
         """Create backup of existing configuration."""
         try:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            backup_path = self.claude_config_path.with_suffix(f'.backup.{timestamp}.json')
-            
+            backup_path = self.claude_config_path.with_suffix(
+                f".backup.{timestamp}.json"
+            )
+
             import shutil
+
             shutil.copy2(self.claude_config_path, backup_path)
             return backup_path
-            
+
         except Exception as e:
             self.logger.debug(f"Could not create backup: {e}")
             return None
-    
+
     def _load_or_create_config(self) -> Dict[str, Any]:
         """Load existing config or create new one."""
         if self.claude_config_path.exists():
             try:
-                with open(self.claude_config_path, 'r') as f:
+                with open(self.claude_config_path) as f:
                     return json.load(f)
             except json.JSONDecodeError:
                 self.logger.warning("Existing config is invalid JSON, creating new")
-        
+
         return {}
-    
+
     def _find_claude_mpm_executable(self) -> Optional[str]:
         """Find the claude-mpm executable path."""
         # Try direct command first
-        import subprocess
         import platform
-        
+        import subprocess
+
         try:
             # Use appropriate command for OS
             if platform.system() == "Windows":
                 cmd = ["where", "claude-mpm"]
             else:
                 cmd = ["which", "claude-mpm"]
-            
+
             result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=2
+                cmd, capture_output=True, text=True, timeout=2, check=False
             )
             if result.returncode == 0:
                 executable_path = result.stdout.strip()
                 # On Windows, 'where' might return multiple paths
-                if platform.system() == "Windows" and '\n' in executable_path:
-                    executable_path = executable_path.split('\n')[0]
+                if platform.system() == "Windows" and "\n" in executable_path:
+                    executable_path = executable_path.split("\n")[0]
                 return executable_path
         except Exception:
             pass
-        
+
         # Try to find via shutil.which (more portable)
         import shutil
+
         claude_mpm_path = shutil.which("claude-mpm")
         if claude_mpm_path:
             return claude_mpm_path
-        
+
         # Fallback to Python module invocation
         return sys.executable
-    
+
     def run(self) -> bool:
         """
         Main entry point for auto-configuration.
-        
+
         Returns:
             True if configured (or already configured), False otherwise
         """
         if not self.should_auto_configure():
             return True  # Already configured or not applicable
-        
+
         # Prompt user
         user_choice = self.prompt_user()
-        
+
         # Save preference to not ask again
         self._save_user_preference("yes" if user_choice else "no")
-        
+
         if user_choice:
             return self.auto_configure()
-        else:
-            if user_choice is False:  # User explicitly said no
-                print("\n📝 You can configure MCP later with:")
-                print("  claude-mpm mcp install")
-            # If timeout (None), don't show additional message
-            return False
+        if user_choice is False:  # User explicitly said no
+            print("\n📝 You can configure MCP later with:")
+            print("  claude-mpm mcp install")
+        # If timeout (None), don't show additional message
+        return False
 
 
 def check_and_configure_mcp() -> bool:
     """
     Check and potentially configure MCP for pipx installations.
-    
+
     This is the main entry point called during CLI initialization.
-    
+
     Returns:
         True if MCP is configured (or configuration was successful), False otherwise
     """
     configurator = MCPAutoConfigurator()
-    return configurator.run()
+    return configurator.run()

claude_mpm/services/mcp_gateway/config/__init__.py

@@ -10,8 +10,8 @@ from .config_schema import MCPConfigSchema, validate_config
 from .configuration import MCPConfiguration
 
 __all__ = [
-    "MCPConfiguration",
     "MCPConfigLoader",
     "MCPConfigSchema",
+    "MCPConfiguration",
     "validate_config",
 ]

claude_mpm/services/mcp_gateway/config/config_loader.py

@@ -42,7 +42,7 @@ class MCPConfigLoader:
             ".mcp_gateway.yaml",
             ".mcp_gateway.yml",
             "config.yaml",
-            "config.yml"
+            "config.yml",
         ],
         search_paths=[
             "~/.claude/mcp",
@@ -50,15 +50,10 @@ class MCPConfigLoader:
             ".",
             "./config",
             "./.claude",
-            "/etc/claude-mpm"
+            "/etc/claude-mpm",
         ],
         env_prefix="CLAUDE_MPM_MCP_",
-        defaults={
-            "host": "localhost",
-            "port": 3000,
-            "debug": False,
-            "timeout": 30
-        }
+        defaults={"host": "localhost", "port": 3000, "debug": False, "timeout": 30},
     )
 
     def __init__(self):
@@ -102,7 +97,7 @@ class MCPConfigLoader:
                 self.logger.error(f"Configuration file not found: {expanded_path}")
                 return None
 
-            with open(expanded_path, "r") as f:
+            with open(expanded_path) as f:
                 config = yaml.safe_load(f)
 
             self.logger.info(f"Configuration loaded from {expanded_path}")
@@ -179,42 +174,44 @@ class MCPConfigLoader:
                 filenames=[config_path.name],
                 search_paths=[str(config_path.parent)],
                 env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
-                defaults=MCPConfiguration.DEFAULT_CONFIG.copy()
+                defaults=MCPConfiguration.DEFAULT_CONFIG.copy(),
             )
-            config_obj = self._shared_loader.load_config(pattern, cache_key=f"mcp_{config_path}")
-            return config_obj.to_dict()
-        else:
-            # Use standard MCP pattern with defaults
-            pattern = ConfigPattern(
-                filenames=self.MCP_CONFIG_PATTERN.filenames,
-                search_paths=self.MCP_CONFIG_PATTERN.search_paths,
-                env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
-                defaults=MCPConfiguration.DEFAULT_CONFIG.copy()
+            config_obj = self._shared_loader.load_config(
+                pattern, cache_key=f"mcp_{config_path}"
             )
-            config_obj = self._shared_loader.load_config(pattern, cache_key="mcp_gateway")
             return config_obj.to_dict()
+        # Use standard MCP pattern with defaults
+        pattern = ConfigPattern(
+            filenames=self.MCP_CONFIG_PATTERN.filenames,
+            search_paths=self.MCP_CONFIG_PATTERN.search_paths,
+            env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
+            defaults=MCPConfiguration.DEFAULT_CONFIG.copy(),
+        )
+        config_obj = self._shared_loader.load_config(pattern, cache_key="mcp_gateway")
+        return config_obj.to_dict()
 
     # Backward compatibility methods (deprecated)
     def find_config_file(self) -> Optional[Path]:
         """Find configuration file using legacy method (deprecated)."""
         import warnings
+
         warnings.warn(
             "find_config_file is deprecated. Use load() method instead.",
             DeprecationWarning,
-            stacklevel=2
+            stacklevel=2,
         )
 
         # Use shared loader to find config file
-        config_file = self._shared_loader._find_config_file(self.MCP_CONFIG_PATTERN)
-        return config_file
+        return self._shared_loader._find_config_file(self.MCP_CONFIG_PATTERN)
 
     def load_from_file(self, config_path: Path) -> Optional[dict]:
         """Load from file using legacy method (deprecated)."""
         import warnings
+
         warnings.warn(
             "load_from_file is deprecated. Use load() method instead.",
             DeprecationWarning,
-            stacklevel=2
+            stacklevel=2,
         )
 
         # Use shared loader
@@ -223,10 +220,11 @@ class MCPConfigLoader:
     def load_from_env(self, prefix: str = "CLAUDE_MPM_MCP_") -> dict:
         """Load from environment using legacy method (deprecated)."""
         import warnings
+
         warnings.warn(
             "load_from_env is deprecated. Use load() method instead.",
             DeprecationWarning,
-            stacklevel=2
+            stacklevel=2,
         )
 
         # Use shared loader

claude_mpm/services/mcp_gateway/config/config_schema.py

@@ -175,19 +175,19 @@ def validate_config(
             if expected_type == "object" and not isinstance(value, dict):
                 errors.append(f"{path}: Expected object, got {type(value).__name__}")
                 return
-            elif expected_type == "array" and not isinstance(value, list):
+            if expected_type == "array" and not isinstance(value, list):
                 errors.append(f"{path}: Expected array, got {type(value).__name__}")
                 return
-            elif expected_type == "string" and not isinstance(value, str):
+            if expected_type == "string" and not isinstance(value, str):
                 errors.append(f"{path}: Expected string, got {type(value).__name__}")
                 return
-            elif expected_type == "number" and not isinstance(value, (int, float)):
+            if expected_type == "number" and not isinstance(value, (int, float)):
                 errors.append(f"{path}: Expected number, got {type(value).__name__}")
                 return
-            elif expected_type == "integer" and not isinstance(value, int):
+            if expected_type == "integer" and not isinstance(value, int):
                 errors.append(f"{path}: Expected integer, got {type(value).__name__}")
                 return
-            elif expected_type == "boolean" and not isinstance(value, bool):
+            if expected_type == "boolean" and not isinstance(value, bool):
                 errors.append(f"{path}: Expected boolean, got {type(value).__name__}")
                 return
 

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -106,9 +106,8 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
         self._config_data = self.DEFAULT_CONFIG.copy()
 
         # Load from file if path provided
-        if self._config_path:
-            if not self.load_config(self._config_path):
-                return False
+        if self._config_path and not self.load_config(self._config_path):
+            return False
 
         # Apply environment variable overrides
         self._apply_env_overrides()
@@ -139,7 +138,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 self.log_warning(f"Configuration file not found: {config_path}")
                 return True  # Not an error, use defaults
 
-            with open(config_path, "r") as f:
+            with open(config_path) as f:
                 if config_path.suffix in [".yaml", ".yml"]:
                     loaded_config = yaml.safe_load(f) or {}
                 else:
@@ -384,7 +383,9 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
         # Revalidate
         return self.validate()
 
-    def get_config_with_validation(self, key: str, default: Any = None, config_type: type = None) -> Any:
+    def get_config_with_validation(
+        self, key: str, default: Any = None, config_type: Optional[type] = None
+    ) -> Any:
         """
         Get configuration value with validation using shared utilities.
 
@@ -397,7 +398,9 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
             Configuration value
         """
         try:
-            return self._config_helper.get_config_value(key, default, config_type=config_type)
+            return self._config_helper.get_config_value(
+                key, default, config_type=config_type
+            )
         except ValueError:
             # Fall back to standard get method
             return self.get(key, default)

claude_mpm/services/mcp_gateway/core/__init__.py

@@ -24,21 +24,21 @@ from .interfaces import (
 )
 
 __all__ = [
+    # Base classes
+    "BaseMCPService",
+    "IMCPCommunication",
+    "IMCPConfiguration",
     # Interfaces
     "IMCPGateway",
-    "IMCPToolRegistry",
-    "IMCPConfiguration",
-    "IMCPToolAdapter",
     "IMCPLifecycle",
-    "IMCPCommunication",
-    # Base classes
-    "BaseMCPService",
-    "MCPServiceState",
+    "IMCPToolAdapter",
+    "IMCPToolRegistry",
+    "MCPCommunicationError",
+    "MCPConfigurationError",
     # Exceptions
     "MCPException",
-    "MCPConfigurationError",
-    "MCPToolNotFoundError",
     "MCPServerError",
-    "MCPCommunicationError",
+    "MCPServiceState",
+    "MCPToolNotFoundError",
     "MCPValidationError",
 ]