Merge branch 'main' into feat/cli

Author: observerw

container/ty/ContainerFile

@@ -1,5 +1,5 @@
 # ty has built-in LSP
-ARG VERSION=latest
+ARG VERSION=0.0.5
 FROM ghcr.io/astral-sh/uv:python3.11-trixie-slim AS builder
 ARG VERSION
 RUN uv tool install ty@${VERSION}

examples/protocol.py

@@ -8,7 +8,7 @@
 
 from typing import Protocol, runtime_checkable
 
-from lsp_client import LSPClient
+from lsp_client import Client
 from lsp_client.capability.request import (
     WithRequestCallHierarchy,
     WithRequestDefinition,
@@ -32,7 +32,7 @@ class ExpectClientProtocol(
 
 
 class BadClient(
-    LSPClient,
+    Client,
     WithRequestDocumentSymbol,
 ):
     """Client that fails to meet protocol requirements.
@@ -44,7 +44,7 @@ class BadClient(
 
 
 class GoodClient(
-    LSPClient,
+    Client,
     WithRequestReferences,
     WithRequestDefinition,
     WithRequestCallHierarchy,

pyproject.toml

@@ -36,7 +36,6 @@ dev = [
     "pytest-asyncio>=1.0.0",
     "pytest-cov>=6.0.0",
     "ruff>=0.8.0",
-    "mypy>=1.13.0",
     "httpx>=0.28.1",
     "aiofiles>=24.1.0",
     "pdoc>=16.0.0",

src/lsp_client/__init__.py

@@ -35,10 +35,8 @@ async def main():
 
 from loguru import logger
 
-from .client.abc import LSPClient
-from .clients import PythonClient, RustClient, TypeScriptClient
-from .clients.pyrefly import PyreflyClient
-from .server.abc import LSPServer
+from .client.abc import Client
+from .server.abc import Server
 from .server.container import ContainerServer
 from .server.local import LocalServer
 from .utils.types import *  # noqa: F403
@@ -61,14 +59,10 @@ def disable_logging() -> None:
 }
 
 __all__ = [
+    "Client",
     "ContainerServer",
-    "LSPClient",
-    "LSPServer",
     "LocalServer",
-    "PyreflyClient",
-    "PythonClient",
-    "RustClient",
-    "TypeScriptClient",
+    "Server",
     "disable_logging",
     "enable_logging",
 ]

src/lsp_client/client/abc.py

@@ -2,7 +2,7 @@
 
 import os
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterable
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any, Self, override
@@ -30,75 +30,83 @@
     CapabilityClientProtocol,
     CapabilityProtocol,
 )
-from lsp_client.server import LocalServer
-from lsp_client.server.abc import LSPServer
+from lsp_client.server import DefaultServers, Server, ServerRuntimeError
 from lsp_client.server.types import ServerRequest
 from lsp_client.utils.channel import Receiver, channel
 from lsp_client.utils.types import AnyPath, Notification, Request, Response, lsp_type
 from lsp_client.utils.workspace import (
     DEFAULT_WORKSPACE_DIR,
     RawWorkspace,
     Workspace,
-    WorkspaceFolder,
+    format_workspace,
 )
 
 
 @define
-class LSPClient(
+class Client(
     # text sync support is mandatory
     WithNotifyTextDocumentSynchronize,
     CapabilityClientProtocol,
     AsyncContextManagerMixin,
     ABC,
 ):
-    _server: LSPServer | None = field(alias="server", default=None)
-    _workspace: RawWorkspace = field(alias="workspace", factory=Path.cwd)
+    _server_arg: Server | None = field(alias="server", default=None)
+    _workspace_arg: RawWorkspace = field(alias="workspace", factory=Path.cwd)
 
     sync_file: bool = True
     request_timeout: float = 5.0
 
+    _server: Server = field(init=False)
+    _workspace: Workspace = field(init=False)
     _buffer: LSPFileBuffer = field(factory=LSPFileBuffer, init=False)
 
-    def get_server(self) -> LSPServer:
-        return self._server or self.create_default_server()
+    def _iter_candidate_servers(self) -> Iterable[Server]:
+        """
+        Server candidates in order of priority:
+        1. User-provided server
+        2. Containerized server
+        3. Local server (maybe with auto-installation)
+        """
+
+        if self._server_arg:
+            yield self._server_arg
+        defaults = self.create_default_servers()
+        yield defaults.container
+        yield defaults.local
+
+    @asynccontextmanager
+    async def _run_server(
+        self,
+    ) -> AsyncGenerator[tuple[Server, Receiver[ServerRequest]]]:
+        async with channel[ServerRequest].create() as (sender, receiver):
+            errors: list[ServerRuntimeError] = []
+            for server in self._iter_candidate_servers():
+                try:
+                    async with server.run(self.get_workspace(), sender=sender) as s:  # ty: ignore[invalid-argument-type]
+                        yield s, receiver
+                        return
+                except ServerRuntimeError as e:
+                    logger.debug("Failed to start server {}: {}", server, e)
+                    errors.append(e)
+
+            raise ExceptionGroup(
+                f"All servers failed to start for {type(self).__name__}", errors
+            )
 
     @override
     def get_workspace(self) -> Workspace:
-        match self._workspace:
-            case str() | os.PathLike() as root_folder_path:
-                return Workspace(
-                    {
-                        DEFAULT_WORKSPACE_DIR: WorkspaceFolder(
-                            uri=Path(root_folder_path).as_uri(),
-                            name="root",
-                        )
-                    }
-                )
-            case Workspace() as ws:
-                return ws
-            case _ as mapping:
-                return Workspace(
-                    {
-                        name: WorkspaceFolder(uri=Path(path).as_uri(), name=name)
-                        for name, path in mapping.items()
-                    }
-                )
+        return self._workspace
+
+    def get_server(self) -> Server:
+        return self._server
 
     @abstractmethod
     def get_language_id(self) -> lsp_type.LanguageKind:
         """The language ID of the client."""
 
     @abstractmethod
-    def create_default_server(self) -> LSPServer:
-        """Create the default server for this client."""
-
-    @abstractmethod
-    async def ensure_installed(self) -> None:
-        """
-        Check and install the server if necessary.
-
-        Note: For local runtime only.
-        """
+    def create_default_servers(self) -> DefaultServers:
+        """Create default servers for this client."""
 
     @abstractmethod
     def create_initialization_options(self) -> dict[str, Any]:
@@ -230,21 +238,19 @@ async def _exit(self) -> None:
     @asynccontextmanager
     @logger.catch(reraise=True)
     async def __asynccontextmanager__(self) -> AsyncGenerator[Self]:
-        if isinstance(self._server, LocalServer):
-            await self.ensure_installed()
-
-        self._hook = build_server_request_hooks(self)
-        client_capabilities = build_client_capabilities(self.__class__)
+        self._workspace = format_workspace(self._workspace_arg)
 
         async with (
             asyncer.create_task_group() as tg,
-            channel[ServerRequest].create() as (sender, receiver),
-            self.get_server().serve(workspace=self.get_workspace(), sender=sender),
+            self._run_server() as (server, receiver),  # ty: ignore[invalid-argument-type]
         ):
+            self._server = server
+
             # start to receive server requests here,
             # since server notification can be sent before `initialize`
-            tg.soonify(self._dispatch_server_requests)(receiver)
+            tg.soonify(self._dispatch_server_requests)(receiver)  # ty: ignore[invalid-argument-type]
 
+            client_capabilities = build_client_capabilities(self.__class__)
             root_workspace = self.get_workspace().get(DEFAULT_WORKSPACE_DIR)
             root_path = root_workspace.path.as_posix() if root_workspace else None
             root_uri = root_workspace.uri if root_workspace else None

src/lsp_client/clients/deno/client.py

@@ -23,8 +23,8 @@
     WithReceivePublishDiagnostics,
 )
 from lsp_client.capability.server_notification.log_message import WithReceiveLogMessage
-from lsp_client.client.abc import LSPClient
-from lsp_client.server.abc import LSPServer
+from lsp_client.client.abc import Client
+from lsp_client.server import DefaultServers
 from lsp_client.server.container import ContainerServer
 from lsp_client.server.local import LocalServer
 from lsp_client.utils.types import lsp_type
@@ -48,9 +48,38 @@
 )
 
 
+async def ensure_deno_installed() -> None:
+    if shutil.which("deno"):
+        return
+
+    logger.warning("deno not found, attempting to install...")
+
+    try:
+        # Use shell to execute the piped command
+        await anyio.run_process(
+            ["sh", "-c", "curl -fsSL https://deno.land/install.sh | sh"]
+        )
+        logger.info("Successfully installed deno via shell script")
+        return
+    except CalledProcessError as e:
+        raise RuntimeError(
+            "Could not install deno. Please install it manually with:\n"
+            "curl -fsSL https://deno.land/install.sh | sh\n\n"
+            "See https://deno.land/ for more information."
+        ) from e
+
+
+DenoLocalServer = partial(
+    LocalServer,
+    program="deno",
+    args=["lsp"],
+    ensure_installed=ensure_deno_installed,
+)
+
+
 @define
 class DenoClient(
-    LSPClient,
+    Client,
     WithRequestHover,
     WithRequestDefinition,
     WithRequestReferences,
@@ -108,8 +137,11 @@ def get_language_id(self) -> lsp_type.LanguageKind:
         return lsp_type.LanguageKind.TypeScript
 
     @override
-    def create_default_server(self) -> LSPServer:
-        return LocalServer(command=["deno", "lsp"])
+    def create_default_servers(self) -> DefaultServers:
+        return DefaultServers(
+            local=DenoLocalServer(),
+            container=DenoContainerServer(),
+        )
 
     @override
     def create_initialization_options(self) -> dict[str, Any]:
@@ -152,24 +184,3 @@ def create_initialization_options(self) -> dict[str, Any]:
     @override
     def check_server_compatibility(self, info: lsp_type.ServerInfo | None) -> None:
         return
-
-    @override
-    async def ensure_installed(self) -> None:
-        if shutil.which("deno"):
-            return
-
-        logger.warning("deno not found, attempting to install...")
-
-        try:
-            # Use shell to execute the piped command
-            await anyio.run_process(
-                ["sh", "-c", "curl -fsSL https://deno.land/install.sh | sh"]
-            )
-            logger.info("Successfully installed deno via shell script")
-            return
-        except CalledProcessError as e:
-            raise RuntimeError(
-                "Could not install deno. Please install it manually with:\n"
-                "curl -fsSL https://deno.land/install.sh | sh\n\n"
-                "See https://deno.land/ for more information."
-            ) from e