llmcode-cli 1.0.0__py3-none-any.whl

llm_code/marketplace/registry.py

@@ -0,0 +1,360 @@
+"""Plugin registry system — search adapters for official, npm, GitHub and custom sources."""
+from __future__ import annotations
+
+import asyncio
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class PluginSummary:
+    """Lightweight summary returned from registry search results."""
+
+    name: str
+    description: str
+    registry: str
+    version: str = ""
+
+
+@dataclass(frozen=True)
+class PluginDetails:
+    """Detailed information about a single plugin."""
+
+    name: str
+    description: str
+    version: str = ""
+    repository: str = ""
+    install_command: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Abstract base
+# ---------------------------------------------------------------------------
+
+class PluginRegistry(ABC):
+    """Abstract base class for all plugin registries."""
+
+    @abstractmethod
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        """Search the registry and return matching summaries."""
+        ...
+
+    @abstractmethod
+    async def get_details(self, name: str) -> PluginDetails | None:
+        """Fetch detailed information about a named plugin."""
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Official MCP registry
+# ---------------------------------------------------------------------------
+
+class OfficialRegistry(PluginRegistry):
+    """Adapter for registry.modelcontextprotocol.io."""
+
+    BASE_URL = "https://registry.modelcontextprotocol.io"
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self.BASE_URL}/v0/servers",
+                    params={"q": query},
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                data: dict[str, Any] = resp.json()
+        except Exception:
+            return []
+
+        results: list[PluginSummary] = []
+        for server in data.get("servers", []):
+            name: str = server.get("name", "")
+            description: str = server.get("description", "")
+            # Filter by query match when the API doesn't do server-side filtering
+            if query.lower() in name.lower() or query.lower() in description.lower():
+                results.append(
+                    PluginSummary(
+                        name=name,
+                        description=description,
+                        registry="official",
+                        version=str(server.get("version", "")),
+                    )
+                )
+                if len(results) >= limit:
+                    break
+        return results
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self.BASE_URL}/v0/servers/{name}",
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return None
+
+        return PluginDetails(
+            name=data.get("name", name),
+            description=data.get("description", ""),
+            version=str(data.get("version", "")),
+            repository=str(data.get("repository", "")),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Smithery registry
+# ---------------------------------------------------------------------------
+
+class SmitheryRegistry(PluginRegistry):
+    """Adapter for api.smithery.ai."""
+
+    BASE_URL = "https://api.smithery.ai"
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self.BASE_URL}/v1/servers",
+                    params={"q": query},
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return []
+
+        results: list[PluginSummary] = []
+        for server in data.get("servers", []):
+            results.append(
+                PluginSummary(
+                    name=server.get("name", ""),
+                    description=server.get("description", ""),
+                    registry="smithery",
+                    version=str(server.get("version", "")),
+                )
+            )
+            if len(results) >= limit:
+                break
+        return results
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# npm registry
+# ---------------------------------------------------------------------------
+
+class NpmRegistry(PluginRegistry):
+    """Adapter for the npm registry search API."""
+
+    BASE_URL = "https://registry.npmjs.org"
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self.BASE_URL}/-/v1/search",
+                    params={"text": f"mcp {query}", "size": limit},
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return []
+
+        results: list[PluginSummary] = []
+        for obj in data.get("objects", []):
+            pkg = obj.get("package", {})
+            results.append(
+                PluginSummary(
+                    name=pkg.get("name", ""),
+                    description=pkg.get("description", ""),
+                    registry="npm",
+                    version=str(pkg.get("version", "")),
+                )
+            )
+        return results
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self.BASE_URL}/{name}",
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return None
+
+        latest = data.get("dist-tags", {}).get("latest", "")
+        version_data = data.get("versions", {}).get(latest, {})
+        return PluginDetails(
+            name=data.get("name", name),
+            description=data.get("description", ""),
+            version=latest,
+            repository=str(version_data.get("repository", {}).get("url", "")),
+            install_command=f"npm install {name}",
+        )
+
+
+# ---------------------------------------------------------------------------
+# GitHub marketplace registry
+# ---------------------------------------------------------------------------
+
+class GitHubRegistry(PluginRegistry):
+    """Adapter for a GitHub-hosted marketplace.json file."""
+
+    def __init__(self, repo: str) -> None:
+        """Initialize with a 'owner/repo' string."""
+        self._repo = repo
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        url = f"https://raw.githubusercontent.com/{self._repo}/main/marketplace.json"
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(url, timeout=10.0)
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return []
+
+        results: list[PluginSummary] = []
+        for plugin in data.get("plugins", []):
+            name: str = plugin.get("name", "")
+            description: str = plugin.get("description", "")
+            if query.lower() in name.lower() or query.lower() in description.lower():
+                results.append(
+                    PluginSummary(
+                        name=name,
+                        description=description,
+                        registry="github",
+                        version=str(plugin.get("version", "")),
+                    )
+                )
+                if len(results) >= limit:
+                    break
+        return results
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        url = f"https://raw.githubusercontent.com/{self._repo}/main/marketplace.json"
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(url, timeout=10.0)
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return None
+
+        for plugin in data.get("plugins", []):
+            if plugin.get("name") == name:
+                return PluginDetails(
+                    name=plugin.get("name", ""),
+                    description=plugin.get("description", ""),
+                    version=str(plugin.get("version", "")),
+                    repository=str(plugin.get("repository", "")),
+                )
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Custom URL registry
+# ---------------------------------------------------------------------------
+
+class CustomRegistry(PluginRegistry):
+    """Adapter for an arbitrary URL serving a plugins[] JSON payload."""
+
+    def __init__(self, url: str) -> None:
+        self._url = url
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(self._url, timeout=10.0)
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return []
+
+        results: list[PluginSummary] = []
+        for plugin in data.get("plugins", []):
+            name: str = plugin.get("name", "")
+            description: str = plugin.get("description", "")
+            if query.lower() in name.lower() or query.lower() in description.lower():
+                results.append(
+                    PluginSummary(
+                        name=name,
+                        description=description,
+                        registry="custom",
+                        version=str(plugin.get("version", "")),
+                    )
+                )
+                if len(results) >= limit:
+                    break
+        return results
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        try:
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(self._url, timeout=10.0)
+                resp.raise_for_status()
+                data = resp.json()
+        except Exception:
+            return None
+
+        for plugin in data.get("plugins", []):
+            if plugin.get("name") == name:
+                return PluginDetails(
+                    name=plugin.get("name", ""),
+                    description=plugin.get("description", ""),
+                    version=str(plugin.get("version", "")),
+                )
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Unified registry — parallel search across all registered sources
+# ---------------------------------------------------------------------------
+
+class UnifiedRegistry(PluginRegistry):
+    """Aggregates multiple registries and searches them in parallel."""
+
+    def __init__(self, registries: dict[str, PluginRegistry]) -> None:
+        self._registries = registries
+
+    async def search(self, query: str, limit: int = 20) -> list[PluginSummary]:
+        if not self._registries:
+            return []
+
+        tasks = [reg.search(query, limit) for reg in self._registries.values()]
+        all_results: list[list[PluginSummary]] = await asyncio.gather(*tasks)
+
+        # Merge and deduplicate by name (first occurrence wins)
+        seen: set[str] = set()
+        merged: list[PluginSummary] = []
+        for batch in all_results:
+            for summary in batch:
+                if summary.name not in seen:
+                    seen.add(summary.name)
+                    merged.append(summary)
+
+        return merged
+
+    async def get_details(self, name: str) -> PluginDetails | None:
+        for reg in self._registries.values():
+            details = await reg.get_details(name)
+            if details is not None:
+                return details
+        return None

llm_code/mcp/bridge.py

@@ -0,0 +1,87 @@
+"""McpToolBridge: wraps an MCP tool as a Tool ABC."""
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+
+from llm_code.mcp.client import McpClient
+from llm_code.mcp.types import McpToolDefinition
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class McpToolBridge(Tool):
+    """Adapts a remote MCP tool to the local Tool ABC."""
+
+    def __init__(
+        self,
+        server_name: str,
+        mcp_tool: McpToolDefinition,
+        client: McpClient,
+    ) -> None:
+        self._server_name = server_name
+        self._mcp_tool = mcp_tool
+        self._client = client
+
+    # ------------------------------------------------------------------
+    # Tool ABC — identity & schema
+    # ------------------------------------------------------------------
+
+    @property
+    def name(self) -> str:
+        return f"mcp__{self._server_name}__{self._mcp_tool.name}"
+
+    @property
+    def description(self) -> str:
+        return self._mcp_tool.description
+
+    @property
+    def input_schema(self) -> dict:
+        return self._mcp_tool.input_schema
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.FULL_ACCESS
+
+    # ------------------------------------------------------------------
+    # Tool ABC — behaviour flags
+    # ------------------------------------------------------------------
+
+    def is_read_only(self, args: dict) -> bool:
+        return bool((self._mcp_tool.annotations or {}).get("readOnly", False))
+
+    def is_destructive(self, args: dict) -> bool:
+        return bool((self._mcp_tool.annotations or {}).get("destructive", False))
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return self.is_read_only(args)
+
+    # ------------------------------------------------------------------
+    # Tool ABC — execution
+    # ------------------------------------------------------------------
+
+    def execute(self, args: dict) -> ToolResult:
+        """Call the remote MCP tool synchronously."""
+        try:
+            mcp_result = self._run_async(self._client.call_tool(self._mcp_tool.name, args))
+            return ToolResult(output=mcp_result.content, is_error=mcp_result.is_error)
+        except Exception as exc:  # noqa: BLE001
+            return ToolResult(output=str(exc), is_error=True)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _run_async(coro):  # type: ignore[type-arg]
+        """Run an async coroutine from a sync context, even inside an event loop."""
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop is not None and loop.is_running():
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                future = pool.submit(asyncio.run, coro)
+                return future.result()
+        else:
+            return asyncio.run(coro)

llm_code/mcp/client.py

@@ -0,0 +1,117 @@
+"""MCP client implementing JSON-RPC 2.0 over an McpTransport."""
+from __future__ import annotations
+
+import itertools
+from typing import Any
+
+from .transport import McpTransport
+from .types import McpResource, McpServerInfo, McpToolDefinition, McpToolResult
+
+_PROTOCOL_VERSION = "2024-11-05"
+
+
+class McpClient:
+    """High-level MCP client built on top of an McpTransport."""
+
+    def __init__(self, transport: McpTransport) -> None:
+        self._transport = transport
+        self._id_counter = itertools.count(1)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def initialize(self) -> McpServerInfo:
+        """Send the MCP initialize request and return parsed server info."""
+        result = await self._request(
+            "initialize",
+            {
+                "protocolVersion": _PROTOCOL_VERSION,
+                "clientInfo": {"name": "llm-code", "version": "0.1.0"},
+                "capabilities": {},
+            },
+        )
+        server_info = result.get("serverInfo", {})
+        return McpServerInfo(
+            name=server_info.get("name", ""),
+            version=server_info.get("version", ""),
+            capabilities=result.get("capabilities", {}),
+        )
+
+    async def list_tools(self) -> list[McpToolDefinition]:
+        """Retrieve the list of tools exposed by the MCP server."""
+        result = await self._request("tools/list", {})
+        return [
+            McpToolDefinition(
+                name=tool["name"],
+                description=tool.get("description", ""),
+                input_schema=tool.get("inputSchema", {}),
+                annotations=tool.get("annotations"),
+            )
+            for tool in result.get("tools", [])
+        ]
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> McpToolResult:
+        """Call a named tool with the given arguments."""
+        result = await self._request(
+            "tools/call",
+            {"name": name, "arguments": arguments},
+        )
+        content_list = result.get("content", [])
+        text = ""
+        for item in content_list:
+            if item.get("type") == "text":
+                text = item.get("text", "")
+                break
+        is_error = bool(result.get("isError", False))
+        return McpToolResult(content=text, is_error=is_error)
+
+    async def list_resources(self) -> list[McpResource]:
+        """Retrieve the list of resources exposed by the MCP server."""
+        result = await self._request("resources/list", {})
+        return [
+            McpResource(
+                uri=resource["uri"],
+                name=resource.get("name", ""),
+                description=resource.get("description"),
+                mime_type=resource.get("mimeType"),
+            )
+            for resource in result.get("resources", [])
+        ]
+
+    async def read_resource(self, uri: str) -> str:
+        """Read the content of a resource by URI, returning text."""
+        result = await self._request("resources/read", {"uri": uri})
+        contents = result.get("contents", [])
+        for item in contents:
+            if item.get("type") == "text":
+                return item.get("text", "")
+        return ""
+
+    async def close(self) -> None:
+        """Close the underlying transport."""
+        await self._transport.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    async def _request(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Build and send a JSON-RPC 2.0 request, returning the result dict."""
+        request_id = next(self._id_counter)
+        message: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params,
+        }
+        await self._transport.send(message)
+        response = await self._transport.receive()
+
+        if "error" in response:
+            error = response["error"]
+            raise RuntimeError(
+                f"MCP error {error.get('code')}: {error.get('message', 'Unknown error')}"
+            )
+
+        return response.get("result", {})

llm_code/mcp/health.py

@@ -0,0 +1,120 @@
+"""MCP server health checking and background monitoring."""
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass
+
+from llm_code.logging import get_logger
+
+logger = get_logger(__name__)
+
+_HEALTH_CHECK_TIMEOUT = 5.0  # seconds
+
+
+@dataclass(frozen=True)
+class HealthStatus:
+    """Health status snapshot for a single MCP server."""
+
+    name: str
+    alive: bool
+    latency_ms: float
+    error: str | None
+    last_checked: float
+
+
+class MCPHealthChecker:
+    """Check and monitor the health of MCP server connections."""
+
+    def __init__(self) -> None:
+        self._monitor_task: asyncio.Task | None = None  # type: ignore[type-arg]
+        self._latest: dict[str, HealthStatus] = {}
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def check_server(self, name: str, client) -> HealthStatus:  # type: ignore[type-arg]
+        """Probe *client* with a listTools call (5 s timeout).
+
+        Returns a :class:`HealthStatus` reflecting whether the server is alive.
+        """
+        start = time.monotonic()
+        try:
+            await asyncio.wait_for(client.list_tools(), timeout=_HEALTH_CHECK_TIMEOUT)
+            latency_ms = (time.monotonic() - start) * 1000
+            status = HealthStatus(
+                name=name,
+                alive=True,
+                latency_ms=latency_ms,
+                error=None,
+                last_checked=time.time(),
+            )
+        except asyncio.TimeoutError:
+            latency_ms = (time.monotonic() - start) * 1000
+            status = HealthStatus(
+                name=name,
+                alive=False,
+                latency_ms=latency_ms,
+                error="timeout",
+                last_checked=time.time(),
+            )
+            logger.warning("MCP server '%s' health check timed out", name)
+        except Exception as exc:  # noqa: BLE001
+            latency_ms = (time.monotonic() - start) * 1000
+            status = HealthStatus(
+                name=name,
+                alive=False,
+                latency_ms=latency_ms,
+                error=str(exc),
+                last_checked=time.time(),
+            )
+            logger.warning("MCP server '%s' health check failed: %s", name, exc)
+
+        self._latest[name] = status
+        return status
+
+    async def check_all(self, servers: dict) -> list[HealthStatus]:  # type: ignore[type-arg]
+        """Check all servers concurrently.
+
+        *servers* maps server name → client.
+        """
+        if not servers:
+            return []
+        tasks = [self.check_server(name, client) for name, client in servers.items()]
+        return list(await asyncio.gather(*tasks))
+
+    def start_background_monitor(self, servers: dict, interval: float = 60.0) -> None:  # type: ignore[type-arg]
+        """Start an asyncio background task that polls *servers* every *interval* seconds."""
+        if self._monitor_task is not None and not self._monitor_task.done():
+            return
+
+        async def _monitor() -> None:
+            while True:
+                previous = {name: s.alive for name, s in self._latest.items()}
+                await self.check_all(servers)
+                for name, status in self._latest.items():
+                    was_alive = previous.get(name)
+                    if was_alive is None:
+                        continue
+                    if was_alive and not status.alive:
+                        logger.warning("MCP server '%s' became unhealthy: %s", name, status.error)
+                    elif not was_alive and status.alive:
+                        logger.info("MCP server '%s' recovered", name)
+                await asyncio.sleep(interval)
+
+        self._monitor_task = asyncio.ensure_future(_monitor())
+
+    def stop_monitor(self) -> None:
+        """Cancel the background monitoring task if running."""
+        if self._monitor_task is not None and not self._monitor_task.done():
+            self._monitor_task.cancel()
+        self._monitor_task = None
+
+    def get_status(self, name: str) -> HealthStatus | None:
+        """Return the most recent :class:`HealthStatus` for *name*, or ``None``."""
+        return self._latest.get(name)
+
+    def get_all_statuses(self) -> dict[str, HealthStatus]:
+        """Return all known health statuses."""
+        return dict(self._latest)