emdash-core 0.1.7__py3-none-any.whl

emdash_core/agent/mcp/client.py

@@ -0,0 +1,346 @@
+"""Generic MCP client for communicating with MCP servers.
+
+This module provides a generic client that can communicate with any
+MCP-compliant server over stdio.
+"""
+
+import json
+import subprocess
+import threading
+from dataclasses import dataclass, field
+from typing import Any, Optional
+from queue import Queue, Empty
+
+from ...utils.logger import log
+
+
+class MCPError(Exception):
+    """Error from MCP server communication."""
+    pass
+
+
+@dataclass
+class MCPToolInfo:
+    """Information about a tool provided by an MCP server.
+
+    Attributes:
+        name: Tool name
+        description: Tool description
+        input_schema: JSON Schema for tool input
+    """
+    name: str
+    description: str
+    input_schema: dict = field(default_factory=dict)
+
+
+@dataclass
+class MCPResponse:
+    """Response from an MCP tool call.
+
+    Attributes:
+        content: Response content (list of content items)
+        is_error: Whether this is an error response
+    """
+    content: list[dict] = field(default_factory=list)
+    is_error: bool = False
+
+    def get_text(self) -> str:
+        """Extract text content from response.
+
+        Returns:
+            Concatenated text content
+        """
+        texts = []
+        for item in self.content:
+            if item.get("type") == "text":
+                texts.append(item.get("text", ""))
+        return "\n".join(texts)
+
+
+class GenericMCPClient:
+    """Generic client for MCP servers.
+
+    Communicates with MCP servers over stdio using JSON-RPC.
+
+    Example:
+        client = GenericMCPClient(
+            name="github",
+            command="github-mcp-server",
+            args=["stdio"],
+            env={"GITHUB_TOKEN": "..."},
+        )
+        client.start()
+
+        tools = client.list_tools()
+        result = client.call_tool("search_code", {"query": "auth"})
+
+        client.stop()
+    """
+
+    def __init__(
+        self,
+        name: str,
+        command: str,
+        args: list[str] = None,
+        env: dict[str, str] = None,
+        timeout: int = 30,
+    ):
+        """Initialize the MCP client.
+
+        Args:
+            name: Name for this client (for logging)
+            command: Command to run the server
+            args: Command arguments
+            env: Environment variables
+            timeout: Timeout for operations in seconds
+        """
+        self.name = name
+        self.command = command
+        self.args = args or []
+        self.env = env or {}
+        self.timeout = timeout
+
+        self._process: Optional[subprocess.Popen] = None
+        self._request_id = 0
+        self._pending: dict[int, Queue] = {}
+        self._reader_thread: Optional[threading.Thread] = None
+        self._running = False
+        self._tools: list[MCPToolInfo] = []
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the client is running."""
+        return self._running and self._process is not None
+
+    def start(self) -> None:
+        """Start the MCP server process."""
+        if self._running:
+            return
+
+        import os
+
+        # Build environment
+        full_env = os.environ.copy()
+        full_env.update(self.env)
+
+        try:
+            self._process = subprocess.Popen(
+                [self.command] + self.args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=full_env,
+                text=True,
+                bufsize=1,
+            )
+        except FileNotFoundError:
+            raise MCPError(f"MCP server command not found: {self.command}")
+        except Exception as e:
+            raise MCPError(f"Failed to start MCP server: {e}")
+
+        self._running = True
+
+        # Start reader thread
+        self._reader_thread = threading.Thread(target=self._read_responses, daemon=True)
+        self._reader_thread.start()
+
+        # Initialize the connection
+        self._initialize()
+
+        log.info(f"Started MCP server: {self.name}")
+
+    def stop(self) -> None:
+        """Stop the MCP server process."""
+        self._running = False
+
+        if self._process:
+            try:
+                self._process.terminate()
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+            except Exception:
+                pass
+            finally:
+                self._process = None
+
+        self._tools = []
+        log.info(f"Stopped MCP server: {self.name}")
+
+    def _initialize(self) -> None:
+        """Initialize the MCP connection."""
+        # Send initialize request
+        response = self._send_request("initialize", {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {
+                "name": "emdash",
+                "version": "1.0.0",
+            },
+        })
+
+        # Send initialized notification
+        self._send_notification("notifications/initialized", {})
+
+    def _send_request(self, method: str, params: dict) -> dict:
+        """Send a JSON-RPC request and wait for response.
+
+        Args:
+            method: RPC method name
+            params: Method parameters
+
+        Returns:
+            Response result
+
+        Raises:
+            MCPError: On communication error or error response
+        """
+        if not self._process or not self._running:
+            raise MCPError("MCP client not running")
+
+        self._request_id += 1
+        request_id = self._request_id
+
+        request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params,
+        }
+
+        # Create response queue
+        response_queue: Queue = Queue()
+        self._pending[request_id] = response_queue
+
+        try:
+            # Send request
+            request_line = json.dumps(request) + "\n"
+            self._process.stdin.write(request_line)
+            self._process.stdin.flush()
+
+            # Wait for response
+            try:
+                response = response_queue.get(timeout=self.timeout)
+            except Empty:
+                raise MCPError(f"Timeout waiting for response to {method}")
+
+            if "error" in response:
+                error = response["error"]
+                raise MCPError(f"MCP error: {error.get('message', 'Unknown error')}")
+
+            return response.get("result", {})
+
+        finally:
+            del self._pending[request_id]
+
+    def _send_notification(self, method: str, params: dict) -> None:
+        """Send a JSON-RPC notification (no response expected).
+
+        Args:
+            method: Notification method
+            params: Method parameters
+        """
+        if not self._process or not self._running:
+            return
+
+        notification = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+        }
+
+        notification_line = json.dumps(notification) + "\n"
+        self._process.stdin.write(notification_line)
+        self._process.stdin.flush()
+
+    def _read_responses(self) -> None:
+        """Background thread to read responses from the server."""
+        while self._running and self._process:
+            try:
+                line = self._process.stdout.readline()
+                if not line:
+                    break
+
+                try:
+                    response = json.loads(line.strip())
+                except json.JSONDecodeError:
+                    continue
+
+                # Route to pending request
+                request_id = response.get("id")
+                if request_id and request_id in self._pending:
+                    self._pending[request_id].put(response)
+
+            except Exception as e:
+                if self._running:
+                    log.warning(f"Error reading MCP response: {e}")
+                break
+
+    def list_tools(self) -> list[MCPToolInfo]:
+        """List available tools from the server.
+
+        Returns:
+            List of MCPToolInfo
+        """
+        if self._tools:
+            return self._tools
+
+        result = self._send_request("tools/list", {})
+
+        tools = []
+        for tool_data in result.get("tools", []):
+            tools.append(MCPToolInfo(
+                name=tool_data.get("name", ""),
+                description=tool_data.get("description", ""),
+                input_schema=tool_data.get("inputSchema", {}),
+            ))
+
+        self._tools = tools
+        return tools
+
+    def call_tool(self, name: str, arguments: dict) -> MCPResponse:
+        """Call a tool on the server.
+
+        Args:
+            name: Tool name
+            arguments: Tool arguments
+
+        Returns:
+            MCPResponse with tool result
+        """
+        result = self._send_request("tools/call", {
+            "name": name,
+            "arguments": arguments,
+        })
+
+        return MCPResponse(
+            content=result.get("content", []),
+            is_error=result.get("isError", False),
+        )
+
+
+# Legacy client for backward compatibility
+class GitHubMCPClient(GenericMCPClient):
+    """GitHub-specific MCP client.
+
+    Deprecated: Use GenericMCPClient directly with appropriate config.
+    """
+
+    def __init__(self, token: Optional[str] = None, timeout: int = 30):
+        """Initialize GitHub MCP client.
+
+        Args:
+            token: GitHub token. If None, reads from environment.
+            timeout: Operation timeout in seconds.
+        """
+        import os
+
+        github_token = token or os.getenv("GITHUB_TOKEN") or os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
+
+        super().__init__(
+            name="github",
+            command="github-mcp-server",
+            args=["stdio"],
+            env={"GITHUB_PERSONAL_ACCESS_TOKEN": github_token or ""},
+            timeout=timeout,
+        )

emdash_core/agent/mcp/config.py

@@ -0,0 +1,302 @@
+"""MCP configuration schema and loading.
+
+This module provides configuration classes for managing MCP servers,
+compatible with Claude Desktop's mcp_config.json format.
+"""
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from ...utils.logger import log
+
+
+@dataclass
+class MCPServerConfig:
+    """Configuration for a single MCP server.
+
+    Attributes:
+        name: Unique identifier for this server
+        command: Command to run (e.g., "npx", "github-mcp-server")
+        args: Arguments to pass to the command
+        env: Environment variables (supports ${VAR} syntax)
+        enabled: Whether this server is enabled
+        timeout: Timeout in seconds for tool calls
+    """
+
+    name: str
+    command: str
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
+    enabled: bool = True
+    timeout: int = 30
+
+    def get_resolved_env(self) -> dict[str, str]:
+        """Resolve environment variable references like ${VAR_NAME}.
+
+        For GitHub tokens, also checks Rove auth config first.
+        For graph DB path, uses emdash config default.
+
+        Returns:
+            Dictionary with resolved environment values
+        """
+        resolved = {}
+        pattern = re.compile(r"\$\{([^}]+)\}")
+
+        def get_env_value(var_name: str) -> str:
+            """Get environment value, checking emdash config for special vars."""
+            # Check for GitHub token - use emdash auth if available
+            if var_name in ("GITHUB_TOKEN", "GITHUB_PERSONAL_ACCESS_TOKEN"):
+                try:
+                    from ...auth import get_github_token
+                    token = get_github_token()
+                    if token:
+                        return token
+                except ImportError:
+                    pass
+            # Check for graph DB path - use emdash config default
+            if var_name == "EMDASH_GRAPH_DB_PATH":
+                env_val = os.getenv(var_name)
+                if env_val:
+                    return env_val
+                # Default to .emdash/index/kuzu_db in cwd
+                default_path = Path.cwd() / ".emdash" / "index" / "kuzu_db"
+                return str(default_path)
+            # Fall back to environment variable
+            return os.getenv(var_name, "")
+
+        for key, value in self.env.items():
+            match = pattern.fullmatch(value)
+            if match:
+                env_var = match.group(1)
+                env_value = get_env_value(env_var)
+                if not env_value:
+                    log.warning(f"Environment variable {env_var} not set for MCP server {self.name}")
+                resolved[key] = env_value
+            else:
+                # Check for partial substitution like "prefix_${VAR}_suffix"
+                def replace_var(m):
+                    return get_env_value(m.group(1))
+
+                resolved[key] = pattern.sub(replace_var, value)
+
+        return resolved
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "command": self.command,
+            "args": self.args,
+            "env": self.env,
+            "enabled": self.enabled,
+            "timeout": self.timeout,
+        }
+
+    @classmethod
+    def from_dict(cls, name: str, data: dict) -> "MCPServerConfig":
+        """Create from dictionary."""
+        return cls(
+            name=name,
+            command=data.get("command", ""),
+            args=data.get("args", []),
+            env=data.get("env", {}),
+            enabled=data.get("enabled", True),
+            timeout=data.get("timeout", 30),
+        )
+
+
+@dataclass
+class MCPConfigFile:
+    """Root configuration for all MCP servers.
+
+    This class handles loading and saving the MCP configuration file,
+    which uses Claude Desktop's format:
+
+    {
+        "mcpServers": {
+            "server-name": {
+                "command": "...",
+                "args": [...],
+                "env": {...}
+            }
+        }
+    }
+    """
+
+    servers: dict[str, MCPServerConfig] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls, path: Path) -> "MCPConfigFile":
+        """Load MCP configuration from file.
+
+        Args:
+            path: Path to the configuration file
+
+        Returns:
+            MCPConfigFile instance (empty if file doesn't exist)
+        """
+        if not path.exists():
+            log.debug(f"MCP config file not found: {path}")
+            return cls()
+
+        try:
+            with open(path) as f:
+                data = json.load(f)
+        except json.JSONDecodeError as e:
+            log.error(f"Invalid JSON in MCP config file {path}: {e}")
+            return cls()
+        except Exception as e:
+            log.error(f"Failed to read MCP config file {path}: {e}")
+            return cls()
+
+        servers = {}
+        for name, config in data.get("mcpServers", {}).items():
+            try:
+                servers[name] = MCPServerConfig.from_dict(name, config)
+            except Exception as e:
+                log.warning(f"Invalid MCP server config '{name}': {e}")
+
+        log.info(f"Loaded MCP config with {len(servers)} servers from {path}")
+        return cls(servers=servers)
+
+    def save(self, path: Path) -> None:
+        """Save configuration to file.
+
+        Args:
+            path: Path to save the configuration file
+        """
+        data = {"mcpServers": {}}
+        for name, server in self.servers.items():
+            data["mcpServers"][name] = server.to_dict()
+
+        # Ensure directory exists
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+
+        log.info(f"Saved MCP config to {path}")
+
+    def get_enabled_servers(self) -> list[MCPServerConfig]:
+        """Get list of enabled server configurations.
+
+        Returns:
+            List of enabled MCPServerConfig instances
+        """
+        return [s for s in self.servers.values() if s.enabled]
+
+    def add_server(self, config: MCPServerConfig) -> None:
+        """Add or update a server configuration.
+
+        Args:
+            config: Server configuration to add
+        """
+        self.servers[config.name] = config
+
+    def remove_server(self, name: str) -> bool:
+        """Remove a server configuration.
+
+        Args:
+            name: Name of the server to remove
+
+        Returns:
+            True if server was removed, False if not found
+        """
+        if name in self.servers:
+            del self.servers[name]
+            return True
+        return False
+
+    def get_server(self, name: str) -> Optional[MCPServerConfig]:
+        """Get a server configuration by name.
+
+        Args:
+            name: Name of the server
+
+        Returns:
+            MCPServerConfig or None if not found
+        """
+        return self.servers.get(name)
+
+
+def get_default_mcp_config_path(repo_root: Optional[Path] = None) -> Path:
+    """Get the default path for the MCP configuration file.
+
+    Args:
+        repo_root: Repository root directory (uses cwd if not provided)
+
+    Returns:
+        Path to .emdash/mcp.json
+    """
+    if repo_root is None:
+        repo_root = Path.cwd()
+    return repo_root / ".emdash" / "mcp.json"
+
+
+def get_default_mcp_servers() -> dict[str, MCPServerConfig]:
+    """Get the default MCP servers that ship with Rove.
+
+    Returns:
+        Dictionary of default server configurations
+    """
+    # Check if graph MCP is enabled via env flag
+    enable_graph_mcp = os.getenv("ENABLE_GRAPH_MCP", "false").lower() == "true"
+
+    return {
+        "github": MCPServerConfig(
+            name="github",
+            command="github-mcp-server",
+            args=["stdio"],
+            env={
+                "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}",
+            },
+            enabled=False,  # Disabled - use local tools for codebase exploration
+            timeout=30,
+        ),
+        "emdash-graph": MCPServerConfig(
+            name="emdash-graph",
+            command="emdash-graph-mcp",
+            args=["--db-path", "${EMDASH_GRAPH_DB_PATH}"],
+            env={
+                "EMDASH_GRAPH_DB_PATH": "${EMDASH_GRAPH_DB_PATH}",
+            },
+            enabled=enable_graph_mcp,
+            timeout=30,
+        ),
+    }
+
+
+def create_default_mcp_config(path: Path) -> MCPConfigFile:
+    """Create a default MCP config file with pre-configured servers.
+
+    This creates the .emdash/mcp.json file with GitHub MCP enabled
+    by default for all new Rove installations.
+
+    Args:
+        path: Path to save the config file
+
+    Returns:
+        The created MCPConfigFile
+    """
+    config = MCPConfigFile(servers=get_default_mcp_servers())
+    config.save(path)
+    log.info(f"Created default MCP config with GitHub MCP at {path}")
+    return config
+
+
+def ensure_mcp_config(path: Path) -> MCPConfigFile:
+    """Ensure MCP config exists, creating default if needed.
+
+    Args:
+        path: Path to the config file
+
+    Returns:
+        MCPConfigFile (loaded or newly created)
+    """
+    if path.exists():
+        return MCPConfigFile.load(path)
+    else:
+        return create_default_mcp_config(path)