feat: add Deno LSP client implementation

Author: observerw

src/lsp_client/clients/deno/README.md

@@ -0,0 +1,39 @@
+# Deno LSP Custom Capabilities
+
+This document summarizes the custom LSP capabilities and protocol extensions provided by the Deno Language Server.
+
+## Custom Requests (Client → Server)
+
+| Request                       | Purpose                                                                                                                   |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `deno/cache`                  | Instructs Deno to cache a module and its dependencies. Usually sent as a response to a code action for un-cached modules. |
+| `deno/performance`            | Requests timing averages for Deno's internal instrumentation for monitoring and debugging.                                |
+| `deno/reloadImportRegistries` | Reloads cached responses from import registries.                                                                          |
+| `deno/virtualTextDocument`    | Requests read-only virtual text documents (e.g., cached remote modules or Deno library files) using the `deno:` schema.   |
+| `deno/task`                   | Retrieves a list of available Deno tasks defined in `deno.json` or `deno.jsonc`.                                          |
+
+## Custom Notifications (Server → Client)
+
+| Notification         | Purpose                                                                                                      |
+| -------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `deno/registryState` | Notifies the client about import registry discovery status, providing suggestions for configuration updates. |
+
+## Testing API (Experimental)
+
+Requires `experimental.testingApi` capability to be enabled by both client and server.
+
+### Requests (Client → Server)
+
+- `deno/testRun`: Initiates a test execution for specified modules or tests.
+- `deno/testRunCancel`: Cancels an ongoing test run by ID.
+
+### Notifications (Server → Client)
+
+- `deno/testModule`: Sent when a test module is discovered.
+- `deno/testModuleDelete`: Sent when a test module is deleted.
+- `deno/testRunProgress`: Tracks the progress and state of a test run (`enqueued`, `started`, `passed`, `failed`, etc.).
+
+## Other Experimental Capabilities
+
+- `denoConfigTasks`: Support for tasks defined in Deno configuration files.
+- `didRefreshDenoConfigurationTreeNotifications`: Notifications for when the configuration tree is refreshed.

src/lsp_client/clients/deno/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from .client import DenoClient, DenoDockerServer, DenoLocalServer
+
+__all__ = [
+    "DenoClient",
+    "DenoDockerServer",
+    "DenoLocalServer",
+]

src/lsp_client/clients/deno/client.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import shutil
+from functools import partial
+from subprocess import CalledProcessError
+from typing import Any, override
+
+import anyio
+from attrs import Factory, define
+from loguru import logger
+
+from lsp_client.capability.request import (
+    WithRequestCallHierarchy,
+    WithRequestDefinition,
+    WithRequestDocumentSymbol,
+    WithRequestHover,
+    WithRequestImplementation,
+    WithRequestReferences,
+    WithRequestTypeDefinition,
+    WithRequestWorkspaceSymbol,
+)
+from lsp_client.capability.server_notification import (
+    WithReceivePublishDiagnostics,
+)
+from lsp_client.capability.server_notification.log_message import WithReceiveLogMessage
+from lsp_client.client.abc import LSPClient
+from lsp_client.server.docker import DockerServer
+from lsp_client.server.local import LocalServer
+from lsp_client.utils.types import lsp_type
+
+DenoLocalServer = partial(LocalServer, command=["deno", "lsp"])
+DenoDockerServer = partial(DockerServer, image="lspcontainers/denols:2.4.2")
+
+
+@define
+class DenoClient(
+    LSPClient,
+    WithRequestHover,
+    WithRequestDefinition,
+    WithRequestReferences,
+    WithRequestImplementation,
+    WithRequestTypeDefinition,
+    WithRequestCallHierarchy,
+    WithRequestDocumentSymbol,
+    WithRequestWorkspaceSymbol,
+    WithReceiveLogMessage,
+    WithReceivePublishDiagnostics,
+):
+    """
+    - Language: TypeScript, JavaScript
+    - Homepage: https://deno.land/
+    - Doc: https://docs.deno.com/runtime/reference/lsp_integration/
+    - Github: https://github.com/denoland/deno
+    - VSCode Extension: https://marketplace.visualstudio.com/items?itemName=denoland.vscode-deno
+    """
+
+    enable: bool = True
+    unstable: bool = False
+    lint: bool = True
+
+    config: str | None = None
+    import_map: str | None = None
+
+    code_lens_implementations: bool = True
+    code_lens_references: bool = True
+    code_lens_references_all_functions: bool = True
+    code_lens_test: bool = True
+
+    suggest_complete_function_calls: bool = True
+    suggest_names: bool = True
+    suggest_paths: bool = True
+    suggest_auto_imports: bool = True
+    suggest_imports_auto_discover: bool = True
+    suggest_imports_hosts: list[str] = Factory(list)
+
+    testing_enable: bool = False
+    testing_args: list[str] = Factory(list)
+
+    @override
+    def get_language_id(self) -> lsp_type.LanguageKind:
+        return lsp_type.LanguageKind.TypeScript
+
+    @override
+    def create_initialization_options(self) -> dict[str, Any]:
+        options: dict[str, Any] = {
+            "enable": self.enable,
+            "unstable": self.unstable,
+            "lint": self.lint,
+            "codeLens": {
+                "implementations": self.code_lens_implementations,
+                "references": self.code_lens_references,
+                "referencesAllFunctions": self.code_lens_references_all_functions,
+                "test": self.code_lens_test,
+            },
+            "suggest": {
+                "completeFunctionCalls": self.suggest_complete_function_calls,
+                "names": self.suggest_names,
+                "paths": self.suggest_paths,
+                "autoImports": self.suggest_auto_imports,
+                "imports": {
+                    "autoDiscover": self.suggest_imports_auto_discover,
+                    "hosts": list(self.suggest_imports_hosts),
+                },
+            },
+        }
+
+        if self.config:
+            options["config"] = self.config
+
+        if self.import_map:
+            options["importMap"] = self.import_map
+
+        if self.testing_enable:
+            options["testing"] = {
+                "enable": self.testing_enable,
+                "args": list(self.testing_args),
+            }
+
+        return options
+
+    @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:
+            await anyio.run_process(["npm", "install", "-g", "deno"])
+            logger.info("Successfully installed deno via npm")
+            return
+        except CalledProcessError as e:
+            raise RuntimeError(
+                "Could not install deno. Please install it manually with 'npm install -g deno'. "
+                "See https://deno.land/ for more information."
+            ) from e

src/lsp_client/clients/deno/extension.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Protocol, override
+
+from lsp_client.protocol import (
+    CapabilityClientProtocol,
+    CapabilityProtocol,
+    ServerRequestHookProtocol,
+)
+
+
+class WithDenoCacheRequest(
+    ServerRequestHookProtocol,
+    CapabilityProtocol,
+    CapabilityClientProtocol,
+    Protocol,
+):
+    @override
+    @classmethod
+    def methods(cls) -> Sequence[str]:
+        return ("deno/cache",)