euporie 2.8.0__py3-none-any.whl → 2.8.5__py3-none-any.whl

euporie/core/layout/scroll.py

@@ -23,7 +23,8 @@ from euporie.core.layout.screen import BoundedWritePosition
 from euporie.core.utils import run_in_thread_with_context
 
 if TYPE_CHECKING:
-    from typing import Callable, Literal, Sequence
+    from collections.abc import Sequence
+    from typing import Callable, Literal
 
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
@@ -43,6 +44,8 @@ log = logging.getLogger(__name__)
 class ScrollingContainer(Container):
     """A scrollable container which renders only the currently visible children."""
 
+    render_info: WindowRenderInfo | None
+
     def __init__(
         self,
         children: Callable[[], Sequence[AnyContainer]] | Sequence[AnyContainer],
@@ -284,25 +287,19 @@ class ScrollingContainer(Container):
         def wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
             response: NotImplementedOrNone = NotImplemented
 
-            if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-                response = self.scroll(-1)
-            elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-                response = self.scroll(1)
-            elif callable(handler):
+            if callable(handler):
                 response = handler(mouse_event)
 
+            if response is NotImplemented:
+                if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+                    response = self.scroll(-1)
+                elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+                    response = self.scroll(1)
+
             # Refresh the child if there was a response
             if response is None:
                 return response
 
-            # This relies on windows returning NotImplemented when scrolled
-            # to the start or end
-            # if response is NotImplemented:
-            #     if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-            #         response = self.scroll(-1)
-            #     elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-            #         response = self.scroll(1)
-
             # Select the clicked child if clicked
             if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
                 if child:
@@ -480,10 +477,10 @@ class ScrollingContainer(Container):
                 )
                 for y in range(ypos + line, ypos + available_height):
                     for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][
-                            x
-                        ] = self._mouse_handler_wrapper(
-                            mouse_handlers.mouse_handlers[y][x]
+                        mouse_handlers.mouse_handlers[y][x] = (
+                            self._mouse_handler_wrapper(
+                                mouse_handlers.mouse_handlers[y][x]
+                            )
                         )
         # Blit children above the selected that are on screen
         line = self.selected_child_position
@@ -525,10 +522,10 @@ class ScrollingContainer(Container):
                 )
                 for y in range(ypos, ypos + line):
                     for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][
-                            x
-                        ] = self._mouse_handler_wrapper(
-                            mouse_handlers.mouse_handlers[y][x]
+                        mouse_handlers.mouse_handlers[y][x] = (
+                            self._mouse_handler_wrapper(
+                                mouse_handlers.mouse_handlers[y][x]
+                            )
                         )
 
         # Dont bother drawing floats
@@ -600,9 +597,10 @@ class ScrollingContainer(Container):
 
     def all_children(self) -> Sequence[Container]:
         """Return the list of all children of this container."""
-        if self.refresh_children:
-            _children = self._children
-            _children.clear()
+        _children = self._children
+        if self.refresh_children or not self._children:
+            self.refresh_children = False
+            new_children = []
             new_child_hashes = set()
             for child in self.children_func():
                 if not (
@@ -611,21 +609,21 @@ class ScrollingContainer(Container):
                     wrapped_child = self._child_cache[child_hash] = CachedContainer(
                         child, mouse_handler_wrapper=self._mouse_handler_wrapper
                     )
-                _children.append(wrapped_child)
+                new_children.append(wrapped_child)
                 new_child_hashes.add(child_hash)
+            _children[:] = new_children
 
             # Clean up metacache
             for child_hash in set(self._child_cache) - new_child_hashes:
                 del self._child_cache[child_hash]
 
-            self.refresh_children = False
             # Clean up positions
             self.index_positions = {
                 i: pos
                 for i, pos in self.index_positions.items()
                 if i < len(self._children)
             }
-        return self._children
+        return _children
 
     def get_children(self) -> list[Container]:
         """Return the list of currently visible children to include in the layout."""

euporie/core/log.py

@@ -20,12 +20,10 @@ from prompt_toolkit.renderer import (
 from prompt_toolkit.shortcuts.utils import print_formatted_text
 from prompt_toolkit.styles.pygments import style_from_pygments_cls
 from prompt_toolkit.styles.style import Style, merge_styles
-from pygments.styles import get_style_by_name
 
-from euporie.core.config import add_setting
 from euporie.core.ft.utils import indent, lex, wrap
 from euporie.core.io import PseudoTTY
-from euporie.core.style import LOG_STYLE
+from euporie.core.style import LOG_STYLE, get_style_by_name
 from euporie.core.utils import dict_merge
 
 if TYPE_CHECKING:
@@ -42,6 +40,65 @@ log = logging.getLogger(__name__)
 LOG_QUEUE: deque = deque(maxlen=1000)
 
 
+class BufferedLogs(logging.Handler):
+    """A handler that collects log records and replays them on exit."""
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        """Initialize the collector.
+
+        Args:
+            logger: Logger to collect from and replay to. If None, uses root logger.
+        """
+        super().__init__()
+        self.records: list[logging.LogRecord] = []
+        self._logger = logger or logging.getLogger()
+        self._original_handlers: list[logging.Handler] = []
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Store the log record."""
+        self.records.append(record)
+
+    def replay(self) -> None:
+        """Replay collected logs through the original logger."""
+        for record in self.records:
+            if record.exc_info:
+                # Create a new record to avoid issues with stale exc_info
+                record = logging.LogRecord(
+                    record.name,
+                    record.levelno,
+                    record.pathname,
+                    record.lineno,
+                    record.msg,
+                    record.args,
+                    record.exc_info,
+                    record.funcName,
+                )
+            self._logger.handle(record)
+
+    def __enter__(self) -> BufferedLogs:
+        """Store and replace the log handlers."""
+        # Save and remove existing handlers
+        self._original_handlers = self._logger.handlers[:]
+        self._logger.handlers.clear()
+        # Add ourselves as the only handler
+        self._logger.addHandler(self)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        """Restore the original handlers."""
+        # Remove ourselves
+        self._logger.removeHandler(self)
+        # Restore original handlers
+        self._logger.handlers = self._original_handlers
+        # Replay collected records through original handlers
+        self.replay()
+
+
 class FtFormatter(logging.Formatter):
     """Base class for formatted text logging formatter."""
 
@@ -240,12 +297,17 @@ class StdoutFormatter(FtFormatter):
         msg_pad = len(date) + 10
         msg_pad_1st_line = msg_pad + 1 + len(ref)
 
-        msg_lines = textwrap.wrap(
-            record.message,
-            width=width,
-            initial_indent=" " * msg_pad_1st_line,
-            subsequent_indent=" " * msg_pad,
-        )
+        msg_lines = "\n".join(
+            textwrap.wrap(
+                record.message,
+                width=width,
+                initial_indent=" " * msg_pad_1st_line,
+                replace_whitespace=False,
+            )
+        ).split("\n")
+        subsequent_indent = " " * msg_pad
+        for i in range(1, len(msg_lines)):
+            msg_lines[i] = f"{subsequent_indent}{msg_lines[i]}"
 
         output: StyleAndTextTuples = [
             ("class:pygments.literal.date", date),
@@ -416,7 +478,7 @@ def setup_logs(config: Config | None = None) -> None:
     }
 
     if config is not None:
-        log_file = config.get("log_file", "")
+        log_file = config.log_file or ""
         log_file_is_stdout = log_file in {"-", "/dev/stdout"}
         log_level = config.log_level.upper()
 
@@ -433,18 +495,14 @@ def setup_logs(config: Config | None = None) -> None:
         # Configure stdout handler
         if log_file_is_stdout:
             stdout_level = log_level
-        elif (app_cls := config.app_cls) is not None and (
-            log_stdout_level := app_cls.log_stdout_level
-        ):
-            stdout_level = log_stdout_level.upper()
         else:
-            stdout_level = "CRITICAL"
+            stdout_level = config.log_level_stdout.upper()
         log_config["handlers"]["stdout"]["level"] = stdout_level
-        if syntax_theme := config.get("syntax_theme"):
+        if syntax_theme := config.syntax_theme:
             log_config["handlers"]["stdout"]["pygments_theme"] = syntax_theme
 
         # Configure euporie logger
-        log_config["loggers"]["euporie"]["level"] = config.log_level.upper()
+        log_config["loggers"]["euporie"]["level"] = log_level
 
         # Update log_config based on additional config dict provided
         if config.log_config:
@@ -463,46 +521,3 @@ def setup_logs(config: Config | None = None) -> None:
 
     # Log uncaught exceptions
     sys.excepthook = handle_exception
-
-
-# ################################### Settings ########################################
-
-
-add_setting(
-    name="log_file",
-    flags=["--log-file"],
-    nargs="?",
-    default="",
-    type_=str,
-    title="the log file path",
-    help_="File path for logs",
-    description="""
-        When set to a file path, the log output will be written to the given path.
-        If no value is given output will be sent to the standard output.
-    """,
-)
-
-add_setting(
-    name="log_level",
-    flags=["--log-level"],
-    type_=str,
-    default="warning",
-    title="the log level",
-    help_="Set the log level",
-    choices=["debug", "info", "warning", "error", "critical"],
-    description="""
-        When set, logging events at the given level are emitted.
-    """,
-)
-
-add_setting(
-    name="log_config",
-    flags=["--log-config"],
-    type_=str,
-    default=None,
-    title="additional logging configuration",
-    help_="Additional logging configuration",
-    description="""
-        A JSON string specifying additional logging configuration.
-    """,
-)

euporie/core/lsp.py

@@ -13,8 +13,9 @@ from typing import TYPE_CHECKING, NamedTuple
 from prompt_toolkit.utils import Event
 
 if TYPE_CHECKING:
+    from collections.abc import Coroutine, Sequence
     from concurrent.futures import Future
-    from typing import Any, Callable, Coroutine, Sequence
+    from typing import Any, Callable
 
 
 log = logging.getLogger(__name__)
@@ -475,6 +476,7 @@ class LspClient:
             "cellTextDocuments": [],
         }
         langs = self.can_change_nb_langs
+        lsp_notebook_cell: dict[str, Any]
         for cell in cells:
             if langs and cell.language not in langs:
                 continue
@@ -598,6 +600,7 @@ class LspClient:
             },
         }
         langs = self.can_change_nb_langs
+        lsp_notebook_cell: dict[str, Any]
         for cell in cells:
             # If specified, only sync cells with the languages the server has requested
             if langs and cell.language not in langs:
@@ -657,6 +660,7 @@ class LspClient:
                 "change": {"cells": (change := {"data": [], "textContent": []})},
             }
             langs = self.can_change_nb_langs
+            lsp_notebook_cell: dict[str, Any]
             for cell in cells:
                 self._doc_versions[cell.path] += 1
                 # If specified, only sync cells with the languages the server has requested
@@ -1032,10 +1036,24 @@ class LspClient:
 
 KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     # Custom additions
-    "ruff": {"command": ["ruff-lsp"], "languages": {"python"}},
     "typos": {"command": ["typos-lsp"], "languages": set()},
     # Helix's known LSPs
     "als": {"command": ["als"]},
+    "ada-language-server": {"command": ["ada_language_server"], "languages": {"ada"}},
+    "ada-gpr-language-server": {
+        "command": ["ada_language_server", "--language-gpr"],
+        "languages": {"ada"},
+    },
+    "angular": {
+        "command": [
+            "ngserver",
+            "--stdio",
+            "--tsProbeLocations",
+            ".",
+            "--ngProbeLocations",
+            ".",
+        ]
+    },
     "awk-language-server": {"command": ["awk-language-server"], "languages": {"awk"}},
     "bash-language-server": {
         "command": ["bash-language-server", "start"],
@@ -1043,11 +1061,16 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     },
     "bass": {"command": ["bass", "--lsp"], "languages": {"bass"}},
     "bicep-langserver": {"command": ["bicep-langserver"], "languages": {"bicep"}},
+    "bitbake-language-server": {
+        "command": ["bitbake-language-server"],
+        "languages": {"bitbake"},
+    },
     "bufls": {"command": ["bufls", "serve"], "languages": {"protobuf"}},
     "cairo-language-server": {
         "command": ["cairo-language-server"],
         "languages": {"cairo"},
     },
+    "circom-lsp": {"command": ["circom-lsp"], "languages": {"circom"}},
     "cl-lsp": {"command": ["cl-lsp", "stdio"], "languages": {"common-lisp"}},
     "clangd": {"command": ["clangd"], "languages": {"opencl", "cpp", "c"}},
     "clojure-lsp": {"command": ["clojure-lsp"], "languages": {"clojure"}},
@@ -1071,16 +1094,22 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["docker-langserver", "--stdio"],
         "languages": {"dockerfile"},
     },
+    "docker-compose-langserver": {
+        "command": ["docker-compose-langserver", "--stdio"],
+        "languages": {"docker-compose"},
+    },
     "dot-language-server": {
         "command": ["dot-language-server", "--stdio"],
         "languages": {"dot"},
     },
+    "earthlyls": {"command": ["earthlyls"], "languages": {"earthfile"}},
     "elixir-ls": {
-        "settings": {"elixirLS": {"dialyzerEnabled": False}},
+        "config": {"elixirLS": {"dialyzerEnabled": False}},
         "command": ["elixir-ls"],
-        "languages": {"elixir", "heex"},
+        "languages": {"heex", "elixir"},
     },
     "elm-language-server": {"command": ["elm-language-server"], "languages": {"elm"}},
+    "elp": {"command": ["elp", "server"], "languages": {"erlang"}},
     "elvish": {"command": ["elvish", "-lsp"], "languages": {"elvish"}},
     "erlang-ls": {"command": ["erlang_ls"], "languages": {"erlang"}},
     "forc": {"command": ["forc", "lsp"], "languages": {"sway"}},
@@ -1090,11 +1119,12 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"fortran"},
     },
     "fsharp-ls": {
-        "settings": {"AutomaticWorkspaceInit": True},
+        "config": {"AutomaticWorkspaceInit": True},
         "command": ["fsautocomplete"],
         "languages": {"fsharp"},
     },
     "gleam": {"command": ["gleam", "lsp"], "languages": {"gleam"}},
+    "glsl_analyzer": {"command": ["glsl_analyzer"], "languages": {"glsl"}},
     "graphql-language-service": {
         "command": ["graphql-lsp", "server", "-m", "stream"],
         "languages": {"graphql"},
@@ -1103,9 +1133,12 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["haskell-language-server-wrapper", "--lsp"],
         "languages": {"cabal", "haskell"},
     },
+    "hyprls": {"command": ["hyprls"], "languages": {"hyprlang"}},
     "idris2-lsp": {"command": ["idris2-lsp"], "languages": {"idris"}},
     "intelephense": {"command": ["intelephense", "--stdio"], "languages": {"php"}},
     "jdtls": {"command": ["jdtls"], "languages": {"java"}},
+    "jedi": {"command": ["jedi-language-server"], "languages": {"python"}},
+    "jq-lsp": {"command": ["jq-lsp"], "languages": {"jq"}},
     "jsonnet-language-server": {
         "command": ["jsonnet-language-server", "-t", "--lint"],
         "languages": {"jsonnet"},
@@ -1122,22 +1155,39 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         ],
         "languages": {"julia"},
     },
+    "koka": {
+        "command": ["koka", "--language-server", "--lsstdio"],
+        "languages": {"koka"},
+    },
     "kotlin-language-server": {
         "command": ["kotlin-language-server"],
         "languages": {"kotlin"},
     },
-    "lean": {"command": ["lean", "--server"], "languages": {"lean"}},
+    "lean": {"command": ["lean", "--server", "--memory=1024"], "languages": {"lean"}},
     "ltex-ls": {"command": ["ltex-ls"]},
     "markdoc-ls": {"command": ["markdoc-ls", "--stdio"], "languages": {"markdoc"}},
+    "markdown-oxide": {"command": ["markdown-oxide"], "languages": {"markdown"}},
     "marksman": {"command": ["marksman", "server"], "languages": {"markdown"}},
     "metals": {
-        "settings": {"isHttpEnabled": True},
+        "config": {
+            "isHttpEnabled": True,
+            "metals": {
+                "inlayHints": {
+                    "typeParameters": {"enable": True},
+                    "hintsInPatternMatch": {"enable": True},
+                }
+            },
+        },
         "command": ["metals"],
         "languages": {"scala"},
     },
+    "mesonlsp": {"command": ["mesonlsp", "--lsp"], "languages": {"meson"}},
     "mint": {"command": ["mint", "ls"], "languages": {"mint"}},
+    "mojo-lsp": {"command": ["mojo-lsp-server"], "languages": {"mojo"}},
     "nil": {"command": ["nil"], "languages": {"nix"}},
     "nimlangserver": {"command": ["nimlangserver"], "languages": {"nim"}},
+    "nimlsp": {"command": ["nimlsp"]},
+    "nixd": {"command": ["nixd"], "languages": {"nix"}},
     "nls": {"command": ["nls"], "languages": {"nickel"}},
     "nu-lsp": {"command": ["nu", "--lsp"], "languages": {"nu"}},
     "ocamllsp": {"command": ["ocamllsp"], "languages": {"ocaml", "ocaml-interface"}},
@@ -1150,6 +1200,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
     "pasls": {"command": ["pasls"], "languages": {"pascal"}},
     "pbkit": {"command": ["pb", "lsp"], "languages": {"protobuf"}},
     "perlnavigator": {"command": ["perlnavigator", "--stdio"], "languages": {"perl"}},
+    "pest-language-server": {
+        "command": ["pest-language-server"],
+        "languages": {"pest"},
+    },
     "prisma-language-server": {
         "command": ["prisma-language-server", "--stdio"],
         "languages": {"prisma"},
@@ -1158,13 +1212,18 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["purescript-language-server", "--stdio"],
         "languages": {"purescript"},
     },
-    "pylsp": {"command": ["pylsp"], "languages": {"python"}},
-    "pyright": {"settings": {}, "command": ["pyright-langserver", "--stdio"]},
+    "pylsp": {"command": ["pylsp"], "languages": {"snakemake", "python"}},
+    "pyright": {"config": {}, "command": ["pyright-langserver", "--stdio"]},
+    "basedpyright": {"config": {}, "command": ["basedpyright-langserver", "--stdio"]},
     "pylyzer": {"command": ["pylyzer", "--server"]},
     "qmlls": {"command": ["qmlls"], "languages": {"qml"}},
+    "quint-language-server": {
+        "command": ["quint-language-server", "--stdio"],
+        "languages": {"quint"},
+    },
     "r": {
         "command": ["R", "--no-echo", "-e", "languageserver::run()"],
-        "languages": {"r", "rmarkdown"},
+        "languages": {"rmarkdown", "r"},
     },
     "racket": {
         "command": ["racket", "-l", "racket-langserver"],
@@ -1176,11 +1235,16 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"rescript"},
     },
     "robotframework_ls": {"command": ["robotframework_ls"], "languages": {"robot"}},
+    "ruff": {"command": ["ruff", "server"], "languages": {"python"}},
     "serve-d": {"command": ["serve-d"], "languages": {"d"}},
     "slint-lsp": {"command": ["slint-lsp"], "languages": {"slint"}},
     "solargraph": {"command": ["solargraph", "stdio"], "languages": {"ruby"}},
     "solc": {"command": ["solc", "--lsp"], "languages": {"solidity"}},
     "sourcekit-lsp": {"command": ["sourcekit-lsp"], "languages": {"swift"}},
+    "spade-language-server": {
+        "command": ["spade-language-server"],
+        "languages": {"spade"},
+    },
     "svlangserver": {"command": ["svlangserver"], "languages": {"verilog"}},
     "swipl": {
         "command": [
@@ -1196,6 +1260,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         ],
         "languages": {"prolog"},
     },
+    "superhtml": {"command": ["superhtml", "lsp"], "languages": {"html"}},
     "tailwindcss-ls": {"command": ["tailwindcss-language-server", "--stdio"]},
     "taplo": {"command": ["taplo", "lsp", "stdio"], "languages": {"toml"}},
     "templ": {"command": ["templ", "lsp"], "languages": {"templ"}},
@@ -1204,36 +1269,38 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"tfvars", "hcl"},
     },
     "texlab": {"command": ["texlab"], "languages": {"latex", "bibtex"}},
+    "typespec": {"command": ["tsp-server", "--stdio"], "languages": {"typespec"}},
     "vala-language-server": {
         "command": ["vala-language-server"],
         "languages": {"vala"},
     },
+    "vale-ls": {"command": ["vale-ls"]},
     "vhdl_ls": {"command": ["vhdl_ls"], "languages": {"vhdl"}},
     "vlang-language-server": {"command": ["v-analyzer"], "languages": {"v"}},
     "vscode-css-language-server": {
-        "settings": {"provideFormatter": True, "css": {"validate": {"enable": True}}},
+        "config": {"provideFormatter": True, "css": {"validate": {"enable": True}}},
         "command": ["vscode-css-language-server", "--stdio"],
         "languages": {"scss", "css"},
     },
     "vscode-html-language-server": {
-        "settings": {"provideFormatter": True},
+        "config": {"provideFormatter": True},
         "command": ["vscode-html-language-server", "--stdio"],
         "languages": {"html"},
     },
     "vscode-json-language-server": {
-        "settings": {"provideFormatter": True, "json": {"validate": {"enable": True}}},
+        "config": {"provideFormatter": True, "json": {"validate": {"enable": True}}},
         "command": ["vscode-json-language-server", "--stdio"],
-        "languages": {"json"},
+        "languages": {"jsonc", "json"},
     },
     "vuels": {
-        "settings": {"typescript": {"tsdk": "node_modules/typescript/lib/"}},
+        "config": {"typescript": {"tsdk": "node_modules/typescript/lib/"}},
         "command": ["vue-language-server", "--stdio"],
         "languages": {"vue"},
     },
     "wgsl_analyzer": {"command": ["wgsl_analyzer"], "languages": {"wgsl"}},
     "yaml-language-server": {
         "command": ["yaml-language-server", "--stdio"],
-        "languages": {"yaml"},
+        "languages": {"yaml", "docker-compose"},
     },
     "zls": {"command": ["zls"], "languages": {"zig"}},
     "blueprint-compiler": {
@@ -1241,12 +1308,22 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"blueprint"},
     },
     "typst-lsp": {"command": ["typst-lsp"], "languages": {"typst"}},
+    "tinymist": {"command": ["tinymist"], "languages": {"typst"}},
+    "pkgbuild-language-server": {
+        "command": ["pkgbuild-language-server"],
+        "languages": {"pkgbuild"},
+    },
+    "helm_ls": {"command": ["helm_ls", "serve"], "languages": {"helm"}},
+    "ember-language-server": {
+        "command": ["ember-language-server", "--stdio"],
+        "languages": {"gts", "gjs", "glimmer"},
+    },
     "ansible-language-server": {
         "command": ["ansible-language-server", "--stdio"],
         "languages": {"yaml"},
     },
     "lua-language-server": {
-        "settings": {
+        "config": {
             "Lua": {
                 "hint": {
                     "enable": True,
@@ -1262,7 +1339,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"lua"},
     },
     "gopls": {
-        "settings": {
+        "config": {
             "hints": {
                 "assignVariableTypes": True,
                 "compositeLiteralFields": True,
@@ -1273,10 +1350,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
             }
         },
         "command": ["gopls"],
-        "languages": {"gotmpl", "gowork", "go", "gomod"},
+        "languages": {"go", "gowork", "gotmpl", "gomod"},
     },
     "golangci-lint-lsp": {
-        "settings": {
+        "config": {
             "command": [
                 "golangci-lint",
                 "run",
@@ -1289,7 +1366,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"go"},
     },
     "rust-analyzer": {
-        "settings": {
+        "config": {
             "inlayHints": {
                 "bindingModeHints": {"enable": False},
                 "closingBraceHints": {"minLines": 10},
@@ -1303,7 +1380,7 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "languages": {"rust"},
     },
     "typescript-language-server": {
-        "settings": {
+        "config": {
             "hostInfo": "helix",
             "typescript": {
                 "inlayHints": {
@@ -1329,10 +1406,10 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
             },
         },
         "command": ["typescript-language-server", "--stdio"],
-        "languages": {"tsx", "typescript", "jsx", "javascript"},
+        "languages": {"jsx", "typescript", "javascript", "tsx"},
     },
     "svelteserver": {
-        "settings": {
+        "config": {
             "configuration": {
                 "typescript": {
                     "inlayHints": {
@@ -1359,4 +1436,21 @@ KNOWN_LSP_SERVERS: dict[str, dict[str, Any]] = {
         "command": ["svelteserver", "--stdio"],
         "languages": {"svelte"},
     },
+    "vscode-eslint-language-server": {
+        "config": {
+            "validate": "on",
+            "experimental": {"useFlatConfig": False},
+            "rulesCustomizations": [],
+            "run": "onType",
+            "problems": {"shortenToSingleLine": False},
+            "nodePath": "",
+            "codeAction": {
+                "disableRuleComment": {"enable": True, "location": "separateLine"},
+                "showDocumentation": {"enable": True},
+            },
+            "workingDirectory": {"mode": "location"},
+        },
+        "command": ["vscode-eslint-language-server", "--stdio"],
+        "languages": {"gts", "gjs"},
+    },
 }