claude-mpm 4.20.3__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -163,17 +163,21 @@ class MCPAutoConfigurator:
         Returns:
             True if user agrees, False if declines, None if timeout
         """
-        print("\n" + "=" * 60)
-        print("🔧 MCP Gateway Configuration")
-        print("=" * 60)
-        print("\nClaude MPM can automatically configure MCP Gateway for")
-        print("Claude Code integration. This enables advanced features:")
-        print("  • File analysis and summarization")
-        print("  • System diagnostics")
-        print("  • Ticket management")
-        print("  • And more...")
-        print("\nWould you like to configure it now? (y/n)")
-        print(f"(Auto-declining in {timeout} seconds)")
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("🔧 MCP Gateway Configuration", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(
+            "\nClaude MPM can automatically configure MCP Gateway for", file=sys.stderr
+        )
+        print(
+            "Claude Code integration. This enables advanced features:", file=sys.stderr
+        )
+        print("  • File analysis and summarization", file=sys.stderr)
+        print("  • System diagnostics", file=sys.stderr)
+        print("  • Ticket management", file=sys.stderr)
+        print("  • And more...", file=sys.stderr)
+        print("\nWould you like to configure it now? (y/n)", file=sys.stderr)
+        print(f"(Auto-declining in {timeout} seconds)", file=sys.stderr)
 
         # Use threading for cross-platform timeout support
         # Python 3.7+ has queue built-in - no need to check, we require 3.10+
@@ -203,7 +207,7 @@ class MCPAutoConfigurator:
 
         if input_thread.is_alive():
             # Timed out
-            print("\n(Timed out - declining)")
+            print("\n(Timed out - declining)", file=sys.stderr)
             return None
         # Got input
         return user_input in ["y", "yes"]
@@ -220,7 +224,7 @@ class MCPAutoConfigurator:
             if self.claude_config_path.exists():
                 backup_path = self._create_backup()
                 if backup_path:
-                    print(f"✅ Backup created: {backup_path}")
+                    print(f"✅ Backup created: {backup_path}", file=sys.stderr)
 
             # Load or create configuration
             config = self._load_or_create_config()
@@ -232,7 +236,7 @@ class MCPAutoConfigurator:
             # Find claude-mpm executable
             executable = self._find_claude_mpm_executable()
             if not executable:
-                print("❌ Could not find claude-mpm executable")
+                print("❌ Could not find claude-mpm executable", file=sys.stderr)
                 return False
 
             # Configure MCP server
@@ -246,20 +250,22 @@ class MCPAutoConfigurator:
             with self.claude_config_path.open("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")
+            print(
+                f"✅ Configuration saved to: {self.claude_config_path}", file=sys.stderr
+            )
+            print("\n🎉 MCP Gateway configured successfully!", file=sys.stderr)
+            print("\nNext steps:", file=sys.stderr)
+            print("1. Restart Claude Code (if running)", file=sys.stderr)
+            print("2. Look for the MCP icon in the interface", file=sys.stderr)
+            print("3. Try @claude-mpm-gateway in a conversation", file=sys.stderr)
 
             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")
+            print(f"❌ Configuration failed: {e}", file=sys.stderr)
+            print("\nYou can configure manually with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
             return False
 
     def _create_backup(self) -> Optional[Path]:
@@ -344,8 +350,8 @@ class MCPAutoConfigurator:
         if user_choice:
             return self.auto_configure()
         if user_choice is False:  # User explicitly said no
-            print("\n📝 You can configure MCP later with:")
-            print("  claude-mpm mcp install")
+            print("\n📝 You can configure MCP later with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
         # If timeout (None), don't show additional message
         return False
 

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -215,7 +215,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                     current[part] = {}
                 elif not isinstance(current[part], dict):
                     self.log_warning(
-                        f"Cannot override non-dict config at {'.'.join(config_path[:i+1])}"
+                        f"Cannot override non-dict config at {'.'.join(config_path[: i + 1])}"
                     )
                     break
                 current = current[part]

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -864,7 +864,7 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
     # Check if running in a non-interactive context
     try:
         if confirm_operation(message):
-            print("🚀 Updating kuzu-memory...")
+            print("🚀 Updating kuzu-memory...", file=sys.stderr)
             try:
                 result = subprocess.run(
                     ["pipx", "upgrade", "kuzu-memory"],
@@ -874,28 +874,37 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
                     check=False,
                 )
                 if result.returncode == 0:
-                    print("✅ Successfully updated kuzu-memory!")
+                    print("✅ Successfully updated kuzu-memory!", file=sys.stderr)
                     logger.info(f"Updated kuzu-memory from {current} to {latest}")
                 else:
-                    print(f"⚠️ Update failed: {result.stderr}")
+                    print(f"⚠️ Update failed: {result.stderr}", file=sys.stderr)
                     logger.warning(f"kuzu-memory update failed: {result.stderr}")
             except subprocess.TimeoutExpired:
-                print("⚠️ Update timed out. Please try again later.")
+                print("⚠️ Update timed out. Please try again later.", file=sys.stderr)
                 logger.warning("kuzu-memory update timed out")
             except Exception as e:
-                print(f"⚠️ Update failed: {e}")
+                print(f"⚠️ Update failed: {e}", file=sys.stderr)
                 logger.warning(f"kuzu-memory update error: {e}")
         else:
             # User declined update
-            print("\n  To skip this version permanently, run:")
-            print(f"    claude-mpm config set-skip-version kuzu-memory {latest}")
-            print("  To disable update checks for kuzu-memory:")
-            print("    claude-mpm config disable-update-checks kuzu-memory")
+            print("\n  To skip this version permanently, run:", file=sys.stderr)
+            print(
+                f"    claude-mpm config set-skip-version kuzu-memory {latest}",
+                file=sys.stderr,
+            )
+            print("  To disable update checks for kuzu-memory:", file=sys.stderr)
+            print(
+                "    claude-mpm config disable-update-checks kuzu-memory",
+                file=sys.stderr,
+            )
 
             # Ask if user wants to skip this version
             if confirm_operation("\n  Skip this version in future checks?"):
                 UpdatePreferences.set_skip_version("kuzu-memory", latest)
-                print(f"  Version {latest} will be skipped in future checks.")
+                print(
+                    f"  Version {latest} will be skipped in future checks.",
+                    file=sys.stderr,
+                )
     except (KeyboardInterrupt, EOFError):
         # User interrupted or input not available
         pass

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -65,7 +65,6 @@ def apply_backward_compatibility_patches():
                         and hasattr(request, "params")
                         and request.params is not None
                     ):
-
                         # Convert params to dict to check for clientInfo
                         params_dict = request.params
                         if hasattr(params_dict, "model_dump"):
@@ -542,7 +541,6 @@ class SimpleMCPServer:
 
                         result = f"Python: {sys.version}"
                     elif info_type == "cwd":
-
                         result = f"Working Directory: {Path.cwd()}"
                     elif info_type == "all":
                         import datetime

claude_mpm/services/mcp_gateway/tools/document_summarizer.py

@@ -73,7 +73,7 @@ class LRUCache:
             if not self.cache:
                 break
             # Remove least recently used item
-            removed_key, removed_value = self.cache.popitem(last=False)
+            _removed_key, removed_value = self.cache.popitem(last=False)
             self.current_memory -= removed_value.get("size_bytes", 0)
 
         # Add new item

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -161,12 +161,17 @@ class ExternalMCPService(BaseToolAdapter):
 
             if interactive:
                 # Show user-friendly installation prompt
-                print(f"\n⚠️  {self.package_name} not found")
-                print("This package enables enhanced functionality (optional).")
-                print("\nInstallation options:")
-                print("1. Install via pip (recommended for this project)")
-                print("2. Install via pipx (isolated, system-wide)")
-                print("3. Skip (continue without this package)")
+                print(f"\n⚠️  {self.package_name} not found", file=sys.stderr)
+                print(
+                    "This package enables enhanced functionality (optional).",
+                    file=sys.stderr,
+                )
+                print("\nInstallation options:", file=sys.stderr)
+                print(
+                    "1. Install via pip (recommended for this project)", file=sys.stderr
+                )
+                print("2. Install via pipx (isolated, system-wide)", file=sys.stderr)
+                print("3. Skip (continue without this package)", file=sys.stderr)
 
                 try:
                     choice = input("\nChoose option (1/2/3) [1]: ").strip() or "1"
@@ -180,7 +185,7 @@ class ExternalMCPService(BaseToolAdapter):
                         )
                         return False
                 except (EOFError, KeyboardInterrupt):
-                    print("\nInstallation cancelled")
+                    print("\nInstallation cancelled", file=sys.stderr)
                     return False
             else:
                 # Non-interactive: default to pip
@@ -201,7 +206,7 @@ class ExternalMCPService(BaseToolAdapter):
     async def _install_via_pip(self) -> bool:
         """Install package via pip."""
         try:
-            print(f"\n📦 Installing {self.package_name} via pip...")
+            print(f"\n📦 Installing {self.package_name} via pip...", file=sys.stderr)
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", self.package_name],
                 capture_output=True,
@@ -211,21 +216,21 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pip")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False
 
@@ -242,12 +247,12 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if pipx_check.returncode != 0:
-                print("✗ pipx is not installed")
-                print("Install pipx first: python -m pip install pipx")
+                print("✗ pipx is not installed", file=sys.stderr)
+                print("Install pipx first: python -m pip install pipx", file=sys.stderr)
                 self.logger.error("pipx not available for installation")
                 return False
 
-            print(f"\n📦 Installing {self.package_name} via pipx...")
+            print(f"\n📦 Installing {self.package_name} via pipx...", file=sys.stderr)
             result = subprocess.run(
                 ["pipx", "install", self.package_name],
                 capture_output=True,
@@ -257,26 +262,26 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pipx")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except FileNotFoundError:
-            print("✗ pipx command not found")
-            print("Install pipx first: python -m pip install pipx")
+            print("✗ pipx command not found", file=sys.stderr)
+            print("Install pipx first: python -m pip install pipx", file=sys.stderr)
             self.logger.error("pipx command not found")
             return False
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False
 

claude_mpm/services/mcp_gateway/tools/kuzu_memory_service.py

@@ -199,7 +199,9 @@ class KuzuMemoryService(BaseToolAdapter):
         try:
             if action == "store":
                 result = await self.store_memory(
-                    params.get("content"), params.get("tags"), {}  # metadata
+                    params.get("content"),
+                    params.get("tags"),
+                    {},  # metadata
                 )
             elif action == "recall":
                 result = await self.recall_memories(
@@ -213,7 +215,9 @@ class KuzuMemoryService(BaseToolAdapter):
                 )
             elif action == "context":
                 result = await self.get_context(
-                    params.get("query", ""), 2, True  # depth  # include_related
+                    params.get("query", ""),
+                    2,
+                    True,  # depth  # include_related
                 )
             else:
                 return MCPToolResult(success=False, error=f"Unknown action: {action}")

claude_mpm/services/memory/failure_tracker.py

@@ -29,6 +29,7 @@ Example flow:
 
 import logging
 import re
+import threading
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Dict, List, Optional, Tuple
@@ -536,6 +537,7 @@ class FailureTracker:
 
 # Singleton instance for session-level tracking
 _tracker_instance: Optional[FailureTracker] = None
+_tracker_lock = threading.Lock()
 
 
 def get_failure_tracker() -> FailureTracker:
@@ -544,13 +546,23 @@ def get_failure_tracker() -> FailureTracker:
     WHY: Session-level tracking requires a singleton to maintain state
     across multiple hook invocations during the same session.
 
+    Thread-safe implementation using double-checked locking pattern to
+    prevent race conditions during concurrent initialization.
+
     Returns:
         The FailureTracker singleton instance
     """
     global _tracker_instance
-    if _tracker_instance is None:
-        _tracker_instance = FailureTracker()
-    return _tracker_instance
+
+    # Fast path - check without lock
+    if _tracker_instance is not None:
+        return _tracker_instance
+
+    # Slow path - acquire lock and double-check
+    with _tracker_lock:
+        if _tracker_instance is None:
+            _tracker_instance = FailureTracker()
+        return _tracker_instance
 
 
 def reset_failure_tracker() -> None:
@@ -558,6 +570,9 @@ def reset_failure_tracker() -> None:
 
     WHY: Tests need to reset state between runs. Also useful for
     explicitly starting a new tracking session.
+
+    Thread-safe implementation ensures proper cleanup.
     """
     global _tracker_instance
-    _tracker_instance = None
+    with _tracker_lock:
+        _tracker_instance = None

claude_mpm/services/memory/optimizer.py

@@ -618,7 +618,7 @@ class MemoryOptimizer(LoggerMixin):
                     )
 
                 # Check for similar items
-                consolidated, consolidated_count = self._consolidate_similar_items(
+                _consolidated, consolidated_count = self._consolidate_similar_items(
                     unique_points
                 )
                 if consolidated_count > 0:

claude_mpm/services/model/model_router.py

@@ -266,7 +266,7 @@ class ModelRouter(BaseService, IModelRouter):
 
         # Route based on strategy
         if self.strategy == RoutingStrategy.CLAUDE_ONLY:
-            return await self._route_to_claude(content, task, model, **kwargs)
+            return await self._route_to_claude(content, task, model=model, **kwargs)
 
         if self.strategy in (
             RoutingStrategy.OLLAMA_ONLY,
@@ -275,13 +275,13 @@ class ModelRouter(BaseService, IModelRouter):
             return await self._route_to_ollama(
                 content,
                 task,
-                model,
+                model=model,
                 require_success=True,
                 **kwargs,
             )
 
         # AUTO strategy
-        return await self._route_auto(content, task, model, **kwargs)
+        return await self._route_auto(content, task, model=model, **kwargs)
 
     async def _route_auto(
         self,
@@ -308,7 +308,7 @@ class ModelRouter(BaseService, IModelRouter):
             response = await self._route_to_ollama(
                 content,
                 task,
-                model,
+                model=model,
                 require_success=False,
                 **kwargs,
             )
@@ -325,7 +325,7 @@ class ModelRouter(BaseService, IModelRouter):
         # Ollama unavailable or failed - fallback to Claude
         if self.fallback_enabled:
             self.log_info("Falling back to Claude")
-            return await self._route_to_claude(content, task, model, **kwargs)
+            return await self._route_to_claude(content, task, model=model, **kwargs)
         return self._create_error_response(
             task,
             model,
@@ -356,8 +356,7 @@ class ModelRouter(BaseService, IModelRouter):
         if require_success and not await self.ollama_provider.is_available():
             if self.strategy == RoutingStrategy.PRIVACY_FIRST:
                 error_msg = (
-                    "Ollama not available. Privacy mode enabled - "
-                    "not sending to cloud."
+                    "Ollama not available. Privacy mode enabled - not sending to cloud."
                 )
             else:
                 error_msg = "Ollama not available and required by configuration"
@@ -368,7 +367,7 @@ class ModelRouter(BaseService, IModelRouter):
         self._route_count["ollama"] += 1
 
         return await self.ollama_provider.analyze_content(
-            content, task, model, **kwargs
+            content, task, model=model, **kwargs
         )
 
     async def _route_to_claude(
@@ -394,7 +393,7 @@ class ModelRouter(BaseService, IModelRouter):
         self._route_count["claude"] += 1
 
         return await self.claude_provider.analyze_content(
-            content, task, model, **kwargs
+            content, task, model=model, **kwargs
         )
 
     def _create_error_response(

claude_mpm/services/monitor/daemon.py

@@ -479,7 +479,7 @@ class UnifiedMonitorDaemon:
             except OSError:
                 if i < 9:
                     self.logger.debug(
-                        f"Port {self.port} still in use, waiting... ({i+1}/10)"
+                        f"Port {self.port} still in use, waiting... ({i + 1}/10)"
                     )
                     time.sleep(1)
                 else:

claude_mpm/services/monitor/server.py

@@ -203,8 +203,8 @@ class UnifiedMonitorServer:
             # Create Socket.IO server with proper ping configuration
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
-                logger=False,
-                engineio_logger=False,
+                logger=True,  # Enable to see Socket.IO events and connection lifecycle
+                engineio_logger=True,  # Enable to see Engine.IO protocol handshake details
                 ping_interval=30,  # 30 seconds ping interval (matches client expectation)
                 ping_timeout=60,  # 60 seconds ping timeout (generous for stability)
             )