claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

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
@@ -189,7 +190,7 @@ class MCPProcessPool:
 
             # Write process info to file for debugging
             info_file = self.pool_dir / f"{server_name}_{process.pid}.json"
-            with open(info_file, "w") as f:
+            with info_file.open("w") as f:
                 json.dump(self._process_info[server_name], f, indent=2)
 
             return process
@@ -377,41 +378,600 @@ def get_process_pool() -> MCPProcessPool:
     return _pool
 
 
-async def pre_warm_mcp_servers():
-    """Pre-warm MCP servers from configuration."""
-    pool = get_process_pool()
+async def auto_initialize_vector_search():
+    """
+    Auto-initialize mcp-vector-search for the current project.
+
+    WHY: Vector search requires project initialization before it can be used.
+    This function ensures the current project is automatically initialized
+    for vector search when the system starts up.
 
-    # Load MCP configurations
-    configs = {}
+    DESIGN DECISION:
+    - Automatically install mcp-vector-search if not present
+    - Run in background with timeout to avoid blocking startup
+    - Failures are logged but don't prevent the system from starting
+    """
+    logger = get_logger("vector_search_init")
 
-    # 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"
+    try:
+        # Import MCPConfigManager to handle installation
+        from claude_mpm.services.mcp_config_manager import MCPConfigManager
 
-    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}")
+        config_manager = MCPConfigManager()
+
+        # Check if mcp-vector-search is already installed
+        vector_search_path = config_manager.detect_service_path("mcp-vector-search")
+
+        if vector_search_path:
+            logger.debug(f"mcp-vector-search found at: {vector_search_path}")
+        else:
+            # Not installed - attempt installation
+            logger.info("🔍 mcp-vector-search not found. Installing via pipx...")
+
+            # First check if pipx is available
+            import shutil
+            import subprocess
+
+            if not shutil.which("pipx"):
+                logger.warning(
+                    "⚠️ pipx not found. Please install pipx to enable automatic mcp-vector-search installation"
+                )
+                logger.info("   Install pipx with: python -m pip install --user pipx")
+                return
+
+            try:
+                result = subprocess.run(
+                    ["pipx", "install", "mcp-vector-search"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                    check=False,  # 1 minute timeout for installation
+                )
+
+                if result.returncode == 0:
+                    logger.info("✅ mcp-vector-search installed successfully")
+                    # Detect the newly installed path
+                    vector_search_path = config_manager.detect_service_path(
+                        "mcp-vector-search"
+                    )
+                    if not vector_search_path:
+                        logger.warning(
+                            "mcp-vector-search installed but command not found in PATH"
+                        )
+                        return
+
+                    # Verify the newly installed service is available
+                    logger.info("📝 Verifying installation...")
+                    available, msg = config_manager.check_mcp_services_available()
+                    if available:
+                        logger.info(f"✅ {msg}")
+                    else:
+                        logger.warning(
+                            f"⚠️ Service installed but not configured in Claude: {msg}"
+                        )
+                        logger.info(
+                            "💡 Configure via: Claude Desktop > Settings > Developer > Model Context Protocol"
+                        )
+                else:
+                    logger.warning(
+                        f"Failed to install mcp-vector-search: {result.stderr}"
+                    )
+                    return
+
+            except subprocess.TimeoutExpired:
+                logger.warning("Installation of mcp-vector-search timed out")
+                return
+            except Exception as e:
+                logger.warning(f"Error installing mcp-vector-search: {e}")
+                return
+
+        # At this point, mcp-vector-search should be available
+        # Get the actual command to use
+        import shutil
+
+        vector_search_cmd = shutil.which("mcp-vector-search")
+        if not vector_search_cmd:
+            # Try pipx installation path as fallback
+            pipx_path = (
+                Path.home()
+                / ".local/pipx/venvs/mcp-vector-search/bin/mcp-vector-search"
+            )
+            if pipx_path.exists():
+                vector_search_cmd = str(pipx_path)
+            else:
+                logger.debug("mcp-vector-search command not found after installation")
+                return
+
+        # Check if current project is already initialized
+        current_dir = Path.cwd()
+        vector_config = current_dir / ".mcp-vector-search/config.json"
+
+        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():
+                # Quick health check - verify database file exists and is accessible
+                try:
+                    # Check if database file exists and has reasonable size
+                    if chroma_db.exists() and chroma_db.stat().st_size > 0:
+                        logger.info("✓ Vector search index is healthy and ready")
+                        return
+                    logger.info("⚠️ Vector search index may be corrupted, rebuilding...")
+                except Exception as e:
+                    logger.debug(
+                        f"Vector search health check failed: {e}, will attempt to rebuild"
+                    )
+
+        # Initialize or reinitialize the project
+        logger.info(f"🎯 Initializing vector search for project: {current_dir}")
+
+        # Initialize the project (this creates the config)
+        # Note: mcp-vector-search operates on the current directory
+        import subprocess
+
+        proc = subprocess.run(
+            [vector_search_cmd, "init"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            cwd=str(current_dir),
+            check=False,  # Run in the project directory
+        )
 
-    # Check .mcp.json for additional configs
-    mcp_config_path = Path.cwd() / ".mcp.json"
-    if mcp_config_path.exists():
+        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:
+                    logger.info("🔄 Starting project indexing in background...")
+                    index_proc = subprocess.run(
+                        [vector_search_cmd, "index", "main"],
+                        capture_output=True,
+                        text=True,
+                        timeout=300,  # 5 minute timeout for indexing
+                        cwd=str(current_dir),
+                        check=False,  # Run in the project directory
+                    )
+                    if index_proc.returncode == 0:
+                        logger.info("✅ Project indexing completed successfully")
+                        # Parse output to show statistics if available
+                        if "indexed" in index_proc.stdout.lower():
+                            # Extract and log indexing statistics
+                            lines = index_proc.stdout.strip().split("\n")
+                            for line in lines:
+                                if "indexed" in line.lower() or "files" in line.lower():
+                                    logger.info(f"   {line.strip()}")
+                    else:
+                        logger.warning(
+                            f"⚠️ Project indexing failed: {index_proc.stderr}"
+                        )
+                except subprocess.TimeoutExpired:
+                    logger.warning(
+                        "⚠️ Project indexing timed out (will continue in background)"
+                    )
+                except Exception as e:
+                    logger.debug(f"Background indexing error (non-critical): {e}")
+
+            # Run indexing in background thread
+            import threading
+
+            index_thread = threading.Thread(target=background_index, daemon=True)
+            index_thread.start()
+            logger.info(
+                "📚 Background indexing started - vector search will be available shortly"
+            )
+
+        else:
+            logger.warning(f"⚠️ Vector search initialization failed: {proc.stderr}")
+
+    except Exception as e:
+        logger.debug(f"Vector search auto-initialization error (non-critical): {e}")
+
+
+async def auto_initialize_kuzu_memory():
+    """
+    Auto-initialize kuzu-memory for persistent knowledge storage.
+
+    WHY: Kuzu-memory provides a graph database for structured memory storage
+    with semantic search capabilities, enabling persistent context across sessions.
+
+    DESIGN DECISION:
+    - Automatically install kuzu-memory if not present via pipx
+    - Initialize database in background to avoid blocking startup
+    - Failures are logged but don't prevent the system from starting
+    """
+    logger = get_logger("kuzu_memory_init")
+
+    try:
+        # Import MCPConfigManager to handle installation
+        from claude_mpm.services.mcp_config_manager import MCPConfigManager
+
+        config_manager = MCPConfigManager()
+
+        # Check if kuzu-memory is already installed
+        kuzu_memory_path = config_manager.detect_service_path("kuzu-memory")
+
+        if kuzu_memory_path:
+            logger.debug(f"kuzu-memory found at: {kuzu_memory_path}")
+        else:
+            # Not installed - attempt installation
+            logger.info("🧠 kuzu-memory not found. Installing via pipx...")
+
+            # First check if pipx is available
+            import shutil
+            import subprocess
+
+            if not shutil.which("pipx"):
+                logger.warning(
+                    "⚠️ pipx not found. Please install pipx to enable automatic kuzu-memory installation"
+                )
+                logger.info("   Install pipx with: python -m pip install --user pipx")
+                return
+
+            try:
+                result = subprocess.run(
+                    ["pipx", "install", "kuzu-memory"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                    check=False,  # 1 minute timeout for installation
+                )
+
+                if result.returncode == 0:
+                    logger.info("✅ kuzu-memory installed successfully")
+                    # Detect the newly installed path
+                    kuzu_memory_path = config_manager.detect_service_path("kuzu-memory")
+                    if not kuzu_memory_path:
+                        logger.warning(
+                            "kuzu-memory installed but command not found in PATH"
+                        )
+                        return
+
+                    # Verify the newly installed service is available
+                    logger.info("📝 Verifying installation...")
+                    available, msg = config_manager.check_mcp_services_available()
+                    if available:
+                        logger.info(f"✅ {msg}")
+                    else:
+                        logger.warning(
+                            f"⚠️ Service installed but not configured in Claude: {msg}"
+                        )
+                        logger.info(
+                            "💡 Configure via: Claude Desktop > Settings > Developer > Model Context Protocol"
+                        )
+                else:
+                    logger.warning(f"Failed to install kuzu-memory: {result.stderr}")
+                    return
+
+            except subprocess.TimeoutExpired:
+                logger.warning("Installation of kuzu-memory timed out")
+                return
+            except Exception as e:
+                logger.warning(f"Error installing kuzu-memory: {e}")
+                return
+
+        # At this point, kuzu-memory should be available
+        # Get the actual command to use
+        import shutil
+
+        kuzu_memory_cmd = shutil.which("kuzu-memory")
+        if not kuzu_memory_cmd:
+            # Try pipx installation path as fallback
+            pipx_path = Path.home() / ".local/pipx/venvs/kuzu-memory/bin/kuzu-memory"
+            if pipx_path.exists():
+                kuzu_memory_cmd = str(pipx_path)
+            else:
+                logger.debug("kuzu-memory command not found after installation")
+                return
+
+        # Check for kuzu-memory updates (non-blocking)
         try:
-            with open(mcp_config_path) as f:
-                config_data = json.load(f)
-                mcp_servers = config_data.get("mcpServers", {})
-                configs.update(mcp_servers)
+            await _check_kuzu_memory_updates(kuzu_memory_cmd)
         except Exception as e:
-            get_logger("MCPProcessPool").warning(f"Failed to load MCP config: {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"
+
+        # Check if database is already initialized
+        if kuzu_memories_dir.exists():
+            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}"
+            )
+
+            # Initialize the database in current project directory
+            import subprocess
+
+            proc = subprocess.run(
+                [kuzu_memory_cmd, "init"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=str(current_dir),
+                check=False,
+            )
+
+            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}")
+
+    except Exception as e:
+        logger.debug(f"Kuzu-memory auto-initialization error (non-critical): {e}")
+
+
+async def _check_kuzu_memory_updates(kuzu_cmd: Path) -> None:
+    """
+    Check for kuzu-memory updates and prompt user.
+
+    Args:
+        kuzu_cmd: Path to kuzu-memory command
 
-    if configs:
-        await pool.pre_warm_servers(configs)
-        await pool.start_health_monitoring()
+    WHY: Keep users informed about important updates that may fix bugs
+    or add features they need.
 
-    return pool
+    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")
+
+    # Skip if environment variable set
+    if os.environ.get("CLAUDE_MPM_SKIP_UPDATE_CHECK"):
+        return
+
+    # Skip if not TTY (can't prompt)
+    if not sys.stdin.isatty():
+        return
+
+    # 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
+
+    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
+                )
+
+                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...", file=sys.stderr)
+            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!", file=sys.stderr)
+                    logger.info(f"Updated kuzu-memory from {current} to {latest}")
+                else:
+                    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.", file=sys.stderr)
+                logger.warning("kuzu-memory update timed out")
+            except Exception as 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:", 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.",
+                    file=sys.stderr,
+                )
+    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 claude_config_path.open() 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 mcp_config_path.open() 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()

claude_mpm/services/mcp_gateway/core/singleton_manager.py

@@ -149,7 +149,7 @@ class MCPGatewayManager:
             return None
 
         try:
-            with open(self.instance_file) as f:
+            with self.instance_file.open() as f:
                 instance_info = json.load(f)
 
             # Validate PID is still running
@@ -195,7 +195,7 @@ class MCPGatewayManager:
                 "lock_file": str(self.lock_file),
             }
 
-            with open(self.instance_file, "w") as f:
+            with self.instance_file.open("w") as f:
                 json.dump(instance_info, f, indent=2)
 
             self._current_instance = instance_info

claude_mpm/services/mcp_gateway/core/startup_verification.py

@@ -45,7 +45,7 @@ class MCPGatewayStartupVerifier:
             "system_info",  # System diagnostics
             "health_check",  # Health diagnostics
             "document_summarizer",  # File summarizer
-            "ticket",  # Ticket service (unified)
+            # Ticket functionality now provided by mcp-ticketer
         ]
 
     async def verify_and_configure(self) -> Dict[str, Any]:
@@ -125,7 +125,7 @@ class MCPGatewayStartupVerifier:
         try:
             import json
 
-            with open(self.config_file, "w") as f:
+            with self.config_file.open("w") as f:
                 json.dump(default_config, f, indent=2)
 
             self.logger.info(
@@ -210,7 +210,7 @@ class MCPGatewayStartupVerifier:
                 "..tools.document_summarizer",
                 "DocumentSummarizerTool",
             ),
-            "ticket": ("..tools.unified_ticket_tool", "UnifiedTicketTool"),
+            # Ticket functionality now provided by mcp-ticketer
         }
 
         if tool_name not in tool_map: