claude-mpm 4.3.6__py3-none-any.whl → 4.3.12__py3-none-any.whl

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -0,0 +1,390 @@
+"""
+External MCP Services Integration
+==================================
+
+Manages installation and basic setup of external MCP services like mcp-vector-search
+and mcp-browser. These services run as separate MCP servers in Claude Desktop,
+not as part of the Claude MPM MCP Gateway.
+
+Note: As of the latest architecture, external services are registered as separate
+MCP servers in Claude Desktop configuration, not as tools within the gateway.
+"""
+
+import asyncio
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
+from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseMCPToolAdapter
+
+
+class ExternalMCPService(BaseMCPToolAdapter):
+    """Base class for external MCP service integration."""
+
+    def __init__(self, service_name: str, package_name: str):
+        """
+        Initialize external MCP service.
+
+        Args:
+            service_name: Name of the service for MCP
+            package_name: Python package name to install/run
+        """
+        super().__init__()
+        self.service_name = service_name
+        self.package_name = package_name
+        self.process = None
+        self._is_installed = False
+
+    async def initialize(self) -> bool:
+        """Initialize the external service."""
+        try:
+            # Check if package is installed
+            self._is_installed = await self._check_installation()
+
+            if not self._is_installed:
+                self.logger.warning(f"{self.package_name} not installed, attempting installation...")
+                await self._install_package()
+                self._is_installed = await self._check_installation()
+
+            if not self._is_installed:
+                self.logger.error(f"Failed to install {self.package_name}")
+                return False
+
+            self.logger.info(f"{self.package_name} is available")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to initialize {self.service_name}: {e}")
+            return False
+
+    async def _check_installation(self) -> bool:
+        """Check if the package is installed."""
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", self.package_name.replace("-", "_"), "--help"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
+            return False
+
+    async def _install_package(self) -> bool:
+        """Install the package using pip."""
+        try:
+            self.logger.info(f"Installing {self.package_name}...")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", self.package_name],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+
+            if result.returncode == 0:
+                self.logger.info(f"Successfully installed {self.package_name}")
+                return True
+            else:
+                self.logger.error(f"Failed to install {self.package_name}: {result.stderr}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Error installing {self.package_name}: {e}")
+            return False
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get service definition for MCP registration."""
+        return {
+            "name": self.service_name,
+            "description": f"External MCP service: {self.package_name}",
+            "type": "external_service",
+            "package": self.package_name,
+            "installed": self._is_installed
+        }
+
+
+class MCPVectorSearchService(ExternalMCPService):
+    """MCP Vector Search service integration."""
+
+    def __init__(self):
+        """Initialize MCP Vector Search service."""
+        super().__init__("mcp-vector-search", "mcp-vector-search")
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get tool definition for MCP registration."""
+        base_def = super().get_definition()
+        base_def.update({
+            "description": "Semantic code search powered by vector embeddings",
+            "tools": [
+                {
+                    "name": "mcp__mcp-vector-search__search_code",
+                    "description": "Search for code using semantic similarity",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "The search query"},
+                            "limit": {"type": "integer", "default": 10},
+                            "similarity_threshold": {"type": "number", "default": 0.3},
+                            "language": {"type": "string"},
+                            "file_extensions": {"type": "array", "items": {"type": "string"}},
+                            "files": {"type": "string"},
+                            "class_name": {"type": "string"},
+                            "function_name": {"type": "string"}
+                        },
+                        "required": ["query"]
+                    }
+                },
+                {
+                    "name": "mcp__mcp-vector-search__search_similar",
+                    "description": "Find code similar to a specific file or function",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "file_path": {"type": "string", "description": "Path to the file"},
+                            "function_name": {"type": "string"},
+                            "limit": {"type": "integer", "default": 10},
+                            "similarity_threshold": {"type": "number", "default": 0.3}
+                        },
+                        "required": ["file_path"]
+                    }
+                },
+                {
+                    "name": "mcp__mcp-vector-search__search_context",
+                    "description": "Search for code based on contextual description",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "description": {"type": "string", "description": "Contextual description"},
+                            "focus_areas": {"type": "array", "items": {"type": "string"}},
+                            "limit": {"type": "integer", "default": 10}
+                        },
+                        "required": ["description"]
+                    }
+                },
+                {
+                    "name": "mcp__mcp-vector-search__get_project_status",
+                    "description": "Get project indexing status and statistics",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                },
+                {
+                    "name": "mcp__mcp-vector-search__index_project",
+                    "description": "Index or reindex the project codebase",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "force": {"type": "boolean", "default": False},
+                            "file_extensions": {"type": "array", "items": {"type": "string"}}
+                        },
+                        "required": []
+                    }
+                }
+            ]
+        })
+        return base_def
+
+    async def invoke(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke a tool from mcp-vector-search."""
+        try:
+            # Extract the actual tool name (remove prefix)
+            actual_tool = tool_name.replace("mcp__mcp-vector-search__", "")
+
+            # Prepare the command
+            cmd = [
+                sys.executable, "-m", "mcp_vector_search",
+                "--tool", actual_tool,
+                "--args", json.dumps(arguments)
+            ]
+
+            # Run the command
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=Path.cwd()  # Use current working directory for project context
+            )
+
+            if result.returncode == 0:
+                try:
+                    return json.loads(result.stdout)
+                except json.JSONDecodeError:
+                    return {"result": result.stdout}
+            else:
+                return {"error": result.stderr or "Tool invocation failed"}
+
+        except subprocess.TimeoutExpired:
+            return {"error": "Tool invocation timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+class MCPBrowserService(ExternalMCPService):
+    """MCP Browser service integration."""
+
+    def __init__(self):
+        """Initialize MCP Browser service."""
+        super().__init__("mcp-browser", "mcp-browser")
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get tool definition for MCP registration."""
+        base_def = super().get_definition()
+        base_def.update({
+            "description": "Web browsing and content extraction capabilities",
+            "tools": [
+                {
+                    "name": "mcp__mcp-browser__browse",
+                    "description": "Browse a webpage and extract content",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "url": {"type": "string", "description": "URL to browse"},
+                            "extract": {"type": "string", "description": "What to extract"}
+                        },
+                        "required": ["url"]
+                    }
+                },
+                {
+                    "name": "mcp__mcp-browser__search",
+                    "description": "Search the web",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "Search query"},
+                            "num_results": {"type": "integer", "default": 10}
+                        },
+                        "required": ["query"]
+                    }
+                },
+                {
+                    "name": "mcp__mcp-browser__screenshot",
+                    "description": "Take a screenshot of a webpage",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "url": {"type": "string", "description": "URL to screenshot"},
+                            "full_page": {"type": "boolean", "default": False}
+                        },
+                        "required": ["url"]
+                    }
+                }
+            ]
+        })
+        return base_def
+
+    async def invoke(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke a tool from mcp-browser."""
+        try:
+            # Extract the actual tool name (remove prefix)
+            actual_tool = tool_name.replace("mcp__mcp-browser__", "")
+
+            # Prepare the command
+            cmd = [
+                sys.executable, "-m", "mcp_browser",
+                "--tool", actual_tool,
+                "--args", json.dumps(arguments)
+            ]
+
+            # Run the command
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+
+            if result.returncode == 0:
+                try:
+                    return json.loads(result.stdout)
+                except json.JSONDecodeError:
+                    return {"result": result.stdout}
+            else:
+                return {"error": result.stderr or "Tool invocation failed"}
+
+        except subprocess.TimeoutExpired:
+            return {"error": "Tool invocation timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+class ExternalMCPServiceManager:
+    """Manager for external MCP services.
+
+    This manager is responsible for checking and installing Python packages
+    for external MCP services. The actual registration of these services
+    happens in Claude Desktop configuration as separate MCP servers.
+
+    Note: This class is maintained for backward compatibility and package
+    management. The actual tool registration is handled by separate MCP
+    server instances in Claude Desktop.
+    """
+
+    def __init__(self):
+        """Initialize the service manager."""
+        self.services: List[ExternalMCPService] = []
+        self.logger = None
+
+    async def initialize_services(self) -> List[ExternalMCPService]:
+        """Initialize all external MCP services.
+
+        This method checks if external service packages are installed
+        and attempts to install them if missing. It does NOT register
+        them as tools in the gateway - they run as separate MCP servers.
+        """
+        # Create service instances
+        services = [
+            MCPVectorSearchService(),
+            MCPBrowserService()
+        ]
+
+        # Initialize each service
+        initialized_services = []
+        for service in services:
+            try:
+                if await service.initialize():
+                    initialized_services.append(service)
+                    if self.logger:
+                        self.logger.info(f"Initialized external service: {service.service_name}")
+                else:
+                    if self.logger:
+                        self.logger.warning(f"Failed to initialize: {service.service_name}")
+            except Exception as e:
+                if self.logger:
+                    self.logger.error(f"Error initializing {service.service_name}: {e}")
+
+        self.services = initialized_services
+        return initialized_services
+
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """Get all tool definitions from external services."""
+        all_tools = []
+        for service in self.services:
+            service_def = service.get_definition()
+            if "tools" in service_def:
+                all_tools.extend(service_def["tools"])
+        return all_tools
+
+    async def invoke_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke a tool from any registered external service."""
+        # Find the service that handles this tool
+        for service in self.services:
+            if tool_name.startswith(f"mcp__{service.service_name}__"):
+                if isinstance(service, (MCPVectorSearchService, MCPBrowserService)):
+                    return await service.invoke(tool_name, arguments)
+
+        return {"error": f"No service found for tool: {tool_name}"}
+
+    async def shutdown(self):
+        """Shutdown all external services."""
+        for service in self.services:
+            try:
+                await service.shutdown()
+            except Exception as e:
+                if self.logger:
+                    self.logger.warning(f"Error shutting down {service.service_name}: {e}")

claude_mpm/utils/log_cleanup.py

@@ -9,7 +9,7 @@ import gzip
 import logging
 import os
 import shutil
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Dict, Optional, Tuple
 
@@ -92,7 +92,7 @@ class LogCleanupUtility:
             logger.info(f"Sessions directory not found: {sessions_dir}")
             return 0, 0.0
 
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -107,7 +107,7 @@ class LogCleanupUtility:
 
                 try:
                     # Check directory modification time
-                    mtime = datetime.fromtimestamp(session_dir.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(session_dir.stat().st_mtime, tz=timezone.utc)
 
                     if mtime < cutoff_time:
                         # Calculate directory size
@@ -117,14 +117,14 @@ class LogCleanupUtility:
                         if dry_run:
                             logger.info(
                                 f"[DRY RUN] Would remove session: {session_dir.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {dir_size:.2f} MB)"
                             )
                         else:
                             shutil.rmtree(session_dir)
                             logger.info(
                                 f"Removed session: {session_dir.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {dir_size:.2f} MB)"
                             )
 
@@ -159,7 +159,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files removed, space freed in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -169,7 +169,7 @@ class LogCleanupUtility:
         for ext in LogCleanupConfig.ARCHIVE_EXTENSIONS:
             for archive_file in self.base_log_dir.rglob(f"*{ext}"):
                 try:
-                    mtime = datetime.fromtimestamp(archive_file.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(archive_file.stat().st_mtime, tz=timezone.utc)
 
                     if mtime < cutoff_time:
                         file_size = archive_file.stat().st_size / (1024 * 1024)  # MB
@@ -178,14 +178,14 @@ class LogCleanupUtility:
                         if dry_run:
                             logger.info(
                                 f"[DRY RUN] Would remove archive: {archive_file.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {file_size:.2f} MB)"
                             )
                         else:
                             archive_file.unlink()
                             logger.info(
                                 f"Removed archive: {archive_file.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {file_size:.2f} MB)"
                             )
 
@@ -218,7 +218,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files removed, space freed in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -238,7 +238,7 @@ class LogCleanupUtility:
 
                 for log_file in log_dir.glob(pattern):
                     try:
-                        mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                        mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc)
 
                         if mtime < cutoff_time:
                             file_size = log_file.stat().st_size / (1024 * 1024)  # MB
@@ -247,14 +247,14 @@ class LogCleanupUtility:
                             if dry_run:
                                 logger.info(
                                     f"[DRY RUN] Would remove log: {log_file.name} "
-                                    f"(age: {(datetime.now() - mtime).days} days, "
+                                    f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                     f"size: {file_size:.2f} MB)"
                                 )
                             else:
                                 log_file.unlink()
                                 logger.info(
                                     f"Removed log: {log_file.name} "
-                                    f"(age: {(datetime.now() - mtime).days} days, "
+                                    f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                     f"size: {file_size:.2f} MB)"
                                 )
 
@@ -321,7 +321,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files compressed, space saved in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=age_days)
         compressed_count = 0
         space_saved = 0.0
 
@@ -331,7 +331,7 @@ class LogCleanupUtility:
                 continue
 
             try:
-                mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc)
 
                 if mtime < cutoff_time:
                     original_size = log_file.stat().st_size / (1024 * 1024)  # MB
@@ -408,7 +408,7 @@ class LogCleanupUtility:
                 stats["oldest_session"] = {
                     "name": oldest.name,
                     "age_days": (
-                        datetime.now() - datetime.fromtimestamp(oldest.stat().st_mtime)
+                        datetime.now(timezone.utc) - datetime.fromtimestamp(oldest.stat().st_mtime, tz=timezone.utc)
                     ).days,
                 }
 
@@ -429,7 +429,7 @@ class LogCleanupUtility:
                 "name": oldest_log.name,
                 "path": str(oldest_log.relative_to(self.base_log_dir)),
                 "age_days": (
-                    datetime.now() - datetime.fromtimestamp(oldest_log.stat().st_mtime)
+                    datetime.now(timezone.utc) - datetime.fromtimestamp(oldest_log.stat().st_mtime, tz=timezone.utc)
                 ).days,
             }
 

claude_mpm/utils/subprocess_utils.py

@@ -83,7 +83,7 @@ def run_command(command_string: str, timeout: float = 60) -> str:
             returncode=getattr(e, "returncode", None),
             stdout=getattr(e, "stdout", ""),
             stderr=stderr,
-        )
+        ) from e
 
 
 def run_subprocess(
@@ -137,16 +137,16 @@ def run_subprocess(
             returncode=None,
             stdout=e.stdout.decode() if e.stdout else "",
             stderr=e.stderr.decode() if e.stderr else "",
-        )
+        ) from e
     except subprocess.CalledProcessError as e:
         raise SubprocessError(
             f"Command failed with return code {e.returncode}: {' '.join(cmd)}",
             returncode=e.returncode,
             stdout=e.stdout if e.stdout else "",
             stderr=e.stderr if e.stderr else "",
-        )
+        ) from e
     except Exception as e:
-        raise SubprocessError(f"Subprocess execution failed: {e}")
+        raise SubprocessError(f"Subprocess execution failed: {e}") from e
 
 
 async def run_subprocess_async(
@@ -195,7 +195,7 @@ async def run_subprocess_async(
             await process.wait()
             raise SubprocessError(
                 f"Command timed out after {timeout}s: {' '.join(cmd)}", returncode=None
-            )
+            ) from None
 
         return SubprocessResult(
             returncode=process.returncode,
@@ -205,7 +205,7 @@ async def run_subprocess_async(
 
     except Exception as e:
         if not isinstance(e, SubprocessError):
-            raise SubprocessError(f"Async subprocess execution failed: {e}")
+            raise SubprocessError(f"Async subprocess execution failed: {e}") from e
         raise
 
 

{claude_mpm-4.3.6.dist-info → claude_mpm-4.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.3.6
+Version: 4.3.12
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team
@@ -42,6 +42,9 @@ Requires-Dist: mistune>=3.0.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: ijson>=3.2.0
 Requires-Dist: mcp>=0.1.0
+Requires-Dist: mcp-vector-search>=0.1.0
+Requires-Dist: mcp-browser>=0.1.0
+Requires-Dist: mcp-ticketer>=0.1.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic>=2.0.0
@@ -120,6 +123,26 @@ Requires-Dist: tree-sitter-cpp>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-c>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-ruby>=0.21.0; extra == "agents"
 Requires-Dist: tree-sitter-php>=0.21.0; extra == "agents"
+Provides-Extra: data-processing
+Requires-Dist: pandas>=2.1.0; extra == "data-processing"
+Requires-Dist: openpyxl>=3.1.0; extra == "data-processing"
+Requires-Dist: xlsxwriter>=3.1.0; extra == "data-processing"
+Requires-Dist: numpy>=1.24.0; extra == "data-processing"
+Requires-Dist: pyarrow>=14.0.0; extra == "data-processing"
+Requires-Dist: dask>=2023.12.0; extra == "data-processing"
+Requires-Dist: polars>=0.19.0; extra == "data-processing"
+Requires-Dist: xlrd>=2.0.0; extra == "data-processing"
+Requires-Dist: xlwt>=1.3.0; extra == "data-processing"
+Requires-Dist: csvkit>=1.3.0; extra == "data-processing"
+Requires-Dist: tabulate>=0.9.0; extra == "data-processing"
+Requires-Dist: python-dateutil>=2.8.0; extra == "data-processing"
+Requires-Dist: lxml>=4.9.0; extra == "data-processing"
+Requires-Dist: sqlalchemy>=2.0.0; extra == "data-processing"
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "data-processing"
+Requires-Dist: pymongo>=4.5.0; extra == "data-processing"
+Requires-Dist: redis>=5.0.0; extra == "data-processing"
+Requires-Dist: beautifulsoup4>=4.12.0; extra == "data-processing"
+Requires-Dist: jsonschema>=4.19.0; extra == "data-processing"
 Dynamic: license-file
 
 # Claude MPM - Multi-Agent Project Manager