claude-mpm 4.5.1__py3-none-any.whl → 4.5.5__py3-none-any.whl

claude_mpm/services/mcp_config_manager.py

@@ -47,7 +47,9 @@ class MCPConfigManager:
     STATIC_MCP_CONFIGS = {
         "kuzu-memory": {
             "type": "stdio",
-            "command": "kuzu-memory",  # Will be resolved to full path
+            # Use full path to kuzu-memory binary from pipx venv
+            # This ensures it runs with the correct Python version
+            "command": "kuzu-memory",  # Will be resolved to pipx venv path
             "args": ["mcp", "serve"],  # v1.1.0+ uses 'mcp serve' command
         },
         "mcp-ticketer": {
@@ -580,57 +582,38 @@ class MCPConfigManager:
                 config["args"] = ["mcp"]
 
         elif service_name == "kuzu-memory":
-            # Determine kuzu-memory command version
-            kuzu_args = ["mcp", "serve"]  # Default to the standard v1.1.0+ format
-            test_cmd = None
-
-            if use_pipx_run:
-                test_cmd = ["pipx", "run", "kuzu-memory", "--help"]
-            elif use_uvx:
-                test_cmd = ["uvx", "kuzu-memory", "--help"]
-            elif service_path:
-                test_cmd = [service_path, "--help"]
-
-            if test_cmd:
-                try:
-                    result = subprocess.run(
-                        test_cmd,
-                        capture_output=True,
-                        text=True,
-                        timeout=10,
-                        check=False,
-                    )
-                    # Check for MCP support in help output
-                    help_output = result.stdout.lower() + result.stderr.lower()
-
-                    # Standard version detection - look for "mcp serve" command (v1.1.0+)
-                    # This is the correct format for kuzu-memory v1.1.0 and later
-                    if "mcp serve" in help_output or (
-                        "mcp" in help_output and "serve" in help_output
-                    ):
-                        # Standard v1.1.0+ version with mcp serve command
-                        kuzu_args = ["mcp", "serve"]
-                    # Legacy version detection - only "serve" without "mcp"
-                    elif "serve" in help_output and "mcp" not in help_output:
-                        # Very old version that only has serve command
-                        kuzu_args = ["serve"]
-                    else:
-                        # Default to the standard mcp serve format (v1.1.0+)
-                        # Note: "claude mcp-server" format is deprecated and does not work
-                        kuzu_args = ["mcp", "serve"]
-                except Exception:
-                    # Default to the standard mcp serve command on any error
-                    kuzu_args = ["mcp", "serve"]
+            # For kuzu-memory, prefer using the binary from pipx venv
+            # This ensures it runs with Python 3.12 instead of system Python 3.13
+            pipx_binary = (
+                Path.home()
+                / ".local"
+                / "pipx"
+                / "venvs"
+                / "kuzu-memory"
+                / "bin"
+                / "kuzu-memory"
+            )
 
-            if use_pipx_run:
+            if pipx_binary.exists():
+                # Use pipx venv binary directly - this runs with the correct Python
+                config["command"] = str(pipx_binary)
+                config["args"] = ["mcp", "serve"]
+            elif use_pipx_run:
+                # Fallback to pipx run
                 config["command"] = "pipx"
-                config["args"] = ["run", "kuzu-memory"] + kuzu_args
+                config["args"] = ["run", "kuzu-memory", "mcp", "serve"]
             elif use_uvx:
+                # UVX fallback
                 config["command"] = "uvx"
-                config["args"] = ["kuzu-memory"] + kuzu_args
-            else:
+                config["args"] = ["kuzu-memory", "mcp", "serve"]
+            elif service_path:
+                # Direct binary path
                 config["command"] = service_path
-                config["args"] = kuzu_args
+                config["args"] = ["mcp", "serve"]
+            else:
+                # Default fallback
+                config["command"] = "pipx"
+                config["args"] = ["run", "kuzu-memory", "mcp", "serve"]
 
         # Generic config for unknown services
         elif use_pipx_run:
@@ -741,9 +724,7 @@ class MCPConfigManager:
                     "command"
                 ) or existing_config.get("args") != correct_config.get("args"):
                     needs_update = True
-                    fixed_services.append(
-                        f"{service_name} in {Path(project_key).name}"
-                    )
+                    fixed_services.append(f"{service_name} in {Path(project_key).name}")
 
                 # Update configuration if needed
                 if needs_update:
@@ -1017,49 +998,44 @@ class MCPConfigManager:
 
         return False, "none"
 
-    def _check_and_fix_mcp_ticketer_dependencies(self) -> bool:
-        """Check and fix mcp-ticketer missing gql dependency.
-
-        Note: This is a workaround for mcp-ticketer <= 0.1.8 which is missing
-        the gql dependency in its package metadata. Future versions (> 0.1.8)
-        should include 'gql[httpx]>=3.0.0' as a dependency, making this fix
-        unnecessary. We keep this for backward compatibility with older versions.
-        """
-        try:
-            # Test if gql is available in mcp-ticketer's environment
-            test_result = subprocess.run(
-                ["pipx", "run", "--spec", "mcp-ticketer", "python", "-c", "import gql"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-                check=False,
-            )
-
-            # If import fails, inject the dependency
-            if test_result.returncode != 0:
-                self.logger.info("🔧 mcp-ticketer missing gql dependency, fixing...")
-
-                inject_result = subprocess.run(
-                    ["pipx", "inject", "mcp-ticketer", "gql"],
-                    capture_output=True,
-                    text=True,
-                    timeout=30,
-                    check=False,
-                )
-
-                if inject_result.returncode == 0:
-                    self.logger.info(
-                        "✅ Successfully injected gql dependency into mcp-ticketer"
-                    )
-                    return True
-                self.logger.warning(f"Failed to inject gql: {inject_result.stderr}")
-                return False
-
-            return False
-
-        except Exception as e:
-            self.logger.debug(f"Could not check/fix mcp-ticketer dependencies: {e}")
-            return False
+    # COMMENTED OUT: These functions are no longer used
+    # Package maintainers should fix dependency declarations in their packages
+    # Automatic dependency injection can cause conflicts and is not recommended
+
+    # def _get_mcp_ticketer_version(self) -> Optional[str]:
+    #     """Get the installed version of mcp-ticketer.
+    #
+    #     Returns:
+    #         Version string (e.g., "0.1.8") or None if not installed
+    #     """
+    #     try:
+    #         result = subprocess.run(
+    #             ["pipx", "runpip", "mcp-ticketer", "show", "mcp-ticketer"],
+    #             capture_output=True,
+    #             text=True,
+    #             timeout=5,
+    #             check=False,
+    #         )
+    #
+    #         if result.returncode == 0:
+    #             # Parse version from output
+    #             for line in result.stdout.split("\n"):
+    #                 if line.startswith("Version:"):
+    #                     return line.split(":", 1)[1].strip()
+    #         return None
+    #     except Exception:
+    #         return None
+    #
+    # def _check_and_fix_mcp_ticketer_dependencies(self) -> bool:
+    #     """Check and fix mcp-ticketer missing gql dependency.
+    #
+    #     DEPRECATED: This workaround is no longer used.
+    #     Package maintainers should fix dependency declarations.
+    #
+    #     Returns:
+    #         False (no longer performs injection)
+    #     """
+    #     return False
 
     def fix_mcp_service_issues(self) -> Tuple[bool, str]:
         """
@@ -1109,24 +1085,26 @@ class MCPConfigManager:
                 )
                 success = self._reinstall_service(service_name)
                 if success:
-                    # Special handling for mcp-ticketer - inject missing gql dependency
-                    if service_name == "mcp-ticketer":
-                        self._check_and_fix_mcp_ticketer_dependencies()
+                    # NOTE: Removed automatic dependency injection workaround
+                    # Package maintainers should fix dependency declarations
                     fixed_services.append(f"{service_name} (reinstalled)")
                 else:
                     failed_services.append(f"{service_name} (reinstall failed)")
 
             elif issue_type == "missing_dependency":
-                # Fix missing dependencies
-                if service_name == "mcp-ticketer":
-                    if self._check_and_fix_mcp_ticketer_dependencies():
-                        fixed_services.append(f"{service_name} (dependency fixed)")
-                    else:
-                        failed_services.append(
-                            f"{service_name} (dependency fix failed)"
-                        )
+                # Fix missing dependencies by automatically reinstalling
+                self.logger.info(
+                    f"  {service_name} has missing dependencies - auto-reinstalling..."
+                )
+                success = self._auto_reinstall_mcp_service(service_name)
+                if success:
+                    fixed_services.append(f"{service_name} (auto-reinstalled)")
                 else:
-                    failed_services.append(f"{service_name} (unknown dependency issue)")
+                    self.logger.warning(
+                        f"  Auto-reinstall failed for {service_name}. Manual fix: "
+                        f"pipx uninstall {service_name} && pipx install {service_name}"
+                    )
+                    failed_services.append(f"{service_name} (auto-reinstall failed)")
 
             elif issue_type == "path_issue":
                 # Path issues are handled by config updates
@@ -1280,6 +1258,79 @@ class MCPConfigManager:
             self.logger.error(f"Error reinstalling {service_name}: {e}")
             return False
 
+    def _auto_reinstall_mcp_service(self, service_name: str) -> bool:
+        """
+        Automatically reinstall an MCP service with missing dependencies.
+
+        This method:
+        1. Uninstalls the corrupted/incomplete service
+        2. Reinstalls it fresh from pipx
+        3. Verifies the reinstall was successful
+        4. Updates status after successful reinstall
+
+        Args:
+            service_name: Name of the MCP service to reinstall
+
+        Returns:
+            True if reinstall successful, False otherwise
+        """
+        try:
+            import shutil
+
+            # Verify pipx is available
+            if not shutil.which("pipx"):
+                self.logger.error("pipx not found - cannot auto-reinstall")
+                return False
+
+            self.logger.info(f"  → Uninstalling {service_name}...")
+            uninstall_result = subprocess.run(
+                ["pipx", "uninstall", service_name],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False,
+            )
+
+            # Log result but don't fail if uninstall had issues
+            if uninstall_result.returncode != 0:
+                self.logger.debug(
+                    f"Uninstall had warnings (expected if corrupted): {uninstall_result.stderr}"
+                )
+
+            self.logger.info(f"  → Installing fresh {service_name}...")
+            install_result = subprocess.run(
+                ["pipx", "install", service_name],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if install_result.returncode != 0:
+                self.logger.error(
+                    f"Install failed for {service_name}: {install_result.stderr}"
+                )
+                return False
+
+            # Verify the reinstall worked
+            self.logger.info(f"  → Verifying {service_name} installation...")
+            issue = self._detect_service_issue(service_name)
+
+            if issue is None:
+                self.logger.info(f"  ✅ Successfully reinstalled {service_name}")
+                return True
+            self.logger.warning(
+                f"Reinstalled {service_name} but still has issue: {issue}"
+            )
+            return False
+
+        except subprocess.TimeoutExpired:
+            self.logger.error(f"Timeout while reinstalling {service_name}")
+            return False
+        except Exception as e:
+            self.logger.error(f"Error auto-reinstalling {service_name}: {e}")
+            return False
+
     def _verify_service_installed(self, service_name: str, method: str) -> bool:
         """
         Verify that a service was successfully installed and is functional.

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -20,6 +20,7 @@ import json
 import os
 import signal
 import subprocess
+import sys
 import threading
 import time
 from pathlib import Path
@@ -484,6 +485,21 @@ async def auto_initialize_vector_search():
 
         if vector_config.exists():
             logger.debug(f"Vector search already initialized for {current_dir}")
+
+            # Ensure .mcp-vector-search is in gitignore even if already initialized
+            try:
+                from ....services.project.project_organizer import ProjectOrganizer
+
+                if (current_dir / ".claude-mpm").exists() or (
+                    current_dir / ".git"
+                ).exists():
+                    organizer = ProjectOrganizer(current_dir)
+                    organizer.update_gitignore(
+                        additional_patterns=[".mcp-vector-search/"]
+                    )
+                    logger.debug("Ensured .mcp-vector-search is in gitignore")
+            except Exception as e:
+                logger.debug(f"Could not update gitignore for .mcp-vector-search: {e}")
             # Check if index needs rebuilding (corrupted database)
             chroma_db = current_dir / ".mcp-vector-search/chroma.sqlite3"
             if chroma_db.exists():
@@ -518,6 +534,23 @@ async def auto_initialize_vector_search():
         if proc.returncode == 0:
             logger.info("✅ Vector search initialization completed")
 
+            # Ensure .mcp-vector-search is in gitignore
+            try:
+                from ....services.project.project_organizer import ProjectOrganizer
+
+                # Check if we're in a git repository (parent of .claude-mpm)
+                if (current_dir / ".claude-mpm").exists() or (
+                    current_dir / ".git"
+                ).exists():
+                    organizer = ProjectOrganizer(current_dir)
+                    organizer.update_gitignore(
+                        additional_patterns=[".mcp-vector-search/"]
+                    )
+                    logger.debug("Ensured .mcp-vector-search is in gitignore")
+            except Exception as e:
+                logger.debug(f"Could not update gitignore for .mcp-vector-search: {e}")
+                # Non-critical, don't fail initialization
+
             # Start background indexing (non-blocking)
             def background_index():
                 try:
@@ -659,6 +692,12 @@ async def auto_initialize_kuzu_memory():
                 logger.debug("kuzu-memory command not found after installation")
                 return
 
+        # Check for kuzu-memory updates (non-blocking)
+        try:
+            await _check_kuzu_memory_updates(kuzu_memory_cmd)
+        except Exception as e:
+            logger.debug(f"Update check failed (non-critical): {e}")
+
         # Initialize kuzu-memory database in current project
         current_dir = Path.cwd()
         kuzu_memories_dir = current_dir / "kuzu-memories"
@@ -668,6 +707,19 @@ async def auto_initialize_kuzu_memory():
             logger.debug(
                 f"Kuzu-memory database already initialized at {kuzu_memories_dir}"
             )
+
+            # Ensure kuzu-memories is in gitignore even if already initialized
+            try:
+                from ....services.project.project_organizer import ProjectOrganizer
+
+                if (current_dir / ".claude-mpm").exists() or (
+                    current_dir / ".git"
+                ).exists():
+                    organizer = ProjectOrganizer(current_dir)
+                    organizer.update_gitignore(additional_patterns=["kuzu-memories/"])
+                    logger.debug("Ensured kuzu-memories is in gitignore")
+            except Exception as e:
+                logger.debug(f"Could not update gitignore for kuzu-memories: {e}")
         else:
             logger.info(
                 f"🎯 Initializing kuzu-memory database for project: {current_dir}"
@@ -687,6 +739,22 @@ async def auto_initialize_kuzu_memory():
 
             if proc.returncode == 0:
                 logger.info("✅ Kuzu-memory database initialized successfully")
+
+                # Ensure kuzu-memories is in gitignore
+                try:
+                    from ....services.project.project_organizer import ProjectOrganizer
+
+                    if (current_dir / ".claude-mpm").exists() or (
+                        current_dir / ".git"
+                    ).exists():
+                        organizer = ProjectOrganizer(current_dir)
+                        organizer.update_gitignore(
+                            additional_patterns=["kuzu-memories/"]
+                        )
+                        logger.debug("Ensured kuzu-memories is in gitignore")
+                except Exception as e:
+                    logger.debug(f"Could not update gitignore for kuzu-memories: {e}")
+                    # Non-critical, don't fail initialization
             else:
                 logger.warning(f"⚠️ Kuzu-memory initialization failed: {proc.stderr}")
 
@@ -694,47 +762,201 @@ async def auto_initialize_kuzu_memory():
         logger.debug(f"Kuzu-memory auto-initialization error (non-critical): {e}")
 
 
-async def pre_warm_mcp_servers():
-    """Pre-warm MCP servers from configuration."""
-    # Auto-initialize vector search for current project
-    await auto_initialize_vector_search()
+async def _check_kuzu_memory_updates(kuzu_cmd: Path) -> None:
+    """
+    Check for kuzu-memory updates and prompt user.
 
-    # Auto-initialize kuzu-memory for persistent knowledge
-    await auto_initialize_kuzu_memory()
+    Args:
+        kuzu_cmd: Path to kuzu-memory command
 
-    pool = get_process_pool()
+    WHY: Keep users informed about important updates that may fix bugs
+    or add features they need.
 
-    # Load MCP configurations
-    configs = {}
+    DESIGN DECISIONS:
+    - Non-blocking with timeout to prevent startup delays
+    - Respects user preferences and environment variables
+    - Only prompts in interactive TTY sessions
+    """
+    logger = get_logger("kuzu_memory_update")
 
-    # Check .claude.json for MCP server configs
-    claude_config_path = Path.home() / ".claude.json"
-    if not claude_config_path.exists():
-        # Try project-local config
-        claude_config_path = Path.cwd() / ".claude.json"
+    # Skip if environment variable set
+    if os.environ.get("CLAUDE_MPM_SKIP_UPDATE_CHECK"):
+        return
 
-    if claude_config_path.exists():
-        try:
-            with open(claude_config_path) as f:
-                config_data = json.load(f)
-                mcp_servers = config_data.get("mcpServers", {})
-                configs.update(mcp_servers)
-        except Exception as e:
-            get_logger("MCPProcessPool").warning(f"Failed to load Claude config: {e}")
+    # Skip if not TTY (can't prompt)
+    if not sys.stdin.isatty():
+        return
 
-    # Check .mcp.json for additional configs
-    mcp_config_path = Path.cwd() / ".mcp.json"
-    if mcp_config_path.exists():
-        try:
-            with open(mcp_config_path) as f:
-                config_data = json.load(f)
-                mcp_servers = config_data.get("mcpServers", {})
-                configs.update(mcp_servers)
-        except Exception as e:
-            get_logger("MCPProcessPool").warning(f"Failed to load MCP config: {e}")
+    # Import update utilities
+    from ..utils.package_version_checker import PackageVersionChecker
+    from ..utils.update_preferences import UpdatePreferences
+
+    # Check if updates are enabled for this package
+    if not UpdatePreferences.should_check_package("kuzu-memory"):
+        return
 
-    if configs:
-        await pool.pre_warm_servers(configs)
-        await pool.start_health_monitoring()
+    try:
+        # Get current version from pipx
+        result = subprocess.run(
+            ["pipx", "list", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+
+        if result.returncode == 0:
+            pipx_data = json.loads(result.stdout)
+            venvs = pipx_data.get("venvs", {})
+            kuzu_info = venvs.get("kuzu-memory", {})
+            metadata = kuzu_info.get("metadata", {})
+            current_version = metadata.get("main_package", {}).get(
+                "package_version", "unknown"
+            )
+
+            if current_version != "unknown":
+                # Check for updates
+                checker = PackageVersionChecker()
+                update_info = await checker.check_for_update(
+                    "kuzu-memory", current_version
+                )
 
-    return pool
+                if update_info and update_info.get("update_available"):
+                    latest_version = update_info["latest"]
+
+                    # Check if user wants to skip this version
+                    if UpdatePreferences.should_skip_version(
+                        "kuzu-memory", latest_version
+                    ):
+                        logger.debug(
+                            f"Skipping kuzu-memory update to {latest_version} per user preference"
+                        )
+                        return
+
+                    # Prompt for update
+                    _prompt_kuzu_update(update_info["current"], latest_version)
+
+    except Exception as e:
+        logger.debug(f"Update check error: {e}")
+
+
+def _prompt_kuzu_update(current: str, latest: str) -> None:
+    """
+    Prompt user to update kuzu-memory.
+
+    Args:
+        current: Current installed version
+        latest: Latest available version
+    """
+    from ...cli.shared.error_handling import confirm_operation
+    from ..utils.update_preferences import UpdatePreferences
+
+    logger = get_logger("kuzu_memory_update")
+
+    message = (
+        f"\n🔄 A new version of kuzu-memory is available!\n"
+        f"   Current: v{current}\n"
+        f"   Latest:  v{latest}\n\n"
+        f"   This update may include bug fixes and performance improvements.\n"
+        f"   Update now?"
+    )
+
+    # Check if running in a non-interactive context
+    try:
+        if confirm_operation(message):
+            print("🚀 Updating kuzu-memory...")
+            try:
+                result = subprocess.run(
+                    ["pipx", "upgrade", "kuzu-memory"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    print("✅ Successfully updated kuzu-memory!")
+                    logger.info(f"Updated kuzu-memory from {current} to {latest}")
+                else:
+                    print(f"⚠️ Update failed: {result.stderr}")
+                    logger.warning(f"kuzu-memory update failed: {result.stderr}")
+            except subprocess.TimeoutExpired:
+                print("⚠️ Update timed out. Please try again later.")
+                logger.warning("kuzu-memory update timed out")
+            except Exception as e:
+                print(f"⚠️ Update failed: {e}")
+                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")
+
+            # 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.")
+    except (KeyboardInterrupt, EOFError):
+        # User interrupted or input not available
+        pass
+
+
+async def pre_warm_mcp_servers():
+    """
+    Pre-warm MCP servers from configuration.
+
+    DISABLED: This function is currently disabled to avoid conflicts with
+    Claude Code's native MCP server management. When enabled, this can
+    cause issues with MCP server initialization and stderr/stdout handling.
+
+    TODO: Re-enable after ensuring compatibility with Claude Code's MCP handling.
+    """
+    logger = get_logger("MCPProcessPool")
+    logger.debug("MCP server pre-warming is currently disabled")
+
+    # COMMENTED OUT: Auto-initialization that can interfere with Claude Code
+    # # Auto-initialize vector search for current project
+    # await auto_initialize_vector_search()
+    #
+    # # Auto-initialize kuzu-memory for persistent knowledge
+    # await auto_initialize_kuzu_memory()
+    #
+    # pool = get_process_pool()
+    #
+    # # Load MCP configurations
+    # configs = {}
+    #
+    # # Check .claude.json for MCP server configs
+    # claude_config_path = Path.home() / ".claude.json"
+    # if not claude_config_path.exists():
+    #     # Try project-local config
+    #     claude_config_path = Path.cwd() / ".claude.json"
+    #
+    # if claude_config_path.exists():
+    #     try:
+    #         with open(claude_config_path) as f:
+    #             config_data = json.load(f)
+    #             mcp_servers = config_data.get("mcpServers", {})
+    #             configs.update(mcp_servers)
+    #     except Exception as e:
+    #         get_logger("MCPProcessPool").warning(f"Failed to load Claude config: {e}")
+    #
+    # # Check .mcp.json for additional configs
+    # mcp_config_path = Path.cwd() / ".mcp.json"
+    # if mcp_config_path.exists():
+    #     try:
+    #         with open(mcp_config_path) as f:
+    #             config_data = json.load(f)
+    #             mcp_servers = config_data.get("mcpServers", {})
+    #             configs.update(mcp_servers)
+    #     except Exception as e:
+    #         get_logger("MCPProcessPool").warning(f"Failed to load MCP config: {e}")
+    #
+    # if configs:
+    #     await pool.pre_warm_servers(configs)
+    #     await pool.start_health_monitoring()
+    #
+    # return pool
+
+    # Return a basic pool instance without pre-warming
+    return get_process_pool()