modules/plugins/languages/ruby.nix

@@ -9,41 +9,44 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.types) listOf package enum;
+  inherit (lib.nvim.lua) expToLua;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.lists) isList;
+  inherit (lib.types) either listOf package str enum;
 
   cfg = config.vim.languages.ruby;
 
-  defaultServers = ["solargraph"];
+  defaultServer = "rubyserver";
   servers = {
-    ruby_lsp = {
+    rubyserver = {
-      enable = true;
+      package = pkgs.rubyPackages.solargraph;
-      cmd = [(getExe pkgs.ruby-lsp)];
+      lspConfig = ''
-      filetypes = ["ruby" "eruby"];
+        lspconfig.solargraph.setup {
-      root_markers = ["Gemfile" ".git"];
+          capabilities = capabilities,
-      init_options = {
+          on_attach = attach_keymaps,
-        formatter = "auto";
+          flags = {
-      };
+            debounce_text_changes = 150,
+          },
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{ "${cfg.lsp.package}/bin/solargraph", "stdio" }''
+        }
+        }
+      '';
     };
-
+    rubylsp = {
-    solargraph = {
+      package = pkgs.ruby-lsp;
-      enable = true;
+      lspConfig = ''
-      cmd = [(getExe pkgs.rubyPackages.solargraph) "stdio"];
+        lspconfig.ruby_lsp.setup {
-      filetypes = ["ruby"];
+          capabilities = capabilities,
-      root_markers = ["Gemfile" ".git"];
+          on_attach = default_on_attach,
-      settings = {
+          cmd = ${
-        solargraph = {
+          if isList cfg.lsp.package
-          diagnostics = true;
+          then expToLua cfg.lsp.package
-        };
+          else ''{ "${cfg.lsp.package}/bin/ruby-lsp" }''
-      };
+        }
-
+        }
-      flags = {
+      '';
-        debounce_text_changes = 150;
-      };
-
-      init_options = {
-        formatting = true;
-      };
     };
   };
 
@@ -76,11 +79,17 @@ in {
     lsp = {
       enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
         description = "Ruby LSP server to use";
       };
+
+      package = mkOption {
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
+        description = "Ruby LSP server package, or the command to run as a list of strings";
+      };
     };
 
     format = {
@@ -119,12 +128,8 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.ruby-lsp = servers.${cfg.lsp.server}.lspConfig;
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/sql.nix

@@ -8,27 +8,31 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum listOf package str;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) diagnostics;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.sql;
   sqlfluffDefault = pkgs.sqlfluff;
 
-  defaultServers = ["sqls"];
+  defaultServer = "sqls";
   servers = {
     sqls = {
-      enable = true;
+      package = pkgs.sqls;
-      cmd = [(getExe pkgs.sqls)];
+      lspConfig = ''
-      filetypes = ["sql" "mysql"];
+        lspconfig.sqls.setup {
-      root_markers = ["config.yml"];
+          on_attach = function(client)
-      settings = {};
+            client.server_capabilities.execute_command = true
-      on_attach = mkLuaInline ''
+            on_attach_keymaps(client, bufnr)
-        function(client, bufnr)
+            require'sqls'.setup{}
-          client.server_capabilities.execute_command = true
+          end,
-          require'sqls'.setup{}
+          cmd = ${
-        end
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{ "${cfg.lsp.package}/bin/sqls", "-config", string.format("%s/config.yml", vim.fn.getcwd()) }''
+        }
+        }
       '';
     };
   };
@@ -77,10 +81,17 @@ in {
     lsp = {
       enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
         description = "SQL LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "SQL LSP server package, or the command to run as a list of strings";
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -121,12 +132,10 @@ in {
       vim = {
         startPlugins = ["sqls-nvim"];
 
-        lsp.servers =
+        lsp.lspconfig = {
-          mapListToAttrs (n: {
+          enable = true;
-            name = n;
+          sources.sql-lsp = servers.${cfg.lsp.server}.lspConfig;
-            value = servers.${n};
+        };
-          })
-          cfg.lsp.servers;
       };
     })
 

modules/plugins/languages/svelte.nix

@@ -7,39 +7,28 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum listOf package;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.svelte;
 
-  defaultServers = ["svelte"];
+  defaultServer = "svelte";
   servers = {
     svelte = {
-      enable = true;
+      package = pkgs.svelte-language-server;
-      cmd = [(getExe pkgs.svelte-language-server) "--stdio"];
+      lspConfig = ''
-      filetypes = ["svelte"];
+        lspconfig.svelte.setup {
-      root_dir = mkLuaInline ''
+          capabilities = capabilities;
-        function(bufnr, on_dir)
+          on_attach = attach_keymaps,
-          local root_files = { 'package.json', '.git' }
+          cmd = ${
-          local fname = vim.api.nvim_buf_get_name(bufnr)
+          if isList cfg.lsp.package
-          -- Svelte LSP only supports file:// schema. https://github.com/sveltejs/language-tools/issues/2777
+          then expToLua cfg.lsp.package
-          if vim.uv.fs_stat(fname) ~= nil then
+          else ''{"${cfg.lsp.package}/bin/svelteserver", "--stdio"}''
-            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_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
       '';
     };
   };
@@ -89,10 +78,17 @@ in {
     lsp = {
       enable = mkEnableOption "Svelte LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
         description = "Svelte LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Svelte LSP server package, or the command to run as a list of strings";
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -130,12 +126,8 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.svelte-lsp = servers.${cfg.lsp.server}.lspConfig;
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/tailwind.nix

@@ -7,142 +7,26 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
-  inherit (lib.types) enum listOf;
+  inherit (lib.types) enum either listOf package str;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.lua) expToLua;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.tailwind;
 
-  defaultServers = ["tailwindcss"];
+  defaultServer = "tailwindcss-language-server";
   servers = {
-    tailwindcss = {
+    tailwindcss-language-server = {
-      enable = true;
+      package = pkgs.tailwindcss-language-server;
-      cmd = [(getExe pkgs.tailwindcss-language-server) "--stdio"];
+      lspConfig = ''
-      filetypes = [
+        lspconfig.tailwindcss.setup {
-        # html
+          capabilities = capabilities;
-        "aspnetcorerazor"
+          on_attach = default_on_attach;
-        "astro"
+          cmd = ${
-        "astro-markdown"
+          if isList cfg.lsp.package
-        "blade"
+          then expToLua cfg.lsp.package
-        "clojure"
+          else ''{"${cfg.lsp.package}/bin/tailwindcss-language-server", "--stdio"}''
-        "django-html"
+        }
-        "htmldjango"
+        }
-        "edge"
-        "eelixir"
-        "elixir"
-        "ejs"
-        "erb"
-        "eruby"
-        "gohtml"
-        "gohtmltmpl"
-        "haml"
-        "handlebars"
-        "hbs"
-        "html"
-        "htmlangular"
-        "html-eex"
-        "heex"
-        "jade"
-        "leaf"
-        "liquid"
-        "markdown"
-        "mdx"
-        "mustache"
-        "njk"
-        "nunjucks"
-        "php"
-        "razor"
-        "slim"
-        "twig"
-        # css
-        "css"
-        "less"
-        "postcss"
-        "sass"
-        "scss"
-        "stylus"
-        "sugarss"
-        # js
-        "javascript"
-        "javascriptreact"
-        "reason"
-        "rescript"
-        "typescript"
-        "typescriptreact"
-        # mixed
-        "vue"
-        "svelte"
-        "templ"
-      ];
-      settings = {
-        tailwindCSS = {
-          validate = true;
-          lint = {
-            cssConflict = "warning";
-            invalidApply = "error";
-            invalidScreen = "error";
-            invalidVariant = "error";
-            invalidConfigPath = "error";
-            invalidTailwindDirective = "error";
-            recommendedVariantOrder = "warning";
-          };
-          classAttributes = [
-            "class"
-            "className"
-            "class:list"
-            "classList"
-            "ngClass"
-          ];
-          includeLanguages = {
-            eelixir = "html-eex";
-            elixir = "phoenix-heex";
-            eruby = "erb";
-            heex = "phoenix-heex";
-            htmlangular = "html";
-            templ = "html";
-          };
-        };
-      };
-      before_init = mkLuaInline ''
-        function(_, config)
-          if not config.settings then
-            config.settings = {}
-          end
-          if not config.settings.editor then
-            config.settings.editor = {}
-          end
-          if not config.settings.editor.tabSize then
-            config.settings.editor.tabSize = vim.lsp.util.get_effective_tabstop()
-          end
-        end
-      '';
-      workspace_required = true;
-      root_dir = mkLuaInline ''
-        function(bufnr, on_dir)
-          local util = require 'lspconfig.util'
-          local root_files = {
-            -- Generic
-            'tailwind.config.js',
-            'tailwind.config.cjs',
-            'tailwind.config.mjs',
-            'tailwind.config.ts',
-            'postcss.config.js',
-            'postcss.config.cjs',
-            'postcss.config.mjs',
-            'postcss.config.ts',
-            -- Django
-            'theme/static_src/tailwind.config.js',
-            'theme/static_src/tailwind.config.cjs',
-            'theme/static_src/tailwind.config.mjs',
-            'theme/static_src/tailwind.config.ts',
-            'theme/static_src/postcss.config.js',
-          }
-          local fname = vim.api.nvim_buf_get_name(bufnr)
-          root_files = util.insert_package_json(root_files, 'tailwindcss', fname)
-          root_files = util.root_markers_with_field(root_files, { 'mix.lock', 'Gemfile.lock' }, 'tailwind', fname)
-          on_dir(vim.fs.dirname(vim.fs.find(root_files, { path = fname, upward = true })[1]))
-        end
       '';
     };
   };
@@ -153,22 +37,25 @@ in {
     lsp = {
       enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
         description = "Tailwindcss LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Tailwindcss LSP server package, or the command to run as a list of strings";
+        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.tailwindcss-lsp = servers.${cfg.lsp.server}.lspConfig;
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/terraform.nix

@@ -4,25 +4,12 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib.types) package;
-  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.terraform;
-
-  defaultServers = ["terraformls"];
-  servers = {
-    terraformls = {
-      enable = true;
-      cmd = [(getExe pkgs.terraform-ls) "serve"];
-      filetypes = ["terraform" "terraform-vars"];
-      root_markers = [".terraform" ".git"];
-    };
-  };
 in {
   options.vim.languages.terraform = {
     enable = mkEnableOption "Terraform/HCL support";
@@ -35,10 +22,10 @@ in {
     lsp = {
       enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      package = mkOption {
-        description = "Terraform LSP server to use";
+        description = "terraform-ls package";
-        type = listOf (enum (attrNames servers));
+        type = package;
-        default = defaultServers;
+        default = pkgs.terraform-ls;
       };
     };
   };
@@ -49,12 +36,14 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.terraform-ls = ''
-          name = n;
+        lspconfig.terraformls.setup {
-          value = servers.${n};
+          capabilities = capabilities,
-        })
+          on_attach=default_on_attach,
-        cfg.lsp.servers;
+          cmd = {"${cfg.lsp.package}/bin/terraform-ls", "serve"},
+        }
+      '';
     })
   ]);
 }

modules/plugins/languages/typst.nix

@@ -6,87 +6,52 @@
 }: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) nullOr enum attrsOf listOf package str;
+  inherit (lib.lists) isList;
+  inherit (lib.types) nullOr enum either attrsOf listOf package str;
   inherit (lib.attrsets) attrNames;
   inherit (lib.meta) getExe;
+  inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.typst;
 
-  defaultServers = ["tinymist"];
+  defaultServer = "tinymist";
   servers = {
-    typst_lsp = {
+    typst-lsp = {
-      enable = true;
+      package = pkgs.typst-lsp;
-      cmd = [(getExe pkgs.typst-lsp)];
+      lspConfig = ''
-      filetypes = ["typst"];
+        lspconfig.typst_lsp.setup {
-      root_markers = [".git"];
+          capabilities = capabilities,
-      on_attach = mkLuaInline ''
+          on_attach = function(client, bufnr)
-        function(client, bufnr)
+            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
-          -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
+            client.server_capabilities.semanticTokensProvider = nil
-          client.server_capabilities.semanticTokensProvider = nil
+          end,
-        end
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/typst-lsp"}''
+        },
+        }
       '';
     };
 
     tinymist = {
-      enable = true;
+      package = pkgs.tinymist;
-      cmd = [(getExe pkgs.tinymist)];
+      lspConfig = ''
-      filetypes = ["typst"];
+        lspconfig.tinymist.setup {
-      root_markers = [".git"];
+          capabilities = capabilities,
-      on_attach = mkLuaInline ''
+          single_file_support = true,
-        function(client, bufnr)
+          on_attach = function(client, bufnr)
-          local function create_tinymist_command(command_name, client, bufnr)
+            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
-            local export_type = command_name:match 'tinymist%.export(%w+)'
+            client.server_capabilities.semanticTokensProvider = nil
-            local info_type = command_name:match 'tinymist%.(%w+)'
+          end,
-            if info_type and info_type:match '^get' then
+          cmd = ${
-              info_type = info_type:gsub('^get', 'Get')
+          if isList cfg.lsp.package
-            end
+          then expToLua cfg.lsp.package
-            local cmd_display = export_type or info_type
+          else ''{"${cfg.lsp.package}/bin/tinymist"}''
-            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
       '';
     };
   };
@@ -113,10 +78,17 @@ in {
     lsp = {
       enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
         description = "Typst LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "typst-lsp package, or the command to run as a list of strings";
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -159,7 +131,7 @@ in {
           dependencies_bin = mkOption {
             type = attrsOf str;
             default = {
-              "tinymist" = getExe pkgs.tinymist;
+              "tinymist" = getExe servers.tinymist.package;
               "websocat" = getExe pkgs.websocat;
             };
 
@@ -197,12 +169,8 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.typst-lsp = servers.${cfg.lsp.server}.lspConfig;
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
 
     # Extensions

modules/plugins/languages/vala.nix

@@ -7,57 +7,36 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
-  inherit (lib.types) enum listOf;
+  inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.lua) expToLua;
-  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.vala;
 
-  defaultServers = ["vala_ls"];
+  defaultServer = "vala_ls";
   servers = {
     vala_ls = {
-      enable = true;
+      package = pkgs.symlinkJoin {
-      cmd = [
+        name = "vala-language-server-wrapper";
-        (getExe (pkgs.symlinkJoin {
+        paths = [pkgs.vala-language-server];
-          name = "vala-language-server-wrapper";
+        buildInputs = [pkgs.makeBinaryWrapper];
-          paths = [pkgs.vala-language-server];
+        postBuild = ''
-          buildInputs = [pkgs.makeBinaryWrapper];
+          wrapProgram $out/bin/vala-language-server \
-          postBuild = ''
+            --prefix PATH : ${pkgs.uncrustify}/bin
-            wrapProgram $out/bin/vala-language-server \
+        '';
-              --prefix PATH : ${pkgs.uncrustify}/bin
+      };
-          '';
+      internalFormatter = true;
-        }))
+      lspConfig = ''
-      ];
+        lspconfig.vala_ls.setup {
-      filetypes = ["vala" "genie"];
+          capabilities = capabilities;
-      root_dir = mkLuaInline ''
+          on_attach = default_on_attach;
-        function(bufnr, on_dir)
+          cmd = ${
-          local meson_matcher = function(path)
+          if isList cfg.lsp.package
-            local pattern = 'meson.build'
+          then expToLua cfg.lsp.package
-            local f = vim.fn.glob(table.concat({ path, pattern }, '/'))
+          else ''{"${cfg.lsp.package}/bin/vala-language-server"}''
-            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
       '';
     };
   };
@@ -72,10 +51,16 @@ in {
 
     lsp = {
       enable = mkEnableOption "Vala LSP support" // {default = config.vim.lsp.enable;};
-      servers = mkOption {
+      server = mkOption {
         description = "Vala LSP server to use";
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Vala LSP server package, or the command to run as a list of strings";
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
@@ -87,12 +72,8 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim.lsp.lspconfig.enable = true;
-        mapListToAttrs (n: {
+      vim.lsp.lspconfig.sources.vala_ls = servers.${cfg.lsp.server}.lspConfig;
-          name = n;
-          value = servers.${n};
-        })
-        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/wgsl.nix

@@ -5,23 +5,31 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib.lists) isList;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.options) literalExpression mkEnableOption mkOption;
-  inherit (lib.types) enum listOf;
+  inherit (lib.types) either enum listOf package str;
-  inherit (lib.meta) getExe;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.wgsl;
 
-  defaultServers = ["wgsl_analyzer"];
+  defaultServer = "wgsl-analyzer";
   servers = {
-    wgsl_analyzer = {
+    wgsl-analyzer = {
-      enable = true;
+      package = pkgs.wgsl-analyzer;
-      cmd = [(getExe pkgs.wgsl-analyzer)];
+      internalFormatter = true;
-      filetypes = ["wgsl"];
+      lspConfig = ''
-      root_markers = [".git"];
+        lspconfig.wgsl_analyzer.setup {
-      settings = {};
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else "{'${cfg.lsp.package}/bin/wgsl_analyzer'}"
+        }
+        }
+      '';
     };
   };
 in {
@@ -36,11 +44,18 @@ in {
     lsp = {
       enable = mkEnableOption "WGSL LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
         description = "WGSL LSP server to use";
       };
+
+      package = mkOption {
+        description = "wgsl-analyzer package, or the command to run as a list of strings";
+        example = literalExpression "[(lib.getExe pkgs.wgsl-analyzer)]";
+        type = either package (listOf str);
+        default = pkgs.wgsl-analyzer;
+      };
     };
   };
 
@@ -53,12 +68,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.servers =
+      vim = {
-        mapListToAttrs (n: {
+        lsp.lspconfig = {
-          name = n;
+          enable = true;
-          value = servers.${n};
+          sources.wgsl_analyzer = servers.${cfg.lsp.server}.lspConfig;
-        })
+        };
-        cfg.lsp.servers;
+      };
     })
   ]);
 }

modules/plugins/languages/zig.nix

@@ -7,21 +7,29 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge mkDefault;
-  inherit (lib.types) bool listOf package enum;
+  inherit (lib.lists) isList;
+  inherit (lib.types) bool either listOf package str enum;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.meta) getExe;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.zig;
 
-  defaultServers = ["zls"];
+  defaultServer = "zls";
   servers = {
     zls = {
-      enable = true;
+      package = pkgs.zls;
-      cmd = [(getExe pkgs.zls)];
+      internalFormatter = true;
-      filetypes = ["zig" "zir"];
+      lspConfig = ''
-      root_markers = ["zls.json" "build.zig" ".git"];
+        lspconfig.zls.setup {
-      workspace_required = false;
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else "{'${cfg.lsp.package}/bin/zls'}"
+        }
+        }
+      '';
     };
   };
 
@@ -66,11 +74,17 @@ in {
     lsp = {
       enable = mkEnableOption "Zig LSP support" // {default = config.vim.lsp.enable;};
 
-      servers = mkOption {
+      server = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = enum (attrNames servers);
-        default = defaultServers;
+        default = defaultServer;
         description = "Zig LSP server to use";
       };
+
+      package = mkOption {
+        description = "ZLS package, or the command to run as a list of strings";
+        type = either package (listOf str);
+        default = pkgs.zls;
+      };
     };
 
     dap = {
@@ -104,12 +118,10 @@ in {
 
     (mkIf cfg.lsp.enable {
       vim = {
-        lsp.servers =
+        lsp.lspconfig = {
-          mapListToAttrs (n: {
+          enable = true;
-            name = n;
+          sources.zig-lsp = servers.${cfg.lsp.server}.lspConfig;
-            value = servers.${n};
+        };
-          })
-          cfg.lsp.servers;
 
         # nvf handles autosaving already
         globals.zig_fmt_autosave = mkDefault 0;