backup

Author: observerw

src/lsp_client/clients/base.py

@@ -4,7 +4,7 @@
 from typing import override
 
 from lsp_client.client.abc import Client
-from lsp_client.client.lang import LanguageConfig
+from lsp_client.protocol.lang import LanguageConfig
 from lsp_client.utils.types import lsp_type
 
 

src/lsp_client/protocol/__init__.py

@@ -1,3 +1,9 @@
+"""LSP protocol abstractions and type definitions.
+
+This module defines the protocol interfaces for LSP client capabilities,
+server request/notification hooks, and client operations.
+"""
+
 from __future__ import annotations
 
 from .capability import (

src/lsp_client/protocol/capability.py

@@ -1,3 +1,10 @@
+"""LSP capability protocols defining client-side capability registration.
+
+Provides protocol interfaces for different LSP capability categories:
+workspace, text document, notebook, window, general, and experimental capabilities.
+Each protocol defines methods for registering client capabilities with the server.
+"""
+
 from __future__ import annotations
 
 from abc import abstractmethod

src/lsp_client/protocol/client.py

@@ -1,10 +1,16 @@
+"""LSP client protocol defining the minimal interface for LSP operations.
+
+Provides the CapabilityClientProtocol that defines required methods for
+workspace management, configuration access, file operations, and LSP message handling.
+"""
+
 from __future__ import annotations
 
 from abc import abstractmethod
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 import anyio
 
@@ -13,8 +19,7 @@
 from lsp_client.utils.uri import from_local_uri
 from lsp_client.utils.workspace import DEFAULT_WORKSPACE_DIR, Workspace
 
-if TYPE_CHECKING:
-    from lsp_client.client.lang import LanguageConfig
+from .lang import LanguageConfig
 
 
 @runtime_checkable

src/lsp_client/protocol/hook.py

@@ -1,3 +1,9 @@
+"""Server request and notification hook system for LSP client.
+
+Defines hooks for handling server-initiated requests and notifications,
+with a registry for managing and dispatching these hooks.
+"""
+
 from __future__ import annotations
 
 from typing import Protocol, runtime_checkable

src/lsp_client/client/lang.py src/lsp_client/protocol/lang.pysrc/lsp_client/client/lang.py renamed to src/lsp_client/protocol/lang.py

@@ -1,3 +1,9 @@
+"""Language-specific configuration for LSP clients.
+
+Provides LanguageConfig for defining language properties including file suffixes,
+project markers, and project root detection logic.
+"""
+
 from __future__ import annotations
 
 from pathlib import Path

src/lsp_client/server/__init__.py

@@ -6,6 +6,7 @@
 from .error import ServerError, ServerInstallationError, ServerRuntimeError
 from .local import LocalServer
 from .socket import SocketServer
+from .types import ServerType
 
 __all__ = [
     "ContainerServer",
@@ -15,5 +16,6 @@
     "ServerError",
     "ServerInstallationError",
     "ServerRuntimeError",
+    "ServerType",
     "SocketServer",
 ]

src/lsp_client/server/abc.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator, Sequence
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from typing import Self
 
 import asyncer
-from attrs import Factory, define, field
+from attrs import define, field
 from loguru import logger
 
 from lsp_client.jsonrpc.channel import ResponseTable, response_channel
@@ -23,7 +23,7 @@
 
 @define(kw_only=True)
 class Server(ABC):
-    args: Sequence[str] = Factory(list)
+    """Base server implementation with JSON-RPC protocol handling."""
 
     _resp_table: ResponseTable = field(factory=ResponseTable, init=False)
 
@@ -43,11 +43,6 @@ async def receive(self) -> RawPackage | None:
     async def kill(self) -> None:
         """Kill the runtime process."""
 
-    @abstractmethod
-    @asynccontextmanager
-    def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:
-        """Run the server process."""
-
     async def _dispatch(self, sender: Sender[ServerRequest] | None) -> None:
         if not sender:
             logger.warning(
@@ -85,16 +80,12 @@ async def request(self, request: RawRequest) -> RawResponsePackage:
     async def notify(self, notification: RawNotification) -> None:
         await self.send(notification)
 
+    @abstractmethod
     @asynccontextmanager
-    async def run(
+    def run(
         self,
         workspace: Workspace,
         *,
         sender: Sender[ServerRequest] | None = None,
     ) -> AsyncGenerator[Self]:
-        async with (
-            self.run_process(workspace),
-            asyncer.create_task_group() as tg,
-        ):
-            tg.soonify(self._dispatch)(sender)
-            yield self
+        """Run the server."""

src/lsp_client/server/container.py

@@ -4,13 +4,15 @@
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Literal, final, override
+from typing import Literal, Self, final, override
 
 import anyio
 from attrs import Factory, define, field
 from loguru import logger
 
 from lsp_client.jsonrpc.parse import RawPackage
+from lsp_client.server.types import ServerRequest
+from lsp_client.utils.channel import Sender
 from lsp_client.utils.workspace import Workspace
 
 from .abc import Server
@@ -207,12 +209,17 @@ async def check_availability(self) -> None:
                 "could not be pulled."
             ) from e
 
-    @override
     @asynccontextmanager
-    async def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:
+    async def run(
+        self,
+        workspace: Workspace,
+        *,
+        sender: Sender[ServerRequest] | None = None,
+    ) -> AsyncGenerator[Self]:
         args = self.format_args(workspace)
         logger.debug("Running docker runtime with command: {}", args)
 
         self._local = LocalServer(program=self.backend, args=args)
-        async with self._local.run_process(workspace):
-            yield
+
+        async with self._local.run(workspace, sender=sender):
+            yield self

src/lsp_client/server/default.py

@@ -1,12 +1,46 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator
+from contextlib import suppress
+
 from attrs import frozen
 
+from .abc import Server
 from .container import ContainerServer
+from .error import ServerRuntimeError
 from .local import LocalServer
+from .types import ServerType
 
 
 @frozen
 class DefaultServers:
     local: LocalServer
     container: ContainerServer
+
+    async def iter_candidate(
+        self,
+        *,
+        server: Server | ServerType = "local",
+    ) -> AsyncIterator[Server]:
+        """
+        Server candidates in order of priority:
+        1. User-provided server
+        2. Local server (if available)
+        3. Containerized server
+        4. Local server with auto-install (if enabled)
+        """
+
+        match server:
+            case "container":
+                yield self.container
+            case "local":
+                yield self.local
+            case Server() as server:
+                yield server
+
+        with suppress(ServerRuntimeError):
+            await self.local.check_availability()
+            yield self.local
+
+        yield self.container
+        yield self.local