Merge pull request #1514 from snoweuph/feat/lsp

LSP Refactoring

configuration.nix

@@ -34,7 +34,7 @@ isMaximal: {
       lspSignature.enable = !isMaximal; # conflicts with blink in maximal
       otter-nvim.enable = isMaximal;
       nvim-docs-view.enable = isMaximal;
-      harper-ls.enable = isMaximal;
+      presets.harper.enable = isMaximal;
     };
 
     debugger = {
@@ -103,7 +103,6 @@ isMaximal: {
       make.enable = false;
       qml.enable = false;
       jinja.enable = false;
-      tailwind.enable = false;
       svelte.enable = false;
       liquid.enable = false;
       tera.enable = false;

docs/manual/configuring/languages.md

@@ -75,8 +75,6 @@ languages have sections under the `vim.languages` attribute.
   [vim.languages.scala.enable](./options.html#option-vim-languages-scala-enable)
 - Svelte:
   [vim.languages.svelte.enable](./options.html#option-vim-languages-svelte-enable)
-- Tailwind:
-  [vim.languages.tailwind.enable](./options.html#option-vim-languages-tailwind-enable)
 - Terraform:
   [vim.languages.terraform.enable](./options.html#option-vim-languages-terraform-enable)
 - Typst:

docs/manual/release-notes/rl-0.9.md

@@ -63,6 +63,45 @@
 
 - Added `json5` into `languages.json`. Some options where renamed.
 
+- Moved `vim.lsp.harper-ls` to `vim.lsp.presets.haper`.
+
+- Removed `typst_lsp` from `languages.typst.lsp.servers`, because it is
+  deprecated and thus was pulled from nixpkgs.
+  <https://github.com/NixOS/nixpkgs/commit/bf24296bbe2e31ac7147b02ea645922390ca8f4b>
+
+- Renamed `ts_ls` to `typescript-language-server`.
+
+- Renamed `denols` to `deno`.
+
+- Renamed `tsgo` to `typescript-go`.
+
+- Renamed `vala_ls` to `vala-language-server`.
+
+- Renamed `terraformls-tf` and `terraformls-hcl` to `terraform-ls`.
+
+- Renamed `tofuls-tf` and `tofuls-hcl` to `tofu-ls`.
+
+- Renamed `ruby_lsp` to `ruby-lsp`.
+
+- Renamed `r_language_server` to `r-languageserver`.
+
+- Renamed `julials` to `julia-languageserver`.
+
+- Renamed `astro` to `astro-language-server`.
+
+- Renamed `bash-ls` to `bash-language-server`.
+
+- Renamed `jsonls` to `vscode-json-language-server`.
+
+- Renamed `cssls` to `vscode-css-language-server`.
+
+- Renamed `jdtls` to `jdt-language-server`.
+
+- Renamed `elixirls` to `elixir-ls`.
+
+- Removed `languages.tailwind` which only provided an LSP. Use
+  `lsp.presets.tailwindcss-language-server` instead.
+
 ## Changelog {#sec-release-0-9-changelog}
 
 [SecBear](https://github.com/SecBear):
@@ -195,6 +234,7 @@
     {command}`:healthcheck` doesn't know that.
   - Remove [which-key.nvim] `<leader>o` `+Notes` description which did not
     actually correspond to any keybinds.
+
 - Allow disabling nvf's vendored keymaps by toggling `vendoredKeymaps.enable`.
 
 [pyrox0](https://github.com/pyrox0):
@@ -229,6 +269,13 @@
 
 [Snoweuph](https://github.com/snoweuph)
 
+- Added `vim.lsp.presets.<name>` to contain LSP configurations. This allows for
+  more flexibility in nvf and reuse of LSPs across languages. Dropped
+  `deprecatedSingleOrListOf` in favor of `listOf` for the affected LSP options.
+
+- Fix `vim.lsp.presets.vala-language-server` to be wrapped correctly with
+  `uncrustify`.
+
 - Fix `tressiter` to allow `null` in grammar options, so they can be filtered
   out.
 

lib/types/custom.nix

@@ -1,9 +1,9 @@
 {lib}: let
-  inherit (builtins) toJSON;
+  inherit (builtins) toJSON attrNames;
   inherit (lib.options) mergeEqualOption;
   inherit (lib.lists) singleton;
   inherit (lib.strings) isString stringLength match;
-  inherit (lib.types) listOf mkOptionType coercedTo;
+  inherit (lib.types) listOf mkOptionType coercedTo enum;
   inherit (lib.trivial) warn;
 in {
   mergelessListOf = elemType:
@@ -39,4 +39,28 @@ in {
       ''
       (singleton x))
     (listOf t);
+
+  # Create an enum type for `values`, which additionally accepts deprecated
+  # values listed in the `renames` attrset as `old = new` pairs.
+  #
+  # Example:
+  #
+  # vim.languages.typescript.lsp.servers = mkOption {
+  #   type = renamedEnum
+  #     "vim.languages.typescript.lsp.servers"
+  #     ["typescript-language-server" "some-other-server"]
+  #     { ts_ls = "typescript-language-server"; };
+  # }
+  #
+  # With this option definition, when users enter `ts_ls`, they
+  # get a warning "`ts_ls` is deprecated, use `typescript-language-server`
+  # instead", and typescript-language-server is automatically used.
+  enumWithRename = option: values: renames:
+    coercedTo (enum (attrNames renames)) (
+      old:
+        warn
+        "${option}: `${old}` is deprecated, use `${renames.${old}}` instead"
+        renames.${old}
+    )
+    (enum values);
 }

lib/types/default.nix

@@ -5,10 +5,12 @@
   typesDag = import ./dag.nix {inherit lib;};
   typesPlugin = import ./plugins.nix {inherit lib self;};
   typesLanguage = import ./languages.nix {inherit lib;};
+  typesLsp = import ./lsp.nix {inherit lib;};
   customTypes = import ./custom.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf;
+  inherit (typesLsp) mkLspPresetEnableOption;
+  inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf enumWithRename;
 }

lib/types/lsp.nix

@@ -0,0 +1,12 @@
+{lib}: let
+  inherit (lib.options) mkEnableOption;
+
+  mkLspPresetEnableOption = option: display: fileTypes:
+    mkEnableOption ''
+      the ${display} Language Server.
+      Default `filetypes = ${lib.generators.toPretty {} fileTypes}`.
+      Use {option}`vim.lsp.servers.${option}` for customization
+    '';
+in {
+  inherit mkLspPresetEnableOption;
+}

modules/extra/deprecations.nix

@@ -242,9 +242,6 @@ in {
       (mkRenamedLspServer "svelte")
       (mkRemovedLspPackage "svelte")
 
-      (mkRenamedLspServer "tailwind")
-      (mkRemovedLspPackage "tailwind")
-
       (mkRemovedLspPackage "terraform")
 
       (mkRenamedLspServer "ts")
@@ -347,5 +344,11 @@ in {
     [
       (mkRenamedOptionModule ["vim" "treesitter" "foldByDefault"] ["vim" "options" "foldenable"])
     ]
+
+    # 2026-13-04
+    [
+      (mkRenamedOptionModule ["vim" "lsp" "harper-ls" "enable"] ["vim" "lsp" "presets" "harper" "enable"])
+      (mkRenamedOptionModule ["vim" "lsp" "harper-ls" "settings"] ["vim" "lsp" "servers" "harper" "settings"])
+    ]
   ];
 }

modules/plugins/languages/arduino.nix

@@ -4,54 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.meta) getExe getExe';
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.types) enum listOf str;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.arduino;
 
   defaultServers = ["arduino-language-server"];
-  servers = {
+  servers = ["arduino-language-server"];
-    arduino-language-server = {
-      enable = true;
-      cmd =
-        [
-          (getExe pkgs.arduino-language-server)
-          "-clangd"
-          (getExe' pkgs.clang-tools "clangd")
-          "-cli"
-          (getExe pkgs.arduino-cli)
-          "-cli-config"
-          "$HOME/.arduino15/arduino-cli.yaml"
-        ]
-        ++ cfg.lsp.extraArgs;
-      filetypes = ["arduino"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            on_dir(util.root_pattern("*.ino")(fname))
-          end
-        '';
-      capabilities = {
-        textDocument = {
-          semanticTokens = mkLuaInline "vim.NIL";
-        };
-        workspace = {
-          semanticTokens = mkLuaInline "vim.NIL";
-        };
-      };
-    };
-  };
 in {
   options.vim.languages.arduino = {
     enable = mkEnableOption "Arduino support";
@@ -74,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Arduino LSP servers to use";
       };
@@ -94,12 +56,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["arduino"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/asm.nix

@@ -4,24 +4,15 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib) genAttrs;
-  inherit (lib.meta) getExe;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.assembly;
   defaultServers = ["asm-lsp"];
-  servers = {
+  servers = ["asm-lsp"];
-    asm-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.asm-lsp)];
-      filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
-      root_markers = [".asm-lsp.toml" ".git"];
-    };
-  };
 in {
   options.vim.languages.assembly = {
     enable = mkEnableOption "Assembly support";
@@ -46,7 +37,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.asm.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Assembly LSP server to use";
       };
@@ -63,12 +54,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/astro.nix

@@ -9,37 +9,15 @@
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum coercedTo;
+  inherit (lib.types) enum coercedTo listOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf enumWithRename;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib) genAttrs;
 
   cfg = config.vim.languages.astro;
 
-  defaultServers = ["astro"];
+  defaultServers = ["astro-language-server"];
-  servers = {
+  servers = ["astro-language-server"];
-    astro = {
-      enable = true;
-      cmd = [(getExe pkgs.astro-language-server) "--stdio"];
-      filetypes = ["astro"];
-      root_markers = ["package.json" "tsconfig.json" "jsconfig.json" ".git"];
-      init_options = {
-        typescript = {};
-      };
-      before_init =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(_, config)
-            if config.init_options and config.init_options.typescript and not config.init_options.typescript.tsdk then
-              config.init_options.typescript.tsdk = util.get_typescript_server_path(config.root_dir)
-            end
-          end
-        '';
-    };
-  };
 
   defaultFormat = ["prettier"];
   formats = let
@@ -107,7 +85,12 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.astro.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.astro.lsp.servers"
+          servers
+          {
+            astro = "astro-language-server";
+          });
         default = defaultServers;
         description = "Astro LSP server to use";
       };
@@ -151,12 +134,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["astro"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/bash.nix

@@ -8,27 +8,15 @@
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum bool;
+  inherit (lib.types) enum bool listOf;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.bash;
 
-  defaultServers = ["bash-ls"];
+  defaultServers = ["bash-language-server"];
-  servers = {
+  servers = ["bash-language-server"];
-    bash-ls = {
-      enable = true;
-      cmd = [(getExe pkgs.bash-language-server) "start"];
-      filetypes = ["bash" "sh"];
-      root_markers = [".git"];
-      settings = {
-        basheIde = {
-          globPattern = mkLuaInline "vim.env.GLOB_PATTERN or '*@(.sh|.inc|.bash|.command)'";
-        };
-      };
-    };
-  };
 
   defaultFormat = ["shfmt"];
   formats = {
@@ -65,7 +53,12 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.bash.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.bash.lsp.servers"
+          servers
+          {
+            bash-ls = "bash-language-server";
+          });
         default = defaultServers;
         description = "Bash LSP server to use";
       };
@@ -107,12 +100,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["bash" "sh" "zsh"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/clang.nix

@@ -6,141 +6,16 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) bool enum package;
+  inherit (lib.types) bool enum package listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.dag) entryAfter;
 
   cfg = config.vim.languages.clang;
 
   defaultServers = ["clangd"];
-  servers = {
+  servers = ["ccls" "clangd"];
-    ccls = {
-      cmd = [(getExe pkgs.ccls)];
-      filetypes = ["c" "cpp" "objc" "objcpp" "cuda"];
-      offset_encoding = "utf-32";
-      root_markers = ["compile_commands.json" ".ccls" ".git"];
-      workspace_required = true;
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          local function switch_source_header(bufnr)
-            local method_name = "textDocument/switchSourceHeader"
-            local params = vim.lsp.util.make_text_document_params(bufnr)
-            client:request(method_name, params, function(err, result)
-              if err then
-                error(tostring(err))
-              end
-              if not result then
-                vim.notify('corresponding file cannot be determined')
-                return
-              end
-              vim.cmd.edit(vim.uri_to_fname(result))
-            end, bufnr)
-          end
-
-          vim.api.nvim_buf_create_user_command(
-            bufnr,
-            "LspCclsSwitchSourceHeader",
-            function(arg)
-              switch_source_header(client, 0)
-            end,
-            {desc = "Switch between source/header"}
-          )
-        end
-      '';
-    };
-
-    clangd = {
-      cmd = ["${pkgs.clang-tools}/bin/clangd"];
-      filetypes = ["c" "cpp" "objc" "objcpp" "cuda" "proto"];
-      root_markers = [
-        ".clangd"
-        ".clang-tidy"
-        ".clang-format"
-        "compile_commands.json"
-        "compile_flags.txt"
-        "configure.ac"
-        ".git"
-      ];
-      capabilities = {
-        textDocument = {
-          completion = {
-            editsNearCursor = true;
-          };
-        };
-        offsetEncoding = ["utf-8" "utf-16"];
-      };
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          local function switch_source_header(bufnr)
-            local method_name = "textDocument/switchSourceHeader"
-            local client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd", })[1]
-            if not client then
-              return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
-            end
-            local params = vim.lsp.util.make_text_document_params(bufnr)
-            client.request(method_name, params, function(err, result)
-              if err then
-                error(tostring(err))
-              end
-              if not result then
-                vim.notify('corresponding file cannot be determined')
-                return
-              end
-              vim.cmd.edit(vim.uri_to_fname(result))
-            end, bufnr)
-          end
-
-          local function symbol_info()
-            local bufnr = vim.api.nvim_get_current_buf()
-            local clangd_client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd" })[1]
-            if not clangd_client or not clangd_client:supports_method 'textDocument/symbolInfo' then
-              return vim.notify('Clangd client not found', vim.log.levels.ERROR)
-            end
-            local win = vim.api.nvim_get_current_win()
-            local params = vim.lsp.util.make_position_params(win, clangd_client.offset_encoding)
-            clangd_client:request('textDocument/symbolInfo', params, function(err, res)
-              if err or #res == 0 then
-                -- Clangd always returns an error, there is not reason to parse it
-                return
-              end
-              local container = string.format('container: %s', res[1].containerName) ---@type string
-              local name = string.format('name: %s', res[1].name) ---@type string
-              vim.lsp.util.open_floating_preview({ name, container }, "", {
-                height = 2,
-                width = math.max(string.len(name), string.len(container)),
-                focusable = false,
-                focus = false,
-                border = 'single',
-                title = 'Symbol Info',
-              })
-            end, bufnr)
-          end
-
-          vim.api.nvim_buf_create_user_command(
-            bufnr,
-            "ClangdSwitchSourceHeader",
-            function(arg)
-              switch_source_header(0)
-            end,
-            {desc = "Switch between source/header"}
-          )
-
-          vim.api.nvim_buf_create_user_command(
-            bufnr,
-            "ClangdShowSymbolInfo",
-            function(arg)
-              symbol_info()
-            end,
-            {desc = "Show symbol info"}
-          )
-        end
-      '';
-    };
-  };
 
   defaultDebugger = "lldb-vscode";
   debuggers = {
@@ -204,7 +79,7 @@ in {
 
       servers = mkOption {
         description = "The clang LSP server to use";
-        type = deprecatedSingleOrListOf "vim.language.clang.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
       };
     };
@@ -240,12 +115,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = ["c" "cpp" "objc" "objcpp" "cuda" "proto"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.dap.enable {

modules/plugins/languages/clojure.nix

@@ -4,25 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.clojure;
 
   defaultServers = ["clojure-lsp"];
-  servers = {
+  servers = ["clojure-lsp"];
-    clojure-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.clojure-lsp)];
-      filetypes = ["clojure" "edn"];
-      root_markers = ["project.clj" "deps.edn" "build.boot" "shadow-cljs.edn" ".git" "bb.edn"];
-    };
-  };
 in {
   options.vim.languages.clojure = {
     enable = mkEnableOption "Clojure language support";
@@ -45,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Clojure LSP server to use";
       };
@@ -54,12 +45,13 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["clojure" "edn"];
-        })
+          root_markers = ["deps.edn" "build.boot" "shadow-cljs.edn" "bb.edn"];
-        cfg.lsp.servers;
+        });
+      };
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/cmake.nix

@@ -7,25 +7,15 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum listOf package;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.cmake;
 
   defaultServers = ["neocmakelsp"];
-  servers = {
+  servers = ["neocmakelsp"];
-    neocmakelsp = {
-      enable = true;
-      cmd = [(getExe pkgs.neocmakelsp) "stdio"];
-      filetypes = ["cmake"];
-      root_markers = [".gersemirc" ".git" "build" "cmake"];
-      capabilities = {
-        textDocument.completion.completionItem.snippetSupport = true;
-      };
-    };
-  };
 
   defaultFormat = "gersemi";
   formats = {
@@ -55,7 +45,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "CMake LSP servers to use";
       };
@@ -90,12 +80,13 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["cmake"];
-        })
+          root_markers = ["build" "cmake"];
-        cfg.lsp.servers;
+        });
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/css.nix

@@ -6,29 +6,17 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.css;
 
-  defaultServer = ["cssls"];
+  defaultServer = ["vscode-css-language-server"];
-  servers = {
+  servers = ["vscode-css-language-server"];
-    cssls = {
-      cmd = ["${pkgs.vscode-langservers-extracted}/bin/vscode-css-language-server" "--stdio"];
-      filetypes = ["css" "scss" "less"];
-      # needed to enable formatting
-      init_options = {provideFormatter = true;};
-      root_markers = [".git" "package.json"];
-      settings = {
-        css.validate = true;
-        scss.validate = true;
-        less.validate = true;
-      };
-    };
-  };
 
   defaultFormat = ["prettier"];
   formats = {
@@ -68,7 +56,12 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.css.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.css.lsp.servers"
+          servers
+          {
+            cssls = "vscode-css-language-server";
+          });
         default = defaultServer;
         description = "CSS LSP server to use";
       };
@@ -92,12 +85,17 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = [
-        })
+            "css"
-        cfg.lsp.servers;
+            # TODO: split in their own modules
+            "scss"
+            "less"
+          ];
+        });
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/cue.nix

@@ -4,16 +4,14 @@
   lib,
   ...
 }: let
-  inherit (lib.options) mkEnableOption literalExpression;
+  inherit (lib.options) mkEnableOption literalExpression mkOption;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.types) enum listOf;
+  inherit (lib) genAttrs;
 
-  lspOptions = {
+  defaultServers = ["cue"];
-    cmd = [(getExe pkgs.cue) "lsp"];
+  servers = ["cue"];
-    filetypes = ["cue"];
-    root_markers = ["cue.mod" ".git"];
-  };
 
   cfg = config.vim.languages.cue;
 in {
@@ -38,6 +36,12 @@ in {
           default = config.vim.lsp.enable;
           defaultText = literalExpression "config.vim.lsp.enable";
         };
+
+      servers = mkOption {
+        type = listOf (enum servers);
+        default = defaultServers;
+        description = "CUE LSP server to use";
+      };
     };
   };
 
@@ -48,7 +52,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers.cue = lspOptions;
+      vim.lsp = {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
+        servers = genAttrs cfg.lsp.servers (_: {
+          filetypes = ["cue"];
+        });
+      };
     })
   ]);
 }

modules/plugins/languages/dart.nix

@@ -4,42 +4,20 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.trivial) boolToString;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) enum package nullOr str bool;
+  inherit (lib.types) enum package nullOr str bool listOf;
   inherit (lib.strings) optionalString;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.dart;
   ftcfg = cfg.flutter-tools;
 
   defaultServers = ["dart"];
-  servers = {
+  servers = ["dart"];
-    dart = {
-      enable = true;
-      cmd = [(getExe pkgs.dart) "language-server" "--protocol=lsp"];
-      filetypes = ["dart"];
-      root_markers = ["pubspec.yaml"];
-      init_options = {
-        onlyAnalyzeProjectsWithOpenFiles = true;
-        suggestFromUnimportedLibraries = true;
-        closingLabels = true;
-        outline = true;
-        flutterOutline = true;
-      };
-      settings = {
-        dart = {
-          completeFunctionCalls = true;
-          showTodos = true;
-        };
-      };
-    };
-  };
 in {
   options.vim.languages.dart = {
     enable = mkEnableOption "Dart language support";
@@ -62,7 +40,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.dart.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Dart LSP server to use";
       };
@@ -142,12 +120,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["dart"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf ftcfg.enable {

modules/plugins/languages/default.nix

@@ -45,7 +45,6 @@ in {
     ./scala.nix
     ./sql.nix
     ./svelte.nix
-    ./tailwind.nix
     ./terraform.nix
     ./toml.nix
     ./ts.nix

modules/plugins/languages/elixir.nix

@@ -7,38 +7,16 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.elixir;
 
-  defaultServers = ["elixirls"];
+  defaultServers = ["elixir-ls"];
-  servers = {
+  servers = ["elixir-ls"];
-    elixirls = {
-      enable = true;
-      cmd = [(getExe pkgs.elixir-ls)];
-      filetypes = ["elixir" "eelixir" "heex" "surface"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            local matches = vim.fs.find({ 'mix.exs' }, { upward = true, limit = 2, path = fname })
-            local child_or_root_path, maybe_umbrella_path = unpack(matches)
-            local root_dir = vim.fs.dirname(maybe_umbrella_path or child_or_root_path)
-
-            on_dir(root_dir)
-          end
-        '';
-    };
-  };
 
   defaultFormat = ["mix"];
   formats = {
@@ -70,7 +48,12 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.elixir.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.elixir.lsp.servers"
+          servers
+          {
+            elixirls = "elixir-ls";
+          });
         default = defaultServers;
         description = "Elixir LSP server to use";
       };
@@ -102,12 +85,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["elixir" "eelixir" "heex" "surface"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/elm.nix

@@ -4,26 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.elm;
 
   defaultServers = ["elm-language-server"];
-  servers = {
+  servers = ["elm-language-server"];
-    elm-language-server = {
-      enable = true;
-      cmd = [(getExe pkgs.elmPackages.elm-language-server)];
-      filetypes = ["elm"];
-      root_markers = ["elm.json"];
-      workspace_required = false;
-    };
-  };
 in {
   options.vim.languages.elm = {
     enable = mkEnableOption "Elm language support";
@@ -47,7 +37,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.elm.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Elm LSP servers to use";
       };
@@ -63,13 +53,11 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim = {
+      vim.lsp = {
-        lsp.servers =
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          mapListToAttrs (n: {
+        servers = genAttrs cfg.lsp.servers (_: {
-            name = n;
+          filetypes = ["elm"];
-            value = servers.${n};
+        });
-          })
-          cfg.lsp.servers;
       };
     })
   ]);

modules/plugins/languages/fsharp.nix

@@ -6,50 +6,15 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   defaultServer = ["fsautocomplete"];
-  servers = {
+  servers = ["fsautocomplete"];
-    fsautocomplete = {
-      cmd = [(getExe pkgs.fsautocomplete) "--adaptive-lsp-server-enabled"];
-      filetypes = ["fsharp"];
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          on_dir(vim.fs.root(bufnr, function(name, path)
-            return name == ".git" or name:match("%.sln$") or name:match("%.fsproj$")
-          end))
-        end
-      '';
-      init_options = {
-        AutomaticWorkspaceInit = true;
-      };
-      settings = {
-        FSharp = {
-          keywordsAutocomplete = true;
-          ExternalAutocomplete = false;
-          Linter = true;
-          UnionCaseStubGeneration = true;
-          UnionCaseStubGenerationBody = ''failwith "Not Implemented"'';
-          RecordStubGeneration = true;
-          RecordStubGenerationBody = ''failwith "Not Implemented"'';
-          InterfaceStubGeneration = true;
-          InterfaceStubGenerationObjectIdentifier = "this";
-          InterfaceStubGenerationMethodBody = ''failwith "Not Implemented"'';
-          UnusedOpensAnalyzer = true;
-          UnusedDeclarationsAnalyzer = true;
-          UseSdkScripts = true;
-          SimplifyNameAnalyzer = true;
-          ResolveNamespaces = true;
-          EnableReferenceCodeLens = true;
-        };
-      };
-    };
-  };
 
   defaultFormat = ["fantomas"];
   formats = {
@@ -82,7 +47,7 @@ in {
             defaultText = literalExpression "config.vim.lsp.enable";
           };
         servers = mkOption {
-          type = deprecatedSingleOrListOf "vim.language.fsharp.lsp.servers" (enum (attrNames servers));
+          type = listOf (enum servers);
           default = defaultServer;
           description = "F# LSP server to use";
         };
@@ -106,12 +71,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = ["fsharp"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/gleam.nix

@@ -4,25 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.gleam;
 
   defaultServers = ["gleam"];
-  servers = {
+  servers = ["gleam"];
-    gleam = {
-      enable = true;
-      cmd = [(getExe pkgs.gleam) "lsp"];
-      filetypes = ["gleam"];
-      root_markers = ["gleam.toml" ".git"];
-    };
-  };
 in {
   options.vim.languages.gleam = {
     enable = mkEnableOption "Gleam language support";
@@ -45,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.gleam.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Gleam LSP server to use";
       };
@@ -59,12 +50,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["gleam"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/glsl.nix

@@ -4,25 +4,16 @@
   pkgs,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.types) enum listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.glsl;
 
   defaultServers = ["glsl_analyzer"];
-  servers = {
+  servers = ["glsl_analyzer"];
-    glsl_analyzer = {
-      enable = true;
-      cmd = [(getExe pkgs.glsl_analyzer)];
-      filetypes = ["glsl" "vert" "tesc" "tese" "frag" "geom" "comp"];
-      root_markers = [".git"];
-    };
-  };
 in {
   options.vim.languages.glsl = {
     enable = mkEnableOption "GLSL language support";
@@ -46,7 +37,7 @@ in {
         };
 
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "GLSL LSP server to use";
       };
@@ -62,12 +53,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["glsl" "vert" "tesc" "tese" "frag" "geom" "comp"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/go.nix

@@ -9,8 +9,9 @@
   inherit (lib.options) mkEnableOption mkOption literalMD literalExpression;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.types) bool enum package str;
+  inherit (lib.types) enum package str listOf;
   inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.attrsets) mapListToAttrs;
@@ -18,47 +19,7 @@
   cfg = config.vim.languages.go;
 
   defaultServers = ["gopls"];
-  servers = {
+  servers = ["gopls"];
-    gopls = {
-      cmd = [(getExe pkgs.gopls)];
-      filetypes = ["go" "gomod" "gosum" "gowork" "gotmpl"];
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          local fname = vim.api.nvim_buf_get_name(bufnr)
-
-          local function get_root(fname)
-            if _G.nvf_gopls_mod_cache and fname:sub(1, #_G.nvf_gopls_mod_cache) == _G.nvf_gopls_mod_cache then
-              local clients = vim.lsp.get_clients { name = 'gopls' }
-              if #clients > 0 then
-                return clients[#clients].config.root_dir
-              end
-            end
-            return vim.fs.root(fname, 'go.work') or vim.fs.root(fname, 'go.mod') or vim.fs.root(fname, '.git')
-          end
-
-          -- see: https://github.com/neovim/nvim-lspconfig/issues/804
-          if _G.nvf_gopls_mod_cache then
-            on_dir(get_root(fname))
-            return
-          end
-          local cmd = { 'go', 'env', 'GOMODCACHE' }
-          local ok, err = pcall(vim.system, cmd, { text = true }, function(output)
-            if output.code == 0 then
-              if output.stdout then
-                _G.nvf_gopls_mod_cache = vim.trim(output.stdout)
-              end
-              on_dir(get_root(fname))
-            else
-              vim.schedule(function()
-                vim.notify(('[gopls] cmd failed with code %d: %s\n%s'):format(output.code, cmd, output.stderr))
-              end)
-            end
-          end)
-          if not ok then vim.notify(('[gopls] cmd failed: %s\n%s'):format(cmd, err)) end
-        end
-      '';
-    };
-  };
 
   defaultFormat = ["gofmt"];
   formats = {
@@ -194,7 +155,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.go.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Go LSP server to use";
       };
@@ -319,12 +280,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = ["go" "gomod" "gosum" "gowork" "gotmpl"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/hcl.nix

@@ -6,30 +6,17 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.hcl;
 
-  defaultServers = ["tofuls-hcl"];
+  defaultServers = ["tofu-ls"];
-  servers = {
+  servers = ["terraform-ls" "tofu-ls"];
-    terraformls-hcl = {
-      enable = true;
-      cmd = [(getExe pkgs.terraform-ls) "serve"];
-      filetypes = ["hcl"];
-      root_markers = [".git"];
-    };
-    tofuls-hcl = {
-      enable = true;
-      cmd = [(getExe pkgs.tofu-ls) "serve"];
-      filetypes = ["hcl"];
-      root_markers = [".terraform" ".git"];
-    };
-    # TODO: package nomad-lsp and offer as an option here too
-  };
 
   defaultFormat = ["hclfmt"];
   formats = {
@@ -64,7 +51,13 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.hcl.lsp.servers"
+          servers
+          {
+            terraformls-hcl = "terraform-ls";
+            tofuls-hcl = "tofu-ls";
+          });
         default = defaultServers;
         description = "HCL LSP server to use";
       };
@@ -116,13 +109,11 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim = {
+      vim.lsp = {
-        lsp.servers =
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          mapListToAttrs (n: {
+        servers = genAttrs cfg.lsp.servers (_: {
-            name = n;
+          filetypes = ["hcl"];
-            value = servers.${n};
+        });
-          })
-          cfg.lsp.servers;
       };
     })
 

modules/plugins/languages/helm.nix

@@ -4,41 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames head;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
-  inherit (lib.modules) mkDefault mkIf mkMerge;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.helm;
-  yamlCfg = config.vim.languages.yaml;
 
   defaultServers = ["helm-ls"];
-  servers = {
+  servers = ["helm-ls"];
-    helm-ls = {
-      enable = true;
-      cmd = [(getExe pkgs.helm-ls) "serve"];
-      filetypes = ["helm" "yaml.helm-values"];
-      root_markers = ["Chart.yaml"];
-      capabilities = {
-        didChangeWatchedFiles = {
-          dynamicRegistration = true;
-        };
-      };
-      settings = mkIf (yamlCfg.enable && yamlCfg.lsp.enable) {
-        helm-ls = {
-          yamlls = {
-            # Without this being enabled, the YAML language module will look broken in helmfiles
-            # if both modules are enabled at once.
-            enabled = mkDefault yamlCfg.lsp.enable;
-            path = head config.vim.lsp.servers.${head yamlCfg.lsp.servers}.cmd;
-          };
-        };
-      };
-    };
-  };
 in {
   options.vim.languages.helm = {
     enable = mkEnableOption "Helm language support";
@@ -61,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.helm.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Helm LSP server to use";
       };
@@ -75,12 +50,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["helm" "yaml.helm-values"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     {

modules/plugins/languages/html.nix

@@ -8,7 +8,8 @@
   inherit (lib.meta) getExe;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) bool enum;
+  inherit (lib.types) bool enum listOf;
+  inherit (lib) genAttrs;
   inherit (lib.lists) optional;
   inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
@@ -17,18 +18,7 @@
   cfg = config.vim.languages.html;
 
   defaultServers = ["superhtml"];
-  servers = {
+  servers = ["superhtml" "emmet-ls"];
-    superhtml = {
-      cmd = [(getExe pkgs.superhtml) "lsp"];
-      filetypes = ["html" "shtml" "htm"];
-      root_markers = ["index.html" ".git"];
-    };
-    emmet-ls = {
-      cmd = [(getExe pkgs.emmet-ls) "--stdio"];
-      filetypes = ["html" "shtml" "htm"];
-      root_markers = ["index.html" ".git"];
-    };
-  };
 
   defaultFormat = ["superhtml"];
   formats = {
@@ -70,7 +60,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.html.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "HTML LSP server to use";
       };
@@ -124,12 +114,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["html" "shtml" "xhtml" "htm"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf (cfg.format.enable && !cfg.lsp.enable) {

modules/plugins/languages/java.nix

@@ -6,60 +6,14 @@
 }: let
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (builtins) attrNames;
+  inherit (lib.types) listOf;
-  inherit (lib.types) listOf enum;
+  inherit (lib.nvim.types) mkGrammarOption enumWithRename;
-  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.dag) entryBefore;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.java;
 
-  defaultServers = ["jdtls"];
+  defaultServers = ["jdt-language-server"];
-  servers = {
+  servers = ["jdt-language-server"];
-    jdtls = {
-      enable = true;
-      cmd =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          {
-            '${getExe pkgs.jdt-language-server}',
-            '-configuration',
-            get_jdtls_config_dir(),
-            '-data',
-            get_jdtls_workspace_dir(),
-            get_jdtls_jvm_args(),
-          }
-        '';
-      filetypes = ["java"];
-      root_markers = [
-        # Multi-module projects
-        ".git"
-        "build.gradle"
-        "build.gradle.kts"
-        # Single-module projects
-        "build.xml" # Ant
-        "pom.xml" # Maven
-        "settings.gradle" # Gradle
-        "settings.gradle.kts" # Gradle
-      ];
-      init_options = {
-        workspace = mkLuaInline "get_jdtls_workspace_dir()";
-        jvm_args = {};
-        os_config = mkLuaInline "nil";
-      };
-      handlers = {
-        "textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
-        "textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
-        "workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
-        "language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
-      };
-    };
-  };
 in {
   options.vim.languages.java = {
     enable = mkEnableOption "Java language support";
@@ -82,7 +36,12 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.java.lsp.servers"
+          servers
+          {
+            jdtls = "jdt-language-server";
+          });
         default = defaultServers;
         description = "Java LSP server to use";
       };
@@ -91,96 +50,12 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.luaConfigRC.jdtls-util =
+      vim.lsp = {
-        entryBefore ["lsp-servers"]
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-        /*
+        servers = genAttrs cfg.lsp.servers (_: {
-        lua
+          filetypes = ["java"];
-        */
+        });
-        ''
+      };
-          local jdtls_handlers = require 'vim.lsp.handlers'
-
-          local jdtls_env = {
-            HOME = vim.uv.os_homedir(),
-            XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
-            JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
-          }
-
-          local function get_cache_dir()
-            return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
-          end
-
-          local function get_jdtls_cache_dir()
-            return get_cache_dir() .. '/jdtls'
-          end
-
-          local function get_jdtls_config_dir()
-            return get_jdtls_cache_dir() .. '/config'
-          end
-
-          local function get_jdtls_workspace_dir()
-            return get_jdtls_cache_dir() .. '/workspace'
-          end
-
-          local function get_jdtls_jvm_args()
-            local args = {}
-            for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
-              local arg = string.format('--jvm-arg=%s', a)
-              table.insert(args, arg)
-            end
-            return unpack(args)
-          end
-
-          -- TextDocument version is reported as 0, override with nil so that
-          -- the client doesn't think the document is newer and refuses to update
-          -- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
-          local function jdtls_fix_zero_version(workspace_edit)
-            if workspace_edit and workspace_edit.documentChanges then
-              for _, change in pairs(workspace_edit.documentChanges) do
-                local text_document = change.textDocument
-                if text_document and text_document.version and text_document.version == 0 then
-                  text_document.version = nil
-                end
-              end
-            end
-            return workspace_edit
-          end
-
-          local function jdtls_on_textdocument_codeaction(err, actions, ctx)
-            for _, action in ipairs(actions) do
-              -- TODO: (steelsojka) Handle more than one edit?
-              if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
-                action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
-              elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
-                action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
-              end
-            end
-
-            jdtls_handlers[ctx.method](err, actions, ctx)
-          end
-
-          local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
-            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
-          end
-
-          local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
-            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
-          end
-
-          -- Non-standard notification that can be used to display progress
-          local function jdtls_on_language_status(_, result)
-            local command = vim.api.nvim_command
-            command 'echohl ModeMsg'
-            command(string.format('echo "%s"', result.message))
-            command 'echohl None'
-          end
-        '';
-
-      vim.lsp.servers =
-        mapListToAttrs (n: {
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/jinja.nix

@@ -4,26 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.jinja;
+
   defaultServers = ["jinja-lsp"];
-  servers = {
+  servers = ["jinja-lsp"];
-    jinja-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.jinja-lsp)];
-      filetypes = ["jinja"];
-      root_markers = [
-        ".git"
-      ];
-    };
-  };
 in {
   options.vim.languages.jinja = {
     enable = mkEnableOption "Jinja template language support";
@@ -48,7 +38,7 @@ in {
         };
       servers = mkOption {
         description = "Jinja LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
       };
     };
@@ -64,12 +54,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["jinja"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/jq.nix

@@ -8,6 +8,7 @@
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.types) enum listOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption;
@@ -15,14 +16,7 @@
   cfg = config.vim.languages.jq;
 
   defaultServers = ["jq-lsp"];
-  servers = {
+  servers = ["jq-lsp"];
-    jq-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.jq-lsp)];
-      filetypes = ["jq"];
-      root_markers = [".git"];
-    };
-  };
 
   defaultFormat = ["jqfmt"];
   formats = {
@@ -57,7 +51,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "JQ LSP server to use";
       };
@@ -88,12 +82,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["jq"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/json.nix

@@ -6,23 +6,17 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.meta) getExe' getExe;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib) genAttrs;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.json;
 
-  defaultServers = ["jsonls"];
+  defaultServers = ["vscode-json-language-server"];
-  servers = {
+  servers = ["vscode-json-language-server"];
-    jsonls = {
-      cmd = [(getExe' pkgs.vscode-langservers-extracted "vscode-json-language-server") "--stdio"];
-      filetypes = ["json" "jsonc" "json5"];
-      init_options = {provideFormatter = true;};
-      root_markers = [".git"];
-    };
-  };
 
   defaultFormat = ["jsonfmt"];
 
@@ -57,7 +51,12 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.json.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.json.lsp.servers"
+          servers
+          {
+            jsonls = "vscode-json-language-server";
+          });
         default = defaultServers;
         description = "JSON LSP server to use";
       };
@@ -89,12 +88,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = ["json" "jsonc" "json5"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/julia.nix

@@ -4,86 +4,16 @@
   config,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
-  inherit (lib.types) enum;
+  inherit (lib.types) listOf;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption enumWithRename;
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.dag) entryBefore;
-
-  defaultServers = ["julials"];
-  servers = {
-    julials = {
-      enable = true;
-      cmd =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          {
-            '${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
-            '--startup-file=no',
-            '--history-file=no',
-            '-e',
-            [[
-              # Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
-              # with the regular load path as a fallback
-              ls_install_path = joinpath(
-                  get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
-                  "environments", "nvim-lspconfig"
-              )
-              pushfirst!(LOAD_PATH, ls_install_path)
-              using LanguageServer
-              popfirst!(LOAD_PATH)
-              depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
-              project_path = let
-                  dirname(something(
-                      ## 1. Finds an explicitly set project (JULIA_PROJECT)
-                      Base.load_path_expand((
-                          p = get(ENV, "JULIA_PROJECT", nothing);
-                          p === nothing ? nothing : isempty(p) ? nothing : p
-                      )),
-                      ## 2. Look for a Project.toml file in the current working directory,
-                      ##    or parent directories, with $HOME as an upper boundary
-                      Base.current_project(),
-                      ## 3. First entry in the load path
-                      get(Base.load_path(), 1, nothing),
-                      ## 4. Fallback to default global environment,
-                      ##    this is more or less unreachable
-                      Base.load_path_expand("@v#.#"),
-                  ))
-              end
-              @info "Running language server" VERSION pwd() project_path depot_path
-              server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
-              server.runlinter = true
-              run(server)
-            ]],
-          }
-        '';
-      filetypes = ["julia"];
-      root_markers = ["Project.toml" "JuliaProject.toml"];
-      on_attach =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(_, bufnr)
-              vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
-                desc = 'Activate a Julia environment',
-                nargs = '?',
-                complete = 'file',
-              })
-          end
-        '';
-    };
-  };
 
   cfg = config.vim.languages.julia;
+
+  defaultServers = ["julia-languageserver"];
+  servers = ["julia-languageserver"];
 in {
   options = {
     vim.languages.julia = {
@@ -107,7 +37,12 @@ in {
             defaultText = literalExpression "config.vim.lsp.enable";
           };
         servers = mkOption {
-          type = deprecatedSingleOrListOf "vim.language.julia.lsp.servers" (enum (attrNames servers));
+          type = listOf (enumWithRename
+            "vim.languages.julia.lsp.servers"
+            servers
+            {
+              julials = "julia-languageserver";
+            });
           default = defaultServers;
           description = ''
             Julia LSP Server to Use
@@ -136,70 +71,14 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.luaConfigRC.julia-util =
+      vim = {
-        entryBefore ["lsp-servers"]
+        lsp = {
-        /*
+          presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-        lua
+          servers = genAttrs cfg.lsp.servers (_: {
-        */
+            filetypes = ["julia"];
-        ''
+          });
-          local function activate_julia_env(path)
+        };
-            assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
+      };
-            local bufnr = vim.api.nvim_get_current_buf()
-            local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
-            assert(
-              #julials_clients > 0,
-              'method julia/activateenvironment is not supported by any servers active on the current buffer'
-            )
-            local function _activate_env(environment)
-              if environment then
-                for _, julials_client in ipairs(julials_clients) do
-                  julials_client:notify('julia/activateenvironment', { envPath = environment })
-                end
-                vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
-              end
-            end
-            if path then
-              path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
-              local found_env = false
-              for _, project_file in ipairs(root_files) do
-                local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
-                if file and file.type then
-                  found_env = true
-                  break
-                end
-              end
-              if not found_env then
-                vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
-                return
-              end
-              _activate_env(path)
-            else
-              local depot_paths = vim.env.JULIA_DEPOT_PATH
-                  and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
-                or { vim.fn.expand '~/.julia' }
-              local environments = {}
-              vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
-              for _, depot_path in ipairs(depot_paths) do
-                local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
-                vim.list_extend(
-                  environments,
-                  vim.fs.find(function(name, env_path)
-                    return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
-                  end, { path = depot_env, type = 'file', limit = math.huge })
-                )
-              end
-              environments = vim.tbl_map(vim.fs.dirname, environments)
-              vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
-            end
-          end
-        '';
-
-      vim.lsp.servers =
-        mapListToAttrs (n: {
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/just.nix

@@ -4,25 +4,16 @@
   pkgs,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.types) enum listOf;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.just;
 
   defaultServers = ["just-lsp"];
-  servers = {
+  servers = ["just-lsp"];
-    just-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.just-lsp)];
-      filetypes = ["just"];
-      root_markers = [".git" "justfile"];
-    };
-  };
 in {
   options.vim.languages.just = {
     enable = mkEnableOption "Just support";
@@ -45,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Just LSP server to use";
       };
@@ -61,12 +52,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["just"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/kotlin.nix

@@ -6,44 +6,16 @@
 }: let
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe' getExe;
+  inherit (lib.meta) getExe;
-  inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
   inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.kotlin;
 
   defaultServers = ["kotlin-language-server"];
-  servers = {
+  servers = ["kotlin-language-server"];
-    kotlin-language-server = {
-      enable = true;
-      cmd = [(getExe' pkgs.kotlin-language-server "kotlin-language-server")];
-      filetypes = ["kotlin"];
-      root_markers = [
-        "settings.gradle" # Gradle (multi-project)
-        "settings.gradle.kts" # Gradle (multi-project)
-        "build.xml" # Ant
-        "pom.xml" # Maven
-        "build.gradle" # Gradle
-        "build.gradle.kts" # gradle
-      ];
-      init_options = {
-        storagePath = mkLuaInline "
-        vim.fs.root(vim.fn.expand '%:p:h',
-          {
-            'settings.gradle', -- Gradle (multi-project)
-            'settings.gradle.kts', -- Gradle (multi-project)
-            'build.xml', -- Ant
-            'pom.xml', -- Maven
-            'build.gradle', -- Gradle
-            'build.gradle.kts', -- Gradle
-          }
-        )";
-      };
-    };
-  };
 
   defaultDiagnosticsProvider = ["ktlint"];
   diagnosticsProviders = {
@@ -73,7 +45,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Kotlin LSP server to use";
       };
@@ -112,12 +84,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["kotlin"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/lua.nix

@@ -8,6 +8,7 @@
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
   inherit (lib.types) bool enum listOf;
   inherit (lib.nvim.types) diagnostics mkGrammarOption;
   inherit (lib.nvim.dag) entryBefore;
@@ -16,23 +17,7 @@
   cfg = config.vim.languages.lua;
 
   defaultServers = ["lua-language-server"];
-  servers = {
+  servers = ["lua-language-server"];
-    lua-language-server = {
-      enable = true;
-      cmd = [(getExe pkgs.lua-language-server)];
-      filetypes = ["lua"];
-      root_markers = [
-        ".luarc.json"
-        ".luarc.jsonc"
-        ".luacheckrc"
-        ".stylua.toml"
-        "stylua.toml"
-        "selene.toml"
-        "selene.yml"
-        ".git"
-      ];
-    };
-  };
 
   defaultFormat = ["stylua"];
   formats = {
@@ -77,7 +62,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Lua LSP server to use";
       };
@@ -122,12 +107,12 @@ in {
 
     (mkIf cfg.enable (mkMerge [
       (mkIf cfg.lsp.enable {
-        vim.lsp.servers =
+        vim.lsp = {
-          mapListToAttrs (n: {
+          presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-            name = n;
+          servers = genAttrs cfg.lsp.servers (_: {
-            value = servers.${n};
+            filetypes = ["lsp"];
-          })
+          });
-          cfg.lsp.servers;
+        };
       })
 
       (mkIf cfg.lsp.lazydev.enable {

modules/plugins/languages/markdown.nix

@@ -5,6 +5,7 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe getExe';
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
@@ -17,28 +18,7 @@
 
   cfg = config.vim.languages.markdown;
   defaultServers = ["marksman"];
-  servers = {
+  servers = ["marksman" "markdown-oxide" "rumdl"];
-    marksman = {
-      enable = true;
-      cmd = [(getExe pkgs.marksman) "server"];
-      filetypes = ["markdown" "mdx"];
-      root_markers = [".marksman.toml" ".git"];
-    };
-
-    markdown-oxide = {
-      enable = true;
-      cmd = [(getExe pkgs.markdown-oxide)];
-      filetypes = ["markdown"];
-      root_markers = [".git" ".obsidian" ".moxide.toml"];
-    };
-
-    rumdl = {
-      enable = true;
-      cmd = [(getExe pkgs.rumdl) "server"];
-      filetypes = ["markdown"];
-      root_markers = [".git" ".rumdl.toml" "rumdl.toml" ".config/rumdl.toml" "pyproject.toml"];
-    };
-  };
 
   defaultFormat = ["deno_fmt"];
   formats = {
@@ -99,7 +79,7 @@ in {
 
       servers = mkOption {
         description = "Markdown LSP server to use";
-        type = deprecatedSingleOrListOf "vim.language.markdown.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
       };
     };
@@ -186,12 +166,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["markdown" "mdx"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/nim.nix

@@ -6,36 +6,16 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.meta) getExe';
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
+  inherit (lib) genAttrs;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.nim;
 
   defaultServers = ["nimlsp"];
-  servers = {
+  servers = ["nimlsp"];
-    nimlsp = {
-      enable = true;
-      cmd = [(getExe' pkgs.nimlsp "nimlsp")];
-      filetypes = ["nim"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-              local fname = vim.api.nvim_buf_get_name(bufnr)
-              on_dir(
-                util.root_pattern '*.nimble'(fname) or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
-              )
-          end
-        '';
-    };
-  };
 
   defaultFormat = ["nimpretty"];
   formats = {
@@ -66,7 +46,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.nim.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Nim LSP server to use";
       };
@@ -103,12 +83,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["nim"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/nix.nix

@@ -5,32 +5,18 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib) concatStringsSep;
+  inherit (lib) concatStringsSep genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.nix;
 
   defaultServers = ["nil"];
-  servers = {
+  servers = ["nil" "nixd"];
-    nil = {
-      enable = true;
-      cmd = [(getExe pkgs.nil)];
-      filetypes = ["nix"];
-      root_markers = [".git" "flake.nix"];
-    };
-
-    nixd = {
-      enable = true;
-      cmd = [(getExe pkgs.nixd)];
-      filetypes = ["nix"];
-      root_markers = [".git" "flake.nix"];
-    };
-  };
 
   defaultFormat = ["alejandra"];
   formats = {
@@ -91,7 +77,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.nix.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Nix LSP server to use";
       };
@@ -147,12 +133,13 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["nix"];
-        })
+          root_markers = ["flake.nix"];
-        cfg.lsp.servers;
+        });
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/nu.nix

@@ -5,32 +5,13 @@
   ...
 }: let
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (builtins) attrNames;
 
   defaultServers = ["nushell"];
-  servers = {
+  servers = ["nushell"];
-    nushell = {
-      enable = true;
-      cmd = [(getExe pkgs.nushell) "--no-config-file" "--lsp"];
-      filetypes = ["nu"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            on_dir(vim.fs.root(bufnr, { '.git' }) or vim.fs.dirname(vim.api.nvim_buf_get_name(bufnr)))
-          end
-        '';
-    };
-  };
 
   cfg = config.vim.languages.nu;
 in {
@@ -56,7 +37,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.nu.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Nu LSP server to use";
       };
@@ -70,12 +51,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["nu"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/ocaml.nix

@@ -7,53 +7,16 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.ocaml;
 
   defaultServers = ["ocaml-lsp"];
-  servers = {
+  servers = ["ocaml-lsp"];
-    ocaml-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.ocamlPackages.ocaml-lsp)];
-      filetypes = ["ocaml" "menhir" "ocamlinterface" "ocamllex" "reason" "dune"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            on_dir(util.root_pattern('*.opam', 'esy.json', 'package.json', '.git', 'dune-project', 'dune-workspace')(fname))
-          end
-        '';
-      get_language_id =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(_, ftype)
-            local language_id_of = {
-              menhir = 'ocaml.menhir',
-              ocaml = 'ocaml',
-              ocamlinterface = 'ocaml.interface',
-              ocamllex = 'ocaml.ocamllex',
-              reason = 'reason',
-              dune = 'dune',
-            }
-
-            return language_id_of[ftype]
-
-          end
-        '';
-    };
-  };
 
   defaultFormat = ["ocamlformat"];
   formats = {
@@ -84,7 +47,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.ocaml.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "OCaml LSP server to use";
       };
@@ -102,12 +65,12 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["ocaml" "menhir" "ocamlinterface" "ocamllex" "reason" "dune"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/odin.nix

@@ -7,34 +7,15 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum package listOf;
   inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.odin;
 
   defaultServers = ["ols"];
-  servers = {
+  servers = ["ols"];
-    ols = {
-      enable = true;
-      cmd = [(getExe pkgs.ols)];
-      filetypes = ["odin"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            on_dir(util.root_pattern('ols.json', '.git', '*.odin')(fname))
-          end'';
-    };
-  };
-
   defaultDebugger = "codelldb";
   debuggers = {
     codelldb = {
@@ -71,7 +52,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.odin.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Odin LSP server to use";
       };
@@ -106,12 +87,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["odin"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.dap.enable {

modules/plugins/languages/openscad.nix

@@ -4,12 +4,10 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.openscad;
   /*
@@ -22,13 +20,7 @@
   */
 
   defaultServers = ["openscad-lsp"];
-  servers = {
+  servers = ["openscad-lsp"];
-    openscad-lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.openscad-lsp) "--stdio"];
-      filetypes = ["openscad"];
-    };
-  };
 in {
   options.vim.languages.openscad = {
     enable = mkEnableOption "OpenSCAD language support";
@@ -42,7 +34,7 @@ in {
         };
 
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "OpenSCAD LSP server to use";
       };
@@ -51,12 +43,12 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["openscad"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/php.nix

@@ -6,65 +6,18 @@
 }: let
   inherit (builtins) attrNames toString;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum int attrs listOf;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.php;
 
   defaultServers = ["phpactor"];
-  servers = {
+  servers = ["phpactor" "phan" "intelephense"];
-    phpactor = {
-      enable = true;
-      cmd = [(getExe pkgs.phpactor) "language-server"];
-      filetypes = ["php"];
-      root_markers = [".git" "composer.json" ".phpactor.json" ".phpactor.yml"];
-      workspace_required = true;
-    };
-
-    phan = {
-      enable = true;
-      cmd = [
-        (getExe pkgs.php81Packages.phan)
-        "-m"
-        "json"
-        "--no-color"
-        "--no-progress-bar"
-        "-x"
-        "-u"
-        "-S"
-        "--language-server-on-stdin"
-        "--allow-polyfill-parser"
-      ];
-      filetypes = ["php"];
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            local cwd = assert(vim.uv.cwd())
-            local root = vim.fs.root(fname, { 'composer.json', '.git' })
-
-            -- prefer cwd if root is a descendant
-            on_dir(root and vim.fs.relpath(cwd, root) and cwd)
-          end
-        '';
-    };
-
-    intelephense = {
-      enable = true;
-      cmd = [(getExe pkgs.intelephense) "--stdio"];
-      filetypes = ["php"];
-      root_markers = ["composer.json" ".git"];
-    };
-  };
 
   defaultFormat = ["php_cs_fixer"];
   formats = {
@@ -103,7 +56,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.php.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "PHP LSP server to use";
       };
@@ -159,12 +112,13 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["php"];
-        })
+          root_markers = ["composer.json"];
-        cfg.lsp.servers;
+        });
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/python.nix

@@ -7,185 +7,18 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.lists) flatten;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe getExe';
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package bool;
+  inherit (lib.types) enum package bool listOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) deprecatedSingleOrListOf diagnostics;
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.dag) entryBefore;
   inherit (lib.trivial) warn;
 
   cfg = config.vim.languages.python;
 
   defaultServers = ["basedpyright"];
-  servers = {
+  servers = ["pyrefly" "pyright" "basedpyright" "python-lsp-server" "ruff" "ty" "zuban"];
-    pyrefly = {
-      enable = true;
-      cmd = [(getExe pkgs.pyrefly) "lsp"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "pyrefly.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        ".git"
-      ];
-    };
-
-    pyright = {
-      enable = true;
-      cmd = [(getExe' pkgs.pyright "pyright-langserver") "--stdio"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        "pyrightconfig.json"
-        ".git"
-      ];
-      settings = {
-        python = {
-          analysis = {
-            autoSearchPaths = true;
-            useLibraryCodeForTypes = true;
-            diagnosticMode = "openFilesOnly";
-          };
-        };
-      };
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
-            local params = {
-              command = 'pyright.organizeimports',
-              arguments = { vim.uri_from_bufnr(bufnr) },
-            }
-
-            -- Using client.request() directly because "pyright.organizeimports" is private
-            -- (not advertised via capabilities), which client:exec_cmd() refuses to call.
-            -- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
-            client.request('workspace/executeCommand', params, nil, bufnr)
-          end, {
-            desc = 'Organize Imports',
-          })
-          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', set_python_path, {
-            desc = 'Reconfigure basedpyright with the provided python path',
-            nargs = 1,
-            complete = 'file',
-          })
-        end
-      '';
-    };
-
-    basedpyright = {
-      enable = true;
-      cmd = [(getExe' pkgs.basedpyright "basedpyright-langserver") "--stdio"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        "pyrightconfig.json"
-        ".git"
-      ];
-      settings = {
-        basedpyright = {
-          analysis = {
-            autoSearchPaths = true;
-            useLibraryCodeForTypes = true;
-            diagnosticMode = "openFilesOnly";
-          };
-        };
-      };
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
-            local params = {
-              command = 'basedpyright.organizeimports',
-              arguments = { vim.uri_from_bufnr(bufnr) },
-            }
-
-            -- Using client.request() directly because "basedpyright.organizeimports" is private
-            -- (not advertised via capabilities), which client:exec_cmd() refuses to call.
-            -- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
-            client.request('workspace/executeCommand', params, nil, bufnr)
-          end, {
-            desc = 'Organize Imports',
-          })
-
-          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', set_python_path, {
-            desc = 'Reconfigure basedpyright with the provided python path',
-            nargs = 1,
-            complete = 'file',
-          })
-        end
-      '';
-    };
-
-    python-lsp-server = {
-      enable = true;
-      cmd = [(getExe pkgs.python3Packages.python-lsp-server)];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        ".git"
-      ];
-    };
-
-    ruff = {
-      enable = true;
-      cmd = [(getExe pkgs.ruff) "server"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        ".git"
-      ];
-    };
-
-    ty = {
-      enable = true;
-      cmd = [(getExe pkgs.ty) "server"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        ".git"
-      ];
-    };
-
-    zuban = {
-      enable = true;
-      cmd = [(getExe pkgs.zuban) "server"];
-      filetypes = ["python"];
-      root_markers = [
-        "pyproject.toml"
-        "setup.py"
-        "setup.cfg"
-        "requirements.txt"
-        "Pipfile"
-        ".git"
-        "mypy.ini"
-        ".mypy.ini"
-      ];
-    };
-  };
 
   defaultFormat = ["black"];
   formats = {
@@ -313,7 +146,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.python.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Python LSP server to use";
       };
@@ -382,35 +215,19 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.luaConfigRC.python-util =
+      vim.lsp = {
-        entryBefore ["lsp-servers"]
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-        /*
+        servers = genAttrs cfg.lsp.servers (_: {
-        lua
+          filetypes = ["python"];
-        */
+          root_markers = [
-        ''
+            "Pipfile"
-          local function set_python_path(server_name, command)
+            "pyproject.toml"
-            local path = command.args
+            "requirements.txt"
-            local clients = vim.lsp.get_clients {
+            "setup.cfg"
-              bufnr = vim.api.nvim_get_current_buf(),
+            "setup.py"
-              name = server_name,
+          ];
-            }
+        });
-            for _, client in ipairs(clients) do
+      };
-              if client.settings then
-                client.settings.python = vim.tbl_deep_extend('force', client.settings.python or {}, { pythonPath = path })
-              else
-                client.config.settings = vim.tbl_deep_extend('force', client.config.settings, { python = { pythonPath = path } })
-              end
-              client:notify('workspace/didChangeConfiguration', { settings = nil })
-            end
-          end
-        '';
-
-      vim.lsp.servers =
-        mapListToAttrs (n: {
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/qml.nix

@@ -5,10 +5,10 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.meta) getExe';
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib) genAttrs;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -17,13 +17,7 @@
   qmlPackage = pkgs.kdePackages.qtdeclarative;
 
   defaultServers = ["qmlls"];
-  servers = {
+  servers = ["qmlls"];
-    qmlls = {
-      cmd = [(getExe' qmlPackage "qmlls")];
-      filetypes = ["qml" "qmljs"];
-      rootmarkers = [".git"];
-    };
-  };
 
   defaultFormat = ["qmlformat"];
   formats = {
@@ -54,7 +48,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.qml.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "QML LSP server to use";
       };
@@ -83,13 +77,14 @@ in {
         grammars = [cfg.treesitter.package];
       };
     })
+
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["qml" "qmljs"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf (cfg.format.enable && !cfg.lsp.enable) {

modules/plugins/languages/r.nix

@@ -7,18 +7,13 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.r;
 
-  r-with-languageserver = pkgs.rWrapper.override {
-    packages = [pkgs.rPackages.languageserver];
-  };
-
   defaultFormat = ["format_r"];
   formats = {
     styler = {
@@ -47,19 +42,8 @@
     };
   };
 
-  defaultServers = ["r_language_server"];
+  defaultServers = ["r-languageserver"];
-  servers = {
+  servers = ["r-languageserver"];
-    r_language_server = {
-      enable = true;
-      cmd = [(getExe r-with-languageserver) "--no-echo" "-e" "languageserver::run()"];
-      filetypes = ["r" "rmd" "quarto"];
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          on_dir(vim.fs.root(bufnr, '.git') or vim.uv.os_homedir())
-        end
-      '';
-    };
-  };
 in {
   options.vim.languages.r = {
     enable = mkEnableOption "R language support";
@@ -83,7 +67,12 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.r.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.r.lsp.servers"
+          servers
+          {
+            r_language_server = "r-languageserver";
+          });
         default = defaultServers;
         description = "R LSP server to use";
       };
@@ -127,12 +116,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["r" "rmd" "quarto"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/ruby.nix

@@ -6,46 +6,17 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf enumWithRename;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.ruby;
 
   defaultServers = ["solargraph"];
-  servers = {
+  servers = ["ruby-lsp" "solargraph"];
-    ruby_lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.ruby-lsp)];
-      filetypes = ["ruby" "eruby"];
-      root_markers = ["Gemfile" ".git"];
-      init_options = {
-        formatter = "auto";
-      };
-    };
-
-    solargraph = {
-      enable = true;
-      cmd = [(getExe pkgs.rubyPackages.solargraph) "stdio"];
-      filetypes = ["ruby"];
-      root_markers = ["Gemfile" ".git"];
-      settings = {
-        solargraph = {
-          diagnostics = true;
-        };
-      };
-
-      flags = {
-        debounce_text_changes = 150;
-      };
-
-      init_options = {
-        formatting = true;
-      };
-    };
-  };
 
   # testing
 
@@ -85,7 +56,12 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.ruby.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.ruby.lsp.servers"
+          servers
+          {
+            ruby_lsp = "ruby-lsp";
+          });
         default = defaultServers;
         description = "Ruby LSP server to use";
       };
@@ -121,12 +97,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["ruby" "eruby"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/sql.nix

@@ -6,33 +6,19 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package str;
+  inherit (lib.types) enum package str listOf;
   inherit (lib.nvim.types) diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.sql;
   sqlfluffDefault = pkgs.sqlfluff;
   sqruffDefault = pkgs.sqruff;
 
   defaultServers = ["sqls"];
-  servers = {
+  servers = ["sqls"];
-    sqls = {
-      enable = true;
-      cmd = [(getExe pkgs.sqls)];
-      filetypes = ["sql" "mysql"];
-      root_markers = ["config.yml"];
-      settings = {};
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          client.server_capabilities.execute_command = true
-          require'sqls'.setup{}
-        end
-      '';
-    };
-  };
 
   defaultFormat = ["sqlfluff"];
   formats = {
@@ -97,7 +83,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.sql.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "SQL LSP server to use";
       };
@@ -142,14 +128,12 @@ in {
 
     (mkIf cfg.lsp.enable {
       vim = {
-        startPlugins = ["sqls-nvim"];
+        lsp = {
-
+          presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-        lsp.servers =
+          servers = genAttrs cfg.lsp.servers (_: {
-          mapListToAttrs (n: {
+            filetypes = ["sql" "mysql" "msql" "plsql"];
-            name = n;
+          });
-            value = servers.${n};
+        };
-          })
-          cfg.lsp.servers;
       };
     })
 

modules/plugins/languages/svelte.nix

@@ -8,51 +8,16 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum coercedTo;
+  inherit (lib.types) enum coercedTo listOf;
   inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.svelte;
 
-  defaultServers = ["svelte"];
+  defaultServers = ["svelte-language-server"];
-  servers = {
+  servers = ["svelte-language-server"];
-    svelte = {
-      enable = true;
-      cmd = [(getExe pkgs.svelte-language-server) "--stdio"];
-      filetypes = ["svelte"];
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          local root_files = { 'package.json', '.git' }
-          local fname = vim.api.nvim_buf_get_name(bufnr)
-          -- Svelte LSP only supports file:// schema. https://github.com/sveltejs/language-tools/issues/2777
-          if vim.uv.fs_stat(fname) ~= nil then
-            on_dir(vim.fs.dirname(vim.fs.find(root_files, { path = fname, upward = true })[1]))
-          end
-        end
-      '';
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          vim.api.nvim_create_autocmd('BufWritePost', {
-            pattern = { '*.js', '*.ts' },
-            group = vim.api.nvim_create_augroup('svelte_js_ts_file_watch', {}),
-            callback = function(ctx)
-              -- internal API to sync changes that have not yet been saved to the file system
-              client:notify('$/onDidChangeTsOrJsFile', { uri = ctx.match })
-            end,
-          })
-
-          vim.api.nvim_buf_create_user_command(bufnr, 'LspMigrateToSvelte5', function()
-            client:exec_cmd({
-              command = 'migrate_to_svelte_5',
-              arguments = { vim.uri_from_bufnr(bufnr) },
-            })
-          end, { desc = 'Migrate Component to Svelte 5 Syntax' })
-        end
-      '';
-    };
-  };
 
   defaultFormat = ["prettier"];
   formats = let
@@ -123,7 +88,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.svelte.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Svelte LSP server to use";
       };
@@ -167,12 +132,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["svelte"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/terraform.nix

@@ -7,28 +7,16 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption enumWithRename;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.terraform;
 
-  defaultServers = ["tofuls-tf"];
+  defaultServers = ["tofu-ls"];
-  servers = {
+  servers = ["terraform-ls" "tofu-ls"];
-    terraformls-tf = {
-      enable = true;
-      cmd = [(getExe pkgs.terraform-ls) "serve"];
-      filetypes = ["terraform" "terraform-vars" "tf"];
-      root_markers = [".terraform" ".git"];
-    };
-    tofuls-tf = {
-      enable = true;
-      cmd = [(getExe pkgs.tofu-ls) "serve"];
-      filetypes = ["terraform" "terraform-vars" "tf"];
-      root_markers = [".terraform" ".git"];
-    };
-  };
 
   defaultFormat = ["tofu-fmt"];
   formats = {
@@ -65,7 +53,13 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.terraform.lsp.servers"
+          servers
+          {
+            terraformls-tf = "terraform-ls";
+            tofuls-tf = "tofu-ls";
+          });
         default = defaultServers;
         description = "Terraform LSP server to use";
       };
@@ -93,13 +87,11 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim = {
+      vim.lsp = {
-        lsp.servers =
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          mapListToAttrs (n: {
+        servers = genAttrs cfg.lsp.servers (_: {
-            name = n;
+          filetypes = ["terraform" "terraform-vars" "tf"];
-            value = servers.${n};
+        });
-          })
-          cfg.lsp.servers;
       };
     })
 

modules/plugins/languages/tex.nix

@@ -5,6 +5,7 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
@@ -14,14 +15,7 @@
 
   cfg = config.vim.languages.tex;
   defaultServers = ["texlab"];
-  servers = {
+  servers = ["texlab"];
-    texlab = {
-      enable = true;
-      cmd = [(getExe pkgs.texlab) "run"];
-      filetypes = ["plaintex" "tex" "bib"];
-      root_markers = [".git" ".latexmkrc" "latexmkrc" ".texlabroot" "texlabroot" ".texstudio" "Tectonic.toml"];
-    };
-  };
 
   defaultFormat = ["tex-fmt"];
   formats = {
@@ -57,7 +51,7 @@ in {
 
       servers = mkOption {
         description = "TeX LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
       };
     };
@@ -88,12 +82,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["plaintex" "tex" "bib"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/toml.nix

@@ -5,41 +5,17 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.toml;
   defaultServers = ["taplo"];
-  servers = {
+  servers = ["taplo" "tombi"];
-    tombi = {
-      enable = true;
-      cmd = [
-        (getExe pkgs.tombi)
-        "lsp"
-      ];
-      filetypes = ["toml"];
-      root_markers = [
-        "tombi.toml"
-        ".git"
-      ];
-    };
-    taplo = {
-      enable = true;
-      cmd = [
-        (getExe pkgs.taplo)
-        "lsp"
-        "stdio"
-      ];
-      filetypes = ["toml"];
-      root_markers = [
-        ".git"
-      ];
-    };
-  };
 
   defaultFormat = ["taplo"];
   formats = {
@@ -93,7 +69,7 @@ in {
 
       servers = mkOption {
         description = "TOML LSP server to use";
-        type = deprecatedSingleOrListOf "vim.language.toml.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
       };
     };
@@ -137,12 +113,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["toml"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/ts.nix

@@ -7,183 +7,18 @@
   inherit (builtins) attrNames elem;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum package bool;
+  inherit (lib.types) enum bool listOf;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption deprecatedSingleOrListOf enumWithRename;
-  inherit (lib.nvim.dag) entryAnywhere entryBefore;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.languages.ts;
 
-  defaultServers = ["ts_ls"];
+  defaultServers = ["typescript-language-server"];
-  servers = let
+  servers = ["typescript-language-server" "deno" "typescript-go"];
-    ts_ls = {
-      cmd = [(getExe pkgs.typescript-language-server) "--stdio"];
-      init_options = {hostInfo = "neovim";};
-      filetypes = [
-        "javascript"
-        "javascriptreact"
-        "javascript.jsx"
-        "typescript"
-        "typescriptreact"
-        "typescript.tsx"
-      ];
-      root_markers = ["tsconfig.json" "jsconfig.json" "package.json" ".git"];
-      handlers = {
-        # handle rename request for certain code actions like extracting functions / types
-        "_typescript.rename" = mkLuaInline ''
-          function(_, result, ctx)
-            local client = assert(vim.lsp.get_client_by_id(ctx.client_id))
-            vim.lsp.util.show_document({
-              uri = result.textDocument.uri,
-              range = {
-                start = result.position,
-                ['end'] = result.position,
-              },
-            }, client.offset_encoding)
-            vim.lsp.buf.rename()
-            return vim.NIL
-          end
-        '';
-      };
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          -- ts_ls provides `source.*` code actions that apply to the whole file. These only appear in
-          -- `vim.lsp.buf.code_action()` if specified in `context.only`.
-          vim.api.nvim_buf_create_user_command(0, 'LspTypescriptSourceAction', function()
-            local source_actions = vim.tbl_filter(function(action)
-              return vim.startswith(action, 'source.')
-            end, client.server_capabilities.codeActionProvider.codeActionKinds)
-
-            vim.lsp.buf.code_action({
-              context = {
-                only = source_actions,
-              },
-            })
-          end, {})
-        end
-      '';
-    };
-  in {
-    inherit ts_ls;
-    # Here for backwards compatibility. Still consider tsserver a valid
-    # configuration in the enum, but assert if it's set to *properly*
-    # redirect the user to the correct server.
-    tsserver = ts_ls;
-
-    denols = {
-      cmd = [(getExe pkgs.deno) "lsp"];
-      cmd_env = {NO_COLOR = true;};
-      filetypes = [
-        "javascript"
-        "javascriptreact"
-        "javascript.jsx"
-        "typescript"
-        "typescriptreact"
-        "typescript.tsx"
-      ];
-      root_markers = ["deno.json" "deno.jsonc" ".git"];
-      settings = {
-        deno = {
-          enable = true;
-          suggest = {
-            imports = {
-              hosts = {
-                "https://deno.land" = true;
-              };
-            };
-          };
-        };
-      };
-      handlers = {
-        "textDocument/definition" = mkLuaInline "nvf_denols_handler";
-        "textDocument/typeDefinition" = mkLuaInline "nvf_denols_handler";
-        "textDocument/references" = mkLuaInline "nvf_denols_handler";
-      };
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          vim.api.nvim_buf_create_user_command(0, 'LspDenolsCache', function()
-            client:exec_cmd({
-              command = 'deno.cache',
-              arguments = { {}, vim.uri_from_bufnr(bufnr) },
-            }, { bufnr = bufnr }, function(err, _result, ctx)
-              if err then
-                local uri = ctx.params.arguments[2]
-                vim.api.nvim_err_writeln('cache command failed for ' .. vim.uri_to_fname(uri))
-              end
-            end)
-          end, {
-            desc = 'Cache a module and all of its dependencies.',
-          })
-        end
-      '';
-    };
-
-    tsgo = {
-      cmd = [(getExe pkgs.typescript-go) "--lsp" "--stdio"];
-      filetypes = [
-        "javascript"
-        "javascriptreact"
-        "javascript.jsx"
-        "typescript"
-        "typescriptreact"
-        "typescript.tsx"
-      ];
-      root_markers = ["tsconfig.json" "jsconfig.json" "package.json" ".git"];
-    };
-  };
-
-  denols_handlers = ''
-    local function nvf_denols_virtual_text_document_handler(uri, res, client)
-      if not res then
-        return nil
-      end
-
-      local lines = vim.split(res.result, '\n')
-      local bufnr = vim.uri_to_bufnr(uri)
-
-      local current_buf = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
-      if #current_buf ~= 0 then
-        return nil
-      end
-
-      vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
-      vim.api.nvim_set_option_value('readonly', true, { buf = bufnr })
-      vim.api.nvim_set_option_value('modified', false, { buf = bufnr })
-      vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
-      vim.lsp.buf_attach_client(bufnr, client.id)
-    end
-
-    local function nvf_denols_virtual_text_document(uri, client)
-      local params = {
-        textDocument = {
-          uri = uri,
-        },
-      }
-      local result = client.request_sync('deno/virtualTextDocument', params)
-      nvf_denols_virtual_text_document_handler(uri, result, client)
-    end
-
-    local function nvf_denols_handler(err, result, ctx, config)
-      if not result or vim.tbl_isempty(result) then
-        return nil
-      end
-
-      local client = vim.lsp.get_client_by_id(ctx.client_id)
-      for _, res in pairs(result) do
-        local uri = res.uri or res.targetUri
-        if uri:match '^deno:' then
-          nvf_denols_virtual_text_document(uri, client)
-          res['uri'] = uri
-          res['targetUri'] = uri
-        end
-      end
-
-      vim.lsp.handlers[ctx.method](err, result, ctx, config)
-    end
-  '';
 
   # TODO: specify packages
   defaultFormat = ["prettier"];
@@ -264,7 +99,14 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.ts.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.ts.lsp.servers"
+          servers
+          {
+            ts_ls = "typescript-language-server";
+            denols = "deno";
+            tsgo = "typescript-go";
+          });
         default = defaultServers;
         description = "Typescript/Javascript LSP server to use";
       };
@@ -317,6 +159,8 @@ in {
   };
 
   config = mkIf cfg.enable (mkMerge [
+    {vim.globals.markdown_fenced_languages = ["ts=typescript"];}
+
     (mkIf cfg.treesitter.enable {
       vim.treesitter.enable = true;
       vim.treesitter.grammars = [
@@ -327,17 +171,22 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          root_markers = ["tsconfig.json"];
-        })
+          filetypes = [
-        cfg.lsp.servers;
+            "typescript"
-    })
+            # TODO: move to a React module
-
+            "typescriptreact"
-    (mkIf (cfg.lsp.enable && elem "denols" cfg.lsp.servers) {
+            "typescript.tsx"
-      vim.globals.markdown_fenced_languages = ["ts=typescript"];
+            "javascriptreact"
-      vim.luaConfigRC.denols_handlers = entryBefore ["lsp-servers"] denols_handlers;
+            "javascript.jsx"
+            # TODO: move to a JavaScript module
+            "javascript"
+          ];
+        });
+      };
     })
 
     (mkIf cfg.format.enable {
@@ -380,21 +229,20 @@ in {
       '';
     })
 
-    # Warn the user if they have set the default server name to tsserver to match upstream (us)
+    # Warn the user if they have set the default server name to "tsserver" to match upstream (us)
-    # The name "tsserver" has been deprecated in lspconfig, and now should be called ts_ls. This
+    # The name "tsserver" has been deprecated, and now should be called "typescript-language-server".
-    # is a purely cosmetic change, but emits a warning if not accounted for.
     {
       assertions = [
         {
           assertion = cfg.lsp.enable -> !(elem "tsserver" cfg.lsp.servers);
           message = ''
-            As of a recent lspconfig update, the `tsserver` configuration has been renamed
+            The name `tsserver` has been deprecated, and now should be called `typescript-language-server`.
-            to `ts_ls` to match upstream behaviour of `lspconfig`, and the name `tsserver`
+            Please set `vim.languages.ts.lsp.server` to `["typescript-language-server" ...]` instead of to `["tsserver" ...]`
-            is no longer considered valid by nvf. Please set `vim.languages.ts.lsp.server`
-            to `"ts_ls"` instead of to `${cfg.lsp.server}`
 
-            Please see <https://github.com/neovim/nvim-lspconfig/pull/3232> for more details
+            Please see:
-            about this change.
+            - <https://github.com/neovim/nvim-lspconfig/pull/3232>
+            - <https://github.com/NotAShelf/nvf/pull/1514>
+            for more details about this change.
           '';
         }
       ];

modules/plugins/languages/twig.nix

@@ -7,6 +7,7 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.types) listOf enum;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
@@ -15,14 +16,7 @@
   cfg = config.vim.languages.twig;
 
   defaultServers = ["twig-language-server"];
-  servers = {
+  servers = ["twig-language-server"];
-    twig-language-server = {
-      enable = true;
-      cmd = [(getExe pkgs.twig-language-server) "--stdio"];
-      filetypes = ["twig"];
-      root_markers = [".git"];
-    };
-  };
 
   defaultFormat = ["djlint"];
   formats = {
@@ -62,7 +56,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Twig LSP server to use";
       };
@@ -104,12 +98,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["twig"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/typst.nix

@@ -6,92 +6,21 @@
 }: let
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) nullOr enum attrsOf listOf package str bool int;
+  inherit (lib.types) nullOr enum attrsOf listOf str bool int;
   inherit (lib.attrsets) attrNames;
+  inherit (lib) genAttrs;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.binds) mkKeymap;
-  inherit (lib.generators) mkLuaInline;
   inherit (config.vim.lib) mkMappingOption;
 
   cfg = config.vim.languages.typst;
 
   defaultServers = ["tinymist"];
-  servers = {
+  servers = ["tinymist"];
-    typst_lsp = {
-      enable = true;
-      cmd = [(getExe pkgs.typst-lsp)];
-      filetypes = ["typst"];
-      root_markers = [".git"];
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
-          client.server_capabilities.semanticTokensProvider = nil
-        end
-      '';
-    };
-
-    tinymist = {
-      enable = true;
-      cmd = [(getExe pkgs.tinymist)];
-      filetypes = ["typst"];
-      root_markers = [".git"];
-      on_attach = mkLuaInline ''
-        function(client, bufnr)
-          local function create_tinymist_command(command_name, client, bufnr)
-            local export_type = command_name:match 'tinymist%.export(%w+)'
-            local info_type = command_name:match 'tinymist%.(%w+)'
-            if info_type and info_type:match '^get' then
-              info_type = info_type:gsub('^get', 'Get')
-            end
-            local cmd_display = export_type or info_type
-            local function run_tinymist_command()
-              local arguments = { vim.api.nvim_buf_get_name(bufnr) }
-              local title_str = export_type and ('Export ' .. cmd_display) or cmd_display
-              local function handler(err, res)
-                if err then
-                  return vim.notify(err.code .. ': ' .. err.message, vim.log.levels.ERROR)
-                end
-                vim.notify(export_type and res or vim.inspect(res), vim.log.levels.INFO)
-              end
-              if vim.fn.has 'nvim-0.11' == 1 then
-                return client:exec_cmd({
-                  title = title_str,
-                  command = command_name,
-                  arguments = arguments,
-                }, { bufnr = bufnr }, handler)
-              else
-                return vim.notify('Tinymist commands require Neovim 0.11+', vim.log.levels.WARN)
-              end
-            end
-            local cmd_name = export_type and ('LspTinymistExport' .. cmd_display) or ('LspTinymist' .. cmd_display)
-            local cmd_desc = export_type and ('Export to ' .. cmd_display) or ('Get ' .. cmd_display)
-            return run_tinymist_command, cmd_name, cmd_desc
-          end
-
-          for _, command in ipairs {
-            'tinymist.exportSvg',
-            'tinymist.exportPng',
-            'tinymist.exportPdf',
-            'tinymist.exportMarkdown',
-            'tinymist.exportText',
-            'tinymist.exportQuery',
-            'tinymist.exportAnsiHighlight',
-            'tinymist.getServerInfo',
-            'tinymist.getDocumentTrace',
-            'tinymist.getWorkspaceLabels',
-            'tinymist.getDocumentMetrics',
-          } do
-            local cmd_func, cmd_name, cmd_desc = create_tinymist_command(command, client, bufnr)
-            vim.api.nvim_buf_create_user_command(bufnr, cmd_name, cmd_func, { nargs = 0, desc = cmd_desc })
-          end
-        end
-      '';
-    };
-  };
 
   defaultFormat = ["typstyle"];
   formats = {
@@ -123,7 +52,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.typst.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Typst LSP server to use";
       };
@@ -261,12 +190,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["typst"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
 
     # Extensions

modules/plugins/languages/vala.nix

@@ -4,64 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.types) enum;
+  inherit (lib.types) listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption enumWithRename;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.vala;
 
-  defaultServers = ["vala_ls"];
+  defaultServers = ["vala-language-server"];
-  servers = {
+  servers = ["vala-language-server"];
-    vala_ls = {
-      enable = true;
-      cmd = [
-        (getExe (pkgs.symlinkJoin {
-          name = "vala-language-server-wrapper";
-          paths = [pkgs.vala-language-server];
-          meta.mainProgram = "vala-language-server-wrapper";
-          buildInputs = [pkgs.makeBinaryWrapper];
-          postBuild = ''
-            wrapProgram $out/bin/vala-language-server \
-              --prefix PATH : ${pkgs.uncrustify}/bin
-          '';
-        }))
-      ];
-      filetypes = ["vala" "genie"];
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          local meson_matcher = function(path)
-            local pattern = 'meson.build'
-            local f = vim.fn.glob(table.concat({ path, pattern }, '/'))
-            if f == ''' then
-              return nil
-            end
-            for line in io.lines(f) do
-              -- skip meson comments
-              if not line:match '^%s*#.*' then
-                local str = line:gsub('%s+', ''')
-                if str ~= ''' then
-                  if str:match '^project%(' then
-                    return path
-                  else
-                    break
-                  end
-                end
-              end
-            end
-          end
-
-          local fname = vim.api.nvim_buf_get_name(bufnr)
-          local root = vim.iter(vim.fs.parents(fname)):find(meson_matcher)
-          on_dir(root or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1]))
-        end
-      '';
-    };
-  };
 in {
   options.vim.languages.vala = {
     enable = mkEnableOption "Vala language support";
@@ -84,7 +36,12 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.vala.lsp.servers" (enum (attrNames servers));
+        type = listOf (enumWithRename
+          "vim.languages.vala.lsp.servers"
+          servers
+          {
+            vala_ls = "vala-language-server";
+          });
         default = defaultServers;
         description = "Vala LSP server to use";
       };
@@ -98,12 +55,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["vala"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/wgsl.nix

@@ -4,26 +4,16 @@
   pkgs,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.wgsl;
 
   defaultServers = ["wgsl-analyzer"];
-  servers = {
+  servers = ["wgsl-analyzer"];
-    wgsl-analyzer = {
-      enable = true;
-      cmd = [(getExe pkgs.wgsl-analyzer)];
-      filetypes = ["wgsl"];
-      root_markers = [".git"];
-      settings = {};
-    };
-  };
 in {
   options.vim.languages.wgsl = {
     enable = mkEnableOption "WGSL language support";
@@ -47,7 +37,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.wgsl.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "WGSL LSP server to use";
       };
@@ -63,12 +53,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["wgsl"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/xml.nix

@@ -4,27 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib) genAttrs;
 
   cfg = config.vim.languages.xml;
 
   defaultServers = ["lemminx"];
-  servers = {
+  servers = ["lemminx"];
-    lemminx = {
-      enable = true;
-      cmd = [
-        (getExe pkgs.lemminx)
-      ];
-      filetypes = ["xml"];
-      root_markers = [".git"];
-    };
-  };
 in {
   options.vim.languages.xml = {
     enable = mkEnableOption "XML language support";
@@ -47,7 +36,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "XML LSP server to use";
       };
@@ -61,12 +50,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (name: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          inherit name;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${name};
+          filetypes = ["xml"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/yaml.nix

@@ -4,48 +4,16 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib) genAttrs;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.yaml;
 
-  on_attach =
-    if config.vim.languages.helm.lsp.enable && config.vim.languages.helm.enable
-    then
-      mkLuaInline ''
-        function(client, bufnr)
-          local filetype = vim.bo[bufnr].filetype
-          if filetype == "helm" then
-            client.stop()
-          end
-        end
-      ''
-    else null;
-
   defaultServers = ["yaml-language-server"];
-  servers = {
+  servers = ["yaml-language-server"];
-    yaml-language-server = {
-      enable = true;
-      cmd = [(getExe pkgs.yaml-language-server) "--stdio"];
-      filetypes = ["yaml" "yaml.docker-compose" "yaml.gitlab" "yaml.helm-values"];
-      root_markers = [".git"];
-      inherit on_attach;
-      # -- https://github.com/redhat-developer/vscode-redhat-telemetry#how-to-disable-telemetry-reporting
-      settings = {
-        redhat = {
-          telemetry = {
-            enabled = false;
-          };
-        };
-      };
-    };
-  };
 in {
   options.vim.languages.yaml = {
     enable = mkEnableOption "YAML language support";
@@ -69,7 +37,7 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.yaml.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Yaml LSP server to use";
       };
@@ -83,12 +51,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp = {
-        mapListToAttrs (n: {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-          name = n;
+        servers = genAttrs cfg.lsp.servers (_: {
-          value = servers.${n};
+          filetypes = ["yaml"];
-        })
+        });
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/zig.nix

@@ -7,23 +7,14 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge mkDefault;
-  inherit (lib.types) bool package enum;
+  inherit (lib) genAttrs;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.types) bool package enum listOf;
-  inherit (lib.meta) getExe;
+  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.zig;
 
   defaultServers = ["zls"];
-  servers = {
+  servers = ["zls"];
-    zls = {
-      enable = true;
-      cmd = [(getExe pkgs.zls)];
-      filetypes = ["zig" "zir"];
-      root_markers = ["zls.json" "build.zig" ".git"];
-      workspace_required = false;
-    };
-  };
 
   # TODO: dap.adapter.lldb is duplicated when enabling the
   # vim.languages.clang.dap module. This does not cause
@@ -77,7 +68,7 @@ in {
         };
 
       servers = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.zig.lsp.servers" (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Zig LSP server to use";
       };
@@ -115,13 +106,13 @@ in {
 
     (mkIf cfg.lsp.enable {
       vim = {
-        lsp.servers =
+        lsp = {
-          mapListToAttrs (n: {
+          presets = genAttrs cfg.lsp.servers (_: {enable = true;});
-            name = n;
+          servers = genAttrs cfg.lsp.servers (_: {
-            value = servers.${n};
+            root_markers = ["build.zig"];
-          })
+            filetypes = ["zig" "zir"];
-          cfg.lsp.servers;
+          });
-
+        };
         # nvf handles autosaving already
         globals.zig_fmt_autosave = mkDefault 0;
       };

modules/plugins/lsp/default.nix

@@ -4,10 +4,11 @@
     ./config.nix
     ./module.nix
 
+    ./presets
+
     ./lspconfig
     ./lspsaga
     ./null-ls
-    ./harper-ls
 
     # lsp plugins
     ./lspsaga

modules/plugins/lsp/harper-ls/config.nix

@@ -1,57 +0,0 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.meta) getExe;
-
-  cfg = config.vim.lsp;
-in {
-  config = mkIf (cfg.enable && cfg.harper-ls.enable) {
-    vim.lsp.servers.harper-ls = {
-      root_markers = [".git" ".harper-dictionary.txt"];
-      cmd = [(getExe pkgs.harper) "--stdio"];
-      settings = {harper-ls = cfg.harper-ls.settings;};
-      filetypes =
-        # <https://writewithharper.com/docs/integrations/language-server#Supported-Languages>
-        [
-          "asciidoc"
-          "c"
-          "clojure"
-          "cmake"
-          "cpp"
-          "cs"
-          "daml"
-          "dart"
-          "gitcommit"
-          "go"
-          "haskell"
-          "html"
-          "ink"
-          "java"
-          "javascript"
-          "javascriptreact"
-          "kotlin"
-          "lhaskell"
-          "lua"
-          "mail"
-          "markdown"
-          "nix"
-          "php"
-          "python"
-          "ruby"
-          "rust"
-          "scala"
-          "sh"
-          "swift"
-          "text"
-          "toml"
-          "typescript"
-          "typescriptreact"
-          "typst"
-        ];
-    };
-  };
-}

modules/plugins/lsp/harper-ls/default.nix

@@ -1,6 +0,0 @@
-{
-  imports = [
-    ./harper-ls.nix
-    ./config.nix
-  ];
-}

modules/plugins/lsp/harper-ls/harper-ls.nix

@@ -1,35 +0,0 @@
-{lib, ...}: let
-  inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.types) anything attrsOf;
-in {
-  options.vim.lsp.harper-ls = {
-    enable = mkEnableOption "Harper grammar checking LSP";
-    settings = mkOption {
-      type = attrsOf anything;
-      default = {};
-      example = {
-        userDictPath = "";
-        workspaceDictPath = "";
-        fileDictPath = "";
-        linters = {
-          BoringWords = true;
-          PossessiveNoun = true;
-          SentenceCapitalization = false;
-          SpellCheck = false;
-        };
-        codeActions = {
-          ForceStable = false;
-        };
-        markdown = {
-          IgnoreLinkTitle = false;
-        };
-        diagnosticSeverity = "hint";
-        isolateEnglish = false;
-        dialect = "American";
-        maxFileLength = 120000;
-        ignoredLintsPath = {};
-      };
-      description = "Settings to pass to harper-ls";
-    };
-  };
-}

modules/plugins/lsp/presets/arduino-language-server.nix

@@ -0,0 +1,46 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe getExe';
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.arduino-language-server;
+in {
+  options.vim.lsp.presets.arduino-language-server = {
+    enable = mkLspPresetEnableOption "arduino-language-server" "Arduino" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.arduino-language-server = {
+      enable = true;
+      cmd = [
+        (getExe pkgs.arduino-language-server)
+        "-clangd"
+        (getExe' pkgs.clang-tools "clangd")
+        "-cli"
+        (getExe pkgs.arduino-cli)
+        "-cli-config"
+        "$HOME/.arduino15/arduino-cli.yaml"
+      ];
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+          on_dir(util.root_pattern("*.ino")(fname))
+        end
+      '';
+      capabilities = {
+        textDocument = {
+          semanticTokens = mkLuaInline "vim.NIL";
+        };
+        workspace = {
+          semanticTokens = mkLuaInline "vim.NIL";
+        };
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/asm-lsp.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.asm-lsp;
+in {
+  options.vim.lsp.presets.asm-lsp = {
+    enable = mkLspPresetEnableOption "asm-lsp" "Assembly" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.asm-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.asm-lsp)];
+      root_markers = [".git" ".asm-lsp.toml"];
+    };
+  };
+}

modules/plugins/lsp/presets/astro-language-server.nix

@@ -0,0 +1,35 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.astro-language-server;
+in {
+  options.vim.lsp.presets.astro-language-server = {
+    enable = mkLspPresetEnableOption "astro-language-server" "Astro" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.astro-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.astro-language-server) "--stdio"];
+      root_markers = [".git" "package.json" "tsconfig.json" "jsconfig.json"];
+      init_options = {
+        typescript = {};
+      };
+      before_init = mkLuaInline ''
+        function(_, config)
+          if config.init_options and config.init_options.typescript and not config.init_options.typescript.tsdk then
+            config.init_options.typescript.tsdk = util.get_typescript_server_path(config.root_dir)
+          end
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/basedpyright.nix

@@ -0,0 +1,77 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe';
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryBefore;
+
+  cfg = config.vim.lsp.presets.basedpyright;
+in {
+  options.vim.lsp.presets.basedpyright = {
+    enable = mkLspPresetEnableOption "basedpyright" "Based Pyright" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim = {
+      lsp.servers.basedpyright = {
+        enable = true;
+        cmd = [(getExe' pkgs.basedpyright "basedpyright-langserver") "--stdio"];
+        root_markers = [".git" "pyrightconfig.json"];
+        settings = {
+          basedpyright = {
+            analysis = {
+              autoSearchPaths = true;
+              useLibraryCodeForTypes = true;
+              diagnosticMode = "openFilesOnly";
+            };
+          };
+        };
+        on_attach = mkLuaInline ''
+          function(client, bufnr)
+            vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
+              local params = {
+                command = 'basedpyright.organizeimports',
+                arguments = { vim.uri_from_bufnr(bufnr) },
+              }
+
+              -- Using client.request() directly because "basedpyright.organizeimports" is private
+              -- (not advertised via capabilities), which client:exec_cmd() refuses to call.
+              -- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
+              client.request('workspace/executeCommand', params, nil, bufnr)
+            end, {
+              desc = 'Organize Imports',
+            })
+
+            vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', basedpyright_set_python_path, {
+              desc = 'Reconfigure basedpyright with the provided python path',
+              nargs = 1,
+              complete = 'file',
+            })
+          end
+        '';
+      };
+      luaConfigRC.basedpyright-util = entryBefore ["lsp-servers"] ''
+        local function basedpyright_set_python_path(server_name, command)
+          local path = command.args
+          local clients = vim.lsp.get_clients {
+            bufnr = vim.api.nvim_get_current_buf(),
+            name = server_name,
+          }
+          for _, client in ipairs(clients) do
+            if client.settings then
+              client.settings.python = vim.tbl_deep_extend('force', client.settings.python or {}, { pythonPath = path })
+            else
+              client.config.settings = vim.tbl_deep_extend('force', client.config.settings, { python = { pythonPath = path } })
+            end
+            client:notify('workspace/didChangeConfiguration', { settings = nil })
+          end
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/bash-language-server.nix

@@ -0,0 +1,30 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.bash-language-server;
+in {
+  options.vim.lsp.presets.bash-language-server = {
+    enable = mkLspPresetEnableOption "bash-language-server" "Bash" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.bash-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.bash-language-server) "start"];
+      root_markers = [".git"];
+      settings = {
+        basheIde = {
+          globPattern = mkLuaInline "vim.env.GLOB_PATTERN or '*@(.sh|.inc|.bash|.command)'";
+        };
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/ccls.nix

@@ -0,0 +1,54 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.ccls;
+in {
+  options.vim.lsp.presets.ccls = {
+    enable = mkLspPresetEnableOption "ccls" "CC" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.ccls = {
+      enable = true;
+      cmd = [(getExe pkgs.ccls)];
+      offset_encoding = "utf-32";
+      root_markers = [".git" ".ccls" "compile_commands.json"];
+      workspace_required = true;
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          local function switch_source_header(bufnr)
+            local method_name = "textDocument/switchSourceHeader"
+            local params = vim.lsp.util.make_text_document_params(bufnr)
+            client:request(method_name, params, function(err, result)
+              if err then
+                error(tostring(err))
+              end
+              if not result then
+                vim.notify('corresponding file cannot be determined')
+                return
+              end
+              vim.cmd.edit(vim.uri_to_fname(result))
+            end, bufnr)
+          end
+
+          vim.api.nvim_buf_create_user_command(
+            bufnr,
+            "LspCclsSwitchSourceHeader",
+            function(arg)
+              switch_source_header(client, 0)
+            end,
+            {desc = "Switch between source/header"}
+          )
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/clangd.nix

@@ -0,0 +1,107 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe';
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.clangd;
+in {
+  options.vim.lsp.presets.clangd = {
+    enable = mkLspPresetEnableOption "clangd" "Clangd" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.clangd = {
+      enable = true;
+      cmd = [(getExe' pkgs.clang-tools "clangd")];
+      root_markers = [
+        ".git"
+        ".clangd"
+        ".clang-tidy"
+        ".clang-format"
+        "compile_commands.json"
+        "compile_flags.txt"
+        "configure.ac"
+      ];
+      capabilities = {
+        textDocument = {
+          completion = {
+            editsNearCursor = true;
+          };
+        };
+        offsetEncoding = ["utf-8" "utf-16"];
+      };
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          local function switch_source_header(bufnr)
+            local method_name = "textDocument/switchSourceHeader"
+            local client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd", })[1]
+            if not client then
+              return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
+            end
+            local params = vim.lsp.util.make_text_document_params(bufnr)
+            client.request(method_name, params, function(err, result)
+              if err then
+                error(tostring(err))
+              end
+              if not result then
+                vim.notify('corresponding file cannot be determined')
+                return
+              end
+              vim.cmd.edit(vim.uri_to_fname(result))
+            end, bufnr)
+          end
+
+          local function symbol_info()
+            local bufnr = vim.api.nvim_get_current_buf()
+            local clangd_client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd" })[1]
+            if not clangd_client or not clangd_client:supports_method 'textDocument/symbolInfo' then
+              return vim.notify('Clangd client not found', vim.log.levels.ERROR)
+            end
+            local win = vim.api.nvim_get_current_win()
+            local params = vim.lsp.util.make_position_params(win, clangd_client.offset_encoding)
+            clangd_client:request('textDocument/symbolInfo', params, function(err, res)
+              if err or #res == 0 then
+                -- Clangd always returns an error, there is not reason to parse it
+                return
+              end
+              local container = string.format('container: %s', res[1].containerName) ---@type string
+              local name = string.format('name: %s', res[1].name) ---@type string
+              vim.lsp.util.open_floating_preview({ name, container }, "", {
+                height = 2,
+                width = math.max(string.len(name), string.len(container)),
+                focusable = false,
+                focus = false,
+                border = 'single',
+                title = 'Symbol Info',
+              })
+            end, bufnr)
+          end
+
+          vim.api.nvim_buf_create_user_command(
+            bufnr,
+            "ClangdSwitchSourceHeader",
+            function(arg)
+              switch_source_header(0)
+            end,
+            {desc = "Switch between source/header"}
+          )
+
+          vim.api.nvim_buf_create_user_command(
+            bufnr,
+            "ClangdShowSymbolInfo",
+            function(arg)
+              symbol_info()
+            end,
+            {desc = "Show symbol info"}
+          )
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/clojure-lsp.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.clojure-lsp;
+in {
+  options.vim.lsp.presets.clojure-lsp = {
+    enable = mkLspPresetEnableOption "clojure-lsp" "Clojure" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.clojure-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.clojure-lsp)];
+      root_markers = [".git" "project.clj"];
+    };
+  };
+}

modules/plugins/lsp/presets/cue.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.cue;
+in {
+  options.vim.lsp.presets.cue = {
+    enable = mkLspPresetEnableOption "cue" "Cue" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.cue = {
+      enable = true;
+      cmd = [(getExe pkgs.cue) "lsp"];
+      root_markers = [".git" "cue.mod"];
+    };
+  };
+}

modules/plugins/lsp/presets/dart.nix

@@ -0,0 +1,37 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.dart;
+in {
+  options.vim.lsp.presets.dart = {
+    enable = mkLspPresetEnableOption "dart" "Dart" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.dart = {
+      enable = true;
+      cmd = [(getExe pkgs.dart) "language-server" "--protocol=lsp"];
+      root_markers = [".git" "pubspec.yaml"];
+      init_options = {
+        onlyAnalyzeProjectsWithOpenFiles = true;
+        suggestFromUnimportedLibraries = true;
+        closingLabels = true;
+        outline = true;
+        flutterOutline = true;
+      };
+      settings = {
+        dart = {
+          completeFunctionCalls = true;
+          showTodos = true;
+        };
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/default.nix

@@ -0,0 +1,75 @@
+{
+  imports = [
+    ./arduino-language-server.nix
+    ./asm-lsp.nix
+    ./astro-language-server.nix
+    ./basedpyright.nix
+    ./bash-language-server.nix
+    ./ccls.nix
+    ./clangd.nix
+    ./clojure-lsp.nix
+    ./cue.nix
+    ./dart.nix
+    ./deno.nix
+    ./elixir-ls.nix
+    ./elm-language-server.nix
+    ./emmet-ls.nix
+    ./fsautocomplete.nix
+    ./gleam.nix
+    ./glsl_analyzer.nix
+    ./gopls.nix
+    ./harper.nix
+    ./helm-ls.nix
+    ./intelephense.nix
+    ./jdt-language-server.nix
+    ./jinja-lsp.nix
+    ./jq-lsp.nix
+    ./julia-languageserver.nix
+    ./just-lsp.nix
+    ./kotlin-language-server.nix
+    ./lemminx.nix
+    ./lua-language-server.nix
+    ./markdown-oxide.nix
+    ./marksman.nix
+    ./neocmakelsp.nix
+    ./nil.nix
+    ./nimlsp.nix
+    ./nixd.nix
+    ./nushell.nix
+    ./ocaml-lsp.nix
+    ./ols.nix
+    ./openscad-lsp.nix
+    ./phan.nix
+    ./phpactor.nix
+    ./pyrefly.nix
+    ./pyright.nix
+    ./python-lsp-server.nix
+    ./qmlls.nix
+    ./r-languageserver.nix
+    ./ruby-lsp.nix
+    ./ruff.nix
+    ./rumdl.nix
+    ./solargraph.nix
+    ./sqls.nix
+    ./superhtml.nix
+    ./svelte-language-server.nix
+    ./tailwindcss-language-server.nix
+    ./taplo.nix
+    ./terraform-ls.nix
+    ./texlab.nix
+    ./tinymist.nix
+    ./tofu-ls.nix
+    ./tombi.nix
+    ./twig-language-server.nix
+    ./ty.nix
+    ./typescript-go.nix
+    ./typescript-language-server.nix
+    ./vala-language-server.nix
+    ./vscode-css-language-server.nix
+    ./vscode-json-language-server.nix
+    ./wgsl-analyzer.nix
+    ./yaml-language-server.nix
+    ./zls.nix
+    ./zuban.nix
+  ];
+}

modules/plugins/lsp/presets/deno.nix

@@ -0,0 +1,111 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.deno;
+in {
+  options.vim.lsp.presets.deno = {
+    enable = mkLspPresetEnableOption "deno" "Deno" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.deno = {
+      enable = true;
+      cmd = [(getExe pkgs.deno) "lsp"];
+      cmd_env = {NO_COLOR = true;};
+      root_markers = ["deno.json" "deno.jsonc" ".git"];
+      settings = {
+        deno = {
+          enable = true;
+          suggest = {
+            imports = {
+              hosts = {
+                "https://deno.land" = true;
+              };
+            };
+          };
+        };
+      };
+      handlers = let
+        handler = mkLuaInline ''
+          function(err, result, ctx, config)
+
+            local function nvf_denols_virtual_text_document_handler(uri, res, client)
+               if not res then
+                 return nil
+               end
+
+               local lines = vim.split(res.result, '\n')
+               local bufnr = vim.uri_to_bufnr(uri)
+
+               local current_buf = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+               if #current_buf ~= 0 then
+                 return nil
+               end
+
+               vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
+               vim.api.nvim_set_option_value('readonly', true, { buf = bufnr })
+               vim.api.nvim_set_option_value('modified', false, { buf = bufnr })
+               vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
+               vim.lsp.buf_attach_client(bufnr, client.id)
+             end
+
+             local function nvf_denols_virtual_text_document(uri, client)
+               local params = {
+                 textDocument = {
+                   uri = uri,
+                 },
+               }
+               local result = client.request_sync('deno/virtualTextDocument', params)
+               nvf_denols_virtual_text_document_handler(uri, result, client)
+             end
+
+             if not result or vim.tbl_isempty(result) then
+               return nil
+             end
+
+             local client = vim.lsp.get_client_by_id(ctx.client_id)
+             for _, res in pairs(result) do
+               local uri = res.uri or res.targetUri
+               if uri:match '^deno:' then
+                 nvf_denols_virtual_text_document(uri, client)
+                 res['uri'] = uri
+                 res['targetUri'] = uri
+               end
+             end
+
+             vim.lsp.handlers[ctx.method](err, result, ctx, config)
+           end
+        '';
+      in {
+        "textDocument/definition" = handler;
+        "textDocument/typeDefinition" = handler;
+        "textDocument/references" = handler;
+      };
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          vim.api.nvim_buf_create_user_command(0, 'LspDenolsCache', function()
+            client:exec_cmd({
+              command = 'deno.cache',
+              arguments = { {}, vim.uri_from_bufnr(bufnr) },
+            }, { bufnr = bufnr }, function(err, _result, ctx)
+              if err then
+                local uri = ctx.params.arguments[2]
+                vim.api.nvim_err_writeln('cache command failed for ' .. vim.uri_to_fname(uri))
+              end
+            end)
+          end, {
+            desc = 'Cache a module and all of its dependencies.',
+          })
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/elixir-ls.nix

@@ -0,0 +1,34 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.elixir-ls;
+in {
+  options.vim.lsp.presets.elixir-ls = {
+    enable = mkLspPresetEnableOption "elixir-ls" "Elixir" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.elixir-ls = {
+      enable = true;
+      cmd = [(getExe pkgs.elixir-ls)];
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+          local matches = vim.fs.find({ 'mix.exs' }, { upward = true, limit = 2, path = fname })
+          local child_or_root_path, maybe_umbrella_path = unpack(matches)
+          local root_dir = vim.fs.dirname(maybe_umbrella_path or child_or_root_path)
+
+          on_dir(root_dir)
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/elm-language-server.nix

@@ -0,0 +1,25 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.elm-language-server;
+in {
+  options.vim.lsp.presets.elm-language-server = {
+    enable = mkLspPresetEnableOption "elm-language-server" "Elm" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.elm-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.elmPackages.elm-language-server)];
+      root_markers = [".git" "elm.json"];
+      workspace_required = false;
+    };
+  };
+}

modules/plugins/lsp/presets/emmet-ls.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.emmet-ls;
+in {
+  options.vim.lsp.presets.emmet-ls = {
+    enable = mkLspPresetEnableOption "emmet-ls" "Emmet" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.emmet-ls = {
+      enable = true;
+      cmd = [(getExe pkgs.emmet-ls) "--stdio"];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/fsautocomplete.nix

@@ -0,0 +1,54 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.fsautocomplete;
+in {
+  options.vim.lsp.presets.fsautocomplete = {
+    enable = mkLspPresetEnableOption "fsautocomplete" "F# Autocomplete" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.fsautocomplete = {
+      enable = true;
+      cmd = [(getExe pkgs.fsautocomplete) "--adaptive-lsp-server-enabled"];
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          on_dir(vim.fs.root(bufnr, function(name, path)
+            return name == ".git" or name:match("%.sln$") or name:match("%.fsproj$")
+          end))
+        end
+      '';
+      init_options = {
+        AutomaticWorkspaceInit = true;
+      };
+      settings = {
+        FSharp = {
+          keywordsAutocomplete = true;
+          ExternalAutocomplete = false;
+          Linter = true;
+          UnionCaseStubGeneration = true;
+          UnionCaseStubGenerationBody = ''failwith "Not Implemented"'';
+          RecordStubGeneration = true;
+          RecordStubGenerationBody = ''failwith "Not Implemented"'';
+          InterfaceStubGeneration = true;
+          InterfaceStubGenerationObjectIdentifier = "this";
+          InterfaceStubGenerationMethodBody = ''failwith "Not Implemented"'';
+          UnusedOpensAnalyzer = true;
+          UnusedDeclarationsAnalyzer = true;
+          UseSdkScripts = true;
+          SimplifyNameAnalyzer = true;
+          ResolveNamespaces = true;
+          EnableReferenceCodeLens = true;
+        };
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/gleam.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.gleam;
+in {
+  options.vim.lsp.presets.gleam = {
+    enable = mkLspPresetEnableOption "gleam" "Gleam" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.gleam = {
+      enable = true;
+      cmd = [(getExe pkgs.gleam) "lsp"];
+      root_markers = [".git" "gleam.toml"];
+    };
+  };
+}

modules/plugins/lsp/presets/glsl_analyzer.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.glsl_analyzer;
+in {
+  options.vim.lsp.presets.glsl_analyzer = {
+    enable = mkLspPresetEnableOption "glsl_analyzer" "GLSL Analyzer" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.glsl_analyzer = {
+      enable = true;
+      cmd = [(getExe pkgs.glsl_analyzer)];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/gopls.nix

@@ -0,0 +1,59 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.gopls;
+in {
+  options.vim.lsp.presets.gopls = {
+    enable = mkLspPresetEnableOption "gopls" "Go" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.gopls = {
+      enable = true;
+      cmd = [(getExe pkgs.gopls)];
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+
+          local function get_root(fname)
+            if _G.nvf_gopls_mod_cache and fname:sub(1, #_G.nvf_gopls_mod_cache) == _G.nvf_gopls_mod_cache then
+              local clients = vim.lsp.get_clients { name = 'gopls' }
+              if #clients > 0 then
+                return clients[#clients].config.root_dir
+              end
+            end
+            return vim.fs.root(fname, 'go.work') or vim.fs.root(fname, 'go.mod') or vim.fs.root(fname, '.git')
+          end
+
+          -- see: https://github.com/neovim/nvim-lspconfig/issues/804
+          if _G.nvf_gopls_mod_cache then
+            on_dir(get_root(fname))
+            return
+          end
+          local cmd = { 'go', 'env', 'GOMODCACHE' }
+          local ok, err = pcall(vim.system, cmd, { text = true }, function(output)
+            if output.code == 0 then
+              if output.stdout then
+                _G.nvf_gopls_mod_cache = vim.trim(output.stdout)
+              end
+              on_dir(get_root(fname))
+            else
+              vim.schedule(function()
+                vim.notify(('[gopls] cmd failed with code %d: %s\n%s'):format(output.code, cmd, output.stderr))
+              end)
+            end
+          end)
+          if not ok then vim.notify(('[gopls] cmd failed: %s\n%s'):format(cmd, err)) end
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/harper.nix

@@ -0,0 +1,54 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.harper;
+  filetypes = [
+    # <https://writewithharper.com/docs/integrations/language-server#Supported-Languages>
+    "asciidoc"
+    "c"
+    "clojure"
+    "cmake"
+    "cpp"
+    "cs"
+    "daml"
+    "dart"
+    "gitcommit"
+    "go"
+    "haskell"
+    "html"
+    "ink"
+    "java"
+    "javascript"
+    "javascriptreact"
+    "kotlin"
+    "lhaskell"
+    "lua"
+    "mail"
+    "markdown"
+    "nix"
+    "php"
+    "python"
+    "ruby"
+    "rust"
+  ];
+in {
+  options.vim.lsp.presets.harper = {
+    enable = mkLspPresetEnableOption "harper" "Harper" filetypes;
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.harper = {
+      enable = true;
+      cmd = [(getExe pkgs.harper) "--stdio"];
+      root_markers = [".git" ".harper-dictionary.txt"];
+      inherit filetypes;
+    };
+  };
+}

modules/plugins/lsp/presets/helm-ls.nix

@@ -0,0 +1,29 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.helm-ls;
+in {
+  options.vim.lsp.presets.helm-ls = {
+    enable = mkLspPresetEnableOption "helm-ls" "Helm" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.helm-ls = {
+      enable = true;
+      cmd = [(getExe pkgs.helm-ls) "serve"];
+      root_markers = [".git" "Chart.yaml"];
+      capabilities = {
+        didChangeWatchedFiles = {
+          dynamicRegistration = true;
+        };
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/intelephense.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.intelephense;
+in {
+  options.vim.lsp.presets.intelephense = {
+    enable = mkLspPresetEnableOption "intelephense" "Intelephense" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.intelephense = {
+      enable = true;
+      cmd = [(getExe pkgs.intelephense) "--stdio"];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/jdt-language-server.nix

@@ -0,0 +1,136 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryBefore;
+
+  cfg = config.vim.lsp.presets.jdt-language-server;
+in {
+  options.vim.lsp.presets.jdt-language-server = {
+    enable = mkLspPresetEnableOption "jdt-language-server" "Eclipse JDT" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim = {
+      lsp.servers.jdt-language-server = {
+        enable = true;
+        cmd = mkLuaInline ''
+          {
+            '${getExe pkgs.jdt-language-server}',
+            '-configuration',
+            get_jdtls_config_dir(),
+            '-data',
+            get_jdtls_workspace_dir(),
+            get_jdtls_jvm_args(),
+          }
+        '';
+        root_markers = [
+          # Multi-module projects
+          ".git"
+          "build.gradle"
+          "build.gradle.kts"
+          # Single-module projects
+          "build.xml" # Ant
+          "pom.xml" # Maven
+          "settings.gradle" # Gradle
+          "settings.gradle.kts" # Gradle
+        ];
+        init_options = {
+          workspace = mkLuaInline "get_jdtls_workspace_dir()";
+          jvm_args = {};
+          os_config = mkLuaInline "nil";
+        };
+        handlers = {
+          "textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
+          "textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
+          "workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
+          "language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
+        };
+      };
+      luaConfigRC.jdtls-util = entryBefore ["lsp-servers"] ''
+        local jdtls_handlers = require 'vim.lsp.handlers'
+
+        local jdtls_env = {
+          HOME = vim.uv.os_homedir(),
+          XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
+          JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
+        }
+
+        local function get_cache_dir()
+          return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
+        end
+
+        local function get_jdtls_cache_dir()
+          return get_cache_dir() .. '/jdtls'
+        end
+
+        local function get_jdtls_config_dir()
+          return get_jdtls_cache_dir() .. '/config'
+        end
+
+        local function get_jdtls_workspace_dir()
+          return get_jdtls_cache_dir() .. '/workspace'
+        end
+
+        local function get_jdtls_jvm_args()
+          local args = {}
+          for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
+            local arg = string.format('--jvm-arg=%s', a)
+            table.insert(args, arg)
+          end
+          return unpack(args)
+        end
+
+        -- TextDocument version is reported as 0, override with nil so that
+        -- the client doesn't think the document is newer and refuses to update
+        -- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
+        local function jdtls_fix_zero_version(workspace_edit)
+          if workspace_edit and workspace_edit.documentChanges then
+            for _, change in pairs(workspace_edit.documentChanges) do
+              local text_document = change.textDocument
+              if text_document and text_document.version and text_document.version == 0 then
+                text_document.version = nil
+              end
+            end
+          end
+          return workspace_edit
+        end
+
+        local function jdtls_on_textdocument_codeaction(err, actions, ctx)
+          for _, action in ipairs(actions) do
+            -- TODO: (steelsojka) Handle more than one edit?
+            if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
+              action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
+            elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
+              action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
+            end
+          end
+
+          jdtls_handlers[ctx.method](err, actions, ctx)
+        end
+
+        local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
+          jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+        end
+
+        local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
+          jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+        end
+
+        -- Non-standard notification that can be used to display progress
+        local function jdtls_on_language_status(_, result)
+          local command = vim.api.nvim_command
+          command 'echohl ModeMsg'
+          command(string.format('echo "%s"', result.message))
+          command 'echohl None'
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/jinja-lsp.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.jinja-lsp;
+in {
+  options.vim.lsp.presets.jinja-lsp = {
+    enable = mkLspPresetEnableOption "jinja-lsp" "Jinja" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.jinja-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.jinja-lsp)];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/jq-lsp.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.jq-lsp;
+in {
+  options.vim.lsp.presets.jq-lsp = {
+    enable = mkLspPresetEnableOption "jq-lsp" "JQ" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.jq-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.jq-lsp)];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/julia-languageserver.nix

@@ -0,0 +1,129 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryBefore;
+
+  cfg = config.vim.lsp.presets.julia-languageserver;
+in {
+  options.vim.lsp.presets.julia-languageserver = {
+    enable = mkLspPresetEnableOption "julia-languageserver" "Julia" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim = {
+      lsp.servers.julia-languageserver = {
+        enable = true;
+        root_markers = ["Project.toml" "JuliaProject.toml"];
+        cmd = mkLuaInline ''
+          {
+            '${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
+            '--startup-file=no',
+            '--history-file=no',
+            '-e',
+            [[
+              # Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
+              # with the regular load path as a fallback
+              ls_install_path = joinpath(
+                  get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
+                  "environments", "nvim-lspconfig"
+              )
+              pushfirst!(LOAD_PATH, ls_install_path)
+              using LanguageServer
+              popfirst!(LOAD_PATH)
+              depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
+              project_path = let
+                  dirname(something(
+                      ## 1. Finds an explicitly set project (JULIA_PROJECT)
+                      Base.load_path_expand((
+                          p = get(ENV, "JULIA_PROJECT", nothing);
+                          p === nothing ? nothing : isempty(p) ? nothing : p
+                      )),
+                      ## 2. Look for a Project.toml file in the current working directory,
+                      ##    or parent directories, with $HOME as an upper boundary
+                      Base.current_project(),
+                      ## 3. First entry in the load path
+                      get(Base.load_path(), 1, nothing),
+                      ## 4. Fallback to default global environment,
+                      ##    this is more or less unreachable
+                      Base.load_path_expand("@v#.#"),
+                  ))
+              end
+              @info "Running language server" VERSION pwd() project_path depot_path
+              server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
+              server.runlinter = true
+              run(server)
+            ]],
+          }
+        '';
+        on_attach = mkLuaInline ''
+          function(_, bufnr)
+              vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
+                desc = 'Activate a Julia environment',
+                nargs = '?',
+                complete = 'file',
+              })
+          end
+        '';
+      };
+      luaConfigRC.julia-util = entryBefore ["lsp-servers"] ''
+        local function activate_julia_env(path)
+          assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
+          local bufnr = vim.api.nvim_get_current_buf()
+          local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
+          assert(
+            #julials_clients > 0,
+            'method julia/activateenvironment is not supported by any servers active on the current buffer'
+          )
+          local function _activate_env(environment)
+            if environment then
+              for _, julials_client in ipairs(julials_clients) do
+                julials_client:notify('julia/activateenvironment', { envPath = environment })
+              end
+              vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
+            end
+          end
+          if path then
+            path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
+            local found_env = false
+            for _, project_file in ipairs(root_files) do
+              local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
+              if file and file.type then
+                found_env = true
+                break
+              end
+            end
+            if not found_env then
+              vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
+              return
+            end
+            _activate_env(path)
+          else
+            local depot_paths = vim.env.JULIA_DEPOT_PATH
+                and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
+              or { vim.fn.expand '~/.julia' }
+            local environments = {}
+            vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
+            for _, depot_path in ipairs(depot_paths) do
+              local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
+              vim.list_extend(
+                environments,
+                vim.fs.find(function(name, env_path)
+                  return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
+                end, { path = depot_env, type = 'file', limit = math.huge })
+              )
+            end
+            environments = vim.tbl_map(vim.fs.dirname, environments)
+            vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
+          end
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/just-lsp.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.just-lsp;
+in {
+  options.vim.lsp.presets.just-lsp = {
+    enable = mkLspPresetEnableOption "just-lsp" "Just" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.just-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.just-lsp)];
+      root_markers = [".git" "Justfile" "justfile"];
+    };
+  };
+}

modules/plugins/lsp/presets/kotlin-language-server.nix

@@ -0,0 +1,46 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.kotlin-language-server;
+in {
+  options.vim.lsp.presets.kotlin-language-server = {
+    enable = mkLspPresetEnableOption "kotlin-language-server" "Kotlin" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.kotlin-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.kotlin-language-server)];
+      root_markers = [
+        "settings.gradle" # Gradle (multi-project)
+        "settings.gradle.kts" # Gradle (multi-project)
+        "build.xml" # Ant
+        "pom.xml" # Maven
+        "build.gradle" # Gradle
+        "build.gradle.kts" # gradle
+      ];
+      init_options = {
+        storagePath = mkLuaInline ''
+          vim.fs.root(vim.fn.expand '%:p:h',
+            {
+              'settings.gradle', -- Gradle (multi-project)
+              'settings.gradle.kts', -- Gradle (multi-project)
+              'build.xml', -- Ant
+              'pom.xml', -- Maven
+              'build.gradle', -- Gradle
+              'build.gradle.kts', -- Gradle
+            }
+          )
+        '';
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/lemminx.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.lemminx;
+in {
+  options.vim.lsp.presets.lemminx = {
+    enable = mkLspPresetEnableOption "lemminx" "Lemminx" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.lemminx = {
+      enable = true;
+      cmd = [(getExe pkgs.lemminx)];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/lua-language-server.nix

@@ -0,0 +1,33 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.lua-language-server;
+in {
+  options.vim.lsp.presets.lua-language-server = {
+    enable = mkLspPresetEnableOption "lua-language-server" "Lua" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.lua-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.lua-language-server)];
+      root_markers = [
+        ".luarc.json"
+        ".luarc.jsonc"
+        ".luacheckrc"
+        ".stylua.toml"
+        "stylua.toml"
+        "selene.toml"
+        "selene.yml"
+        ".git"
+      ];
+    };
+  };
+}

modules/plugins/lsp/presets/markdown-oxide.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.markdown-oxide;
+in {
+  options.vim.lsp.presets.markdown-oxide = {
+    enable = mkLspPresetEnableOption "markdown-oxide" "Markdown Oxide" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.markdown-oxide = {
+      enable = true;
+      cmd = [(getExe pkgs.markdown-oxide)];
+      root_markers = [".git" ".moxide.toml" ".obsidian"];
+    };
+  };
+}

modules/plugins/lsp/presets/marksman.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.marksman;
+in {
+  options.vim.lsp.presets.marksman = {
+    enable = mkLspPresetEnableOption "marksman" "Marksman" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.marksman = {
+      enable = true;
+      cmd = [(getExe pkgs.marksman) "server"];
+      root_markers = [".git" ".marksman.toml"];
+    };
+  };
+}

modules/plugins/lsp/presets/neocmakelsp.nix

@@ -0,0 +1,27 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.neocmakelsp;
+in {
+  options.vim.lsp.presets.neocmakelsp = {
+    enable = mkLspPresetEnableOption "neocmakelsp" "NeoCmake" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.neocmakelsp = {
+      enable = true;
+      cmd = [(getExe pkgs.neocmakelsp) "stdio"];
+      root_markers = [".git" ".gersemirc"];
+      capabilities = {
+        textDocument.completion.completionItem.snippetSupport = true;
+      };
+    };
+  };
+}

modules/plugins/lsp/presets/nil.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.nil;
+in {
+  options.vim.lsp.presets.nil = {
+    enable = mkLspPresetEnableOption "nil" "Nil" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.nil = {
+      enable = true;
+      cmd = [(getExe pkgs.nil)];
+      root_markers = [".git"];
+    };
+  };
+}

modules/plugins/lsp/presets/nimlsp.nix

@@ -0,0 +1,32 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+  inherit (lib.generators) mkLuaInline;
+
+  cfg = config.vim.lsp.presets.nimlsp;
+in {
+  options.vim.lsp.presets.nimlsp = {
+    enable = mkLspPresetEnableOption "nimlsp" "Nim" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.nimlsp = {
+      enable = true;
+      cmd = [(getExe pkgs.nimlsp)];
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+          on_dir(
+            util.root_pattern '*.nimble'(fname) or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
+          )
+        end
+      '';
+    };
+  };
+}

modules/plugins/lsp/presets/nixd.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.nixd;
+in {
+  options.vim.lsp.presets.nixd = {
+    enable = mkLspPresetEnableOption "nixd" "Nixd" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.nixd = {
+      enable = true;
+      cmd = [(getExe pkgs.nixd)];
+      root_markers = [".git"];
+    };
+  };
+}