treewide: begin restructuring the module tree

modules/plugins/assistant/copilot/config.nix

@@ -0,0 +1,85 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (builtins) toJSON;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.lists) optionals;
+  inherit (lib.nvim.binds) mkLuaBinding;
+
+  cfg = config.vim.assistant.copilot;
+
+  wrapPanelBinding = luaFunction: key: ''
+    function()
+      local s, _ = pcall(${luaFunction})
+
+      if not s then
+        local termcode = vim.api.nvim_replace_termcodes(${toJSON key}, true, false, true)
+
+        vim.fn.feedkeys(termcode, 'n')
+      end
+    end
+  '';
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins =
+      [
+        "copilot-lua"
+        # cfg.copilotNodePackage
+      ]
+      ++ optionals (cfg.cmp.enable) [
+        "copilot-cmp"
+      ];
+
+    vim.luaConfigRC.copilot = entryAnywhere ''
+      require("copilot").setup(${toLuaObject cfg.setupOpts})
+
+      ${lib.optionalString (cfg.cmp.enable) ''
+        require("copilot_cmp").setup()
+      ''}
+    '';
+
+    # Disable plugin handled keymaps.
+    # Setting it here so that it doesn't show up in user docs
+    vim.assistant.copilot.setupOpts = {
+      panel.keymap = {
+        jump_prev = lib.mkDefault false;
+        jump_next = lib.mkDefault false;
+        accept = lib.mkDefault false;
+        refresh = lib.mkDefault false;
+        open = lib.mkDefault false;
+      };
+      suggestion.keymap = {
+        accept = lib.mkDefault false;
+        accept_word = lib.mkDefault false;
+        accept_line = lib.mkDefault false;
+        next = lib.mkDefault false;
+        prev = lib.mkDefault false;
+        dismiss = lib.mkDefault false;
+      };
+    };
+
+    vim.maps.normal = mkMerge [
+      (mkLuaBinding cfg.mappings.panel.jumpPrev (wrapPanelBinding "require(\"copilot.panel\").jump_prev" cfg.mappings.panel.jumpPrev) "[copilot] Accept suggestion")
+      (mkLuaBinding cfg.mappings.panel.jumpNext (wrapPanelBinding "require(\"copilot.panel\").jump_next" cfg.mappings.panel.jumpNext) "[copilot] Accept suggestion")
+      (mkLuaBinding cfg.mappings.panel.accept (wrapPanelBinding ''require("copilot.panel").accept'' cfg.mappings.panel.accept) "[copilot] Accept suggestion")
+      (mkLuaBinding cfg.mappings.panel.refresh (wrapPanelBinding "require(\"copilot.panel\").refresh" cfg.mappings.panel.refresh) "[copilot] Accept suggestion")
+      (mkLuaBinding cfg.mappings.panel.open (wrapPanelBinding ''
+          function() require("copilot.panel").open({ position = "${cfg.setupOpts.panel.layout.position}", ratio = ${toString cfg.setupOpts.panel.layout.ratio}, }) end
+        ''
+        cfg.mappings.panel.open) "[copilot] Accept suggestion")
+    ];
+
+    vim.maps.insert = mkMerge [
+      (mkLuaBinding cfg.mappings.suggestion.accept "require(\"copilot.suggestion\").accept" "[copilot] Accept suggestion")
+      (mkLuaBinding cfg.mappings.suggestion.acceptLine "require(\"copilot.suggestion\").accept_line" "[copilot] Accept suggestion (line)")
+      (mkLuaBinding cfg.mappings.suggestion.acceptWord "require(\"copilot.suggestion\").accept_word" "[copilot] Accept suggestion (word)")
+      (mkLuaBinding cfg.mappings.suggestion.next "require(\"copilot.suggestion\").next" "[copilot] next suggestion")
+      (mkLuaBinding cfg.mappings.suggestion.prev "require(\"copilot.suggestion\").prev" "[copilot] previous suggestion")
+      (mkLuaBinding cfg.mappings.suggestion.dismiss "require(\"copilot.suggestion\").dismiss" "[copilot] dismiss suggestion")
+    ];
+  };
+}

modules/plugins/assistant/copilot/copilot.nix

@@ -0,0 +1,131 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib) mkRenamedOptionModule;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) nullOr str enum float;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+
+  cfg = config.vim.assistant.copilot;
+in {
+  imports = [
+    (mkRenamedOptionModule ["vim" "assistant" "copilot" "panel"] ["vim" "assistant" "copilot" "setupOpts" "panel"])
+    (mkRenamedOptionModule ["vim" "assistant" "copilot" "copilotNodeCommand"] ["vim" "assistant" "copilot" "setupOpts" "copilot_node_command"])
+    (mkRenamedOptionModule ["vim" "assistant" "copilot" "copilotNodePackage"] ["vim" "assistant" "copilot" "setupOpts" "copilot_node_command"])
+  ];
+
+  options.vim.assistant.copilot = {
+    enable = mkEnableOption "GitHub Copilot AI assistant";
+    cmp.enable = mkEnableOption "nvim-cmp integration for GitHub Copilot";
+
+    setupOpts = mkPluginSetupOption "Copilot" {
+      copilot_node_command = mkOption {
+        type = str;
+        default = "${lib.getExe pkgs.nodejs-slim}";
+        description = ''
+          The command that will be executed to initiate nodejs for GitHub Copilot.
+          Recommended to leave as default.
+        '';
+      };
+      panel = {
+        enabled = mkEnableOption "Completion Panel" // {default = !cfg.cmp.enable;};
+        layout = {
+          position = mkOption {
+            type = enum [
+              "bottom"
+              "top"
+              "left"
+              "right"
+            ];
+            default = "bottom";
+            description = "Panel position";
+          };
+          ratio = mkOption {
+            type = float;
+            default = 0.4;
+            description = "Panel size";
+          };
+        };
+      };
+
+      suggestion = {
+        enabled = mkEnableOption "Suggestions" // {default = !cfg.cmp.enable;};
+        # keymap = { };
+      };
+    };
+
+    mappings = {
+      panel = {
+        jumpPrev = mkOption {
+          type = nullOr str;
+          default = "[[";
+          description = "Jump to previous suggestion";
+        };
+
+        jumpNext = mkOption {
+          type = nullOr str;
+          default = "]]";
+          description = "Jump to next suggestion";
+        };
+
+        accept = mkOption {
+          type = nullOr str;
+          default = "<CR>";
+          description = "Accept suggestion";
+        };
+
+        refresh = mkOption {
+          type = nullOr str;
+          default = "gr";
+          description = "Refresh suggestions";
+        };
+
+        open = mkOption {
+          type = nullOr str;
+          default = "<M-CR>";
+          description = "Open suggestions";
+        };
+      };
+      suggestion = {
+        accept = mkOption {
+          type = nullOr str;
+          default = "<M-l>";
+          description = "Accept suggetion";
+        };
+
+        acceptWord = mkOption {
+          type = nullOr str;
+          default = null;
+          description = "Accept next word";
+        };
+
+        acceptLine = mkOption {
+          type = nullOr str;
+          default = null;
+          description = "Accept next line";
+        };
+
+        prev = mkOption {
+          type = nullOr str;
+          default = "<M-[>";
+          description = "Previous suggestion";
+        };
+
+        next = mkOption {
+          type = nullOr str;
+          default = "<M-]>";
+          description = "Next suggestion";
+        };
+
+        dismiss = mkOption {
+          type = nullOr str;
+          default = "<C-]>";
+          description = "Dismiss suggestion";
+        };
+      };
+    };
+  };
+}

modules/plugins/assistant/copilot/default.nix

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

modules/plugins/assistant/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./copilot
+  ];
+}

modules/plugins/autopairs/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./nvim-autopairs
+  ];
+}

modules/plugins/autopairs/nvim-autopairs/config.nix

@@ -0,0 +1,20 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.autopairs;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = ["nvim-autopairs"];
+
+    vim.luaConfigRC.autopairs = entryAnywhere ''
+      require("nvim-autopairs").setup{}
+    '';
+  };
+}

modules/plugins/autopairs/nvim-autopairs/default.nix

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

modules/plugins/autopairs/nvim-autopairs/nvim-autopairs.nix

@@ -0,0 +1,21 @@
+{lib, ...}: let
+  inherit (lib) mkRemovedOptionModule;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum;
+in {
+  imports = [
+    (mkRemovedOptionModule ["vim" "autopairs" "nvim-compe"] "nvim-compe is deprecated and no longer suported.")
+  ];
+
+  options.vim = {
+    autopairs = {
+      enable = mkEnableOption "autopairs" // {default = false;};
+
+      type = mkOption {
+        type = enum ["nvim-autopairs"];
+        default = "nvim-autopairs";
+        description = "Set the autopairs type. Options: nvim-autopairs [nvim-autopairs]";
+      };
+    };
+  };
+}

modules/plugins/comments/comment-nvim/comment-nvim.nix

@@ -0,0 +1,19 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.comments.comment-nvim = {
+    enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";
+
+    mappings = {
+      toggleCurrentLine = mkMappingOption "Toggle current line comment" "gcc";
+      toggleCurrentBlock = mkMappingOption "Toggle current block comment" "gbc";
+
+      toggleOpLeaderLine = mkMappingOption "Toggle line comment" "gc";
+      toggleOpLeaderBlock = mkMappingOption "Toggle block comment" "gb";
+
+      toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
+      toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
+    };
+  };
+}

modules/plugins/comments/comment-nvim/config.nix

@@ -0,0 +1,50 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) mkExprBinding mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.comments.comment-nvim;
+  self = import ./comment-nvim.nix {inherit lib;};
+  inherit (self.options.vim.comments.comment-nvim) mappings;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = [
+      "comment-nvim"
+    ];
+
+    vim.maps.normal = mkMerge [
+      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+      (mkBinding cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+
+      (mkExprBinding cfg.mappings.toggleCurrentLine ''
+          function()
+            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+                    or '<Plug>(comment_toggle_linewise_count)'
+          end
+        ''
+        mappings.toggleCurrentLine.description)
+      (mkExprBinding cfg.mappings.toggleCurrentBlock ''
+          function()
+            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+                    or '<Plug>(comment_toggle_blockwise_count)'
+          end
+        ''
+        mappings.toggleCurrentBlock.description)
+    ];
+
+    vim.maps.visualOnly = mkMerge [
+      (mkBinding cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+      (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
+    ];
+
+    vim.luaConfigRC.comment-nvim = entryAnywhere ''
+      require('Comment').setup({
+        mappings = { basic = false, extra = false, },
+      })
+    '';
+  };
+}

modules/plugins/comments/comment-nvim/default.nix

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

modules/plugins/comments/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./comment-nvim
+  ];
+}

modules/plugins/completion/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./nvim-cmp
+  ];
+}

modules/plugins/completion/nvim-cmp/config.nix

@@ -0,0 +1,244 @@
+{
+  lib,
+  config,
+  ...
+}: let
+  inherit (builtins) toJSON;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.attrsets) attrNames mapAttrsToList;
+  inherit (lib.strings) concatMapStringsSep concatStringsSep optionalString;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
+
+  cfg = config.vim.autocomplete;
+  lspkindEnabled = config.vim.lsp.enable && config.vim.lsp.lspkind.enable;
+
+  self = import ./nvim-cmp.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.autocomplete.mappings;
+
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
+
+  builtSources =
+    concatMapStringsSep
+    "\n"
+    (n: "{ name = '${n}'},")
+    (attrNames cfg.sources);
+
+  builtMaps =
+    concatStringsSep
+    "\n"
+    (mapAttrsToList
+      (n: v:
+        if v == null
+        then ""
+        else "${n} = '${v}',")
+      cfg.sources);
+
+  dagPlacement =
+    if lspkindEnabled
+    then entryAfter ["lspkind"]
+    else entryAnywhere;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = [
+      "nvim-cmp"
+      "cmp-buffer"
+      "cmp-vsnip"
+      "cmp-path"
+      "vim-vsnip"
+    ];
+
+    vim.autocomplete.sources = {
+      "nvim-cmp" = null;
+      "vsnip" = "[VSnip]";
+      "buffer" = "[Buffer]";
+      "crates" = "[Crates]";
+      "path" = "[Path]";
+      "copilot" = "[Copilot]";
+    };
+
+    vim.maps.insert = mkMerge [
+      (mkSetLuaBinding mappings.complete ''
+        require('cmp').complete
+      '')
+      (mkSetLuaBinding mappings.confirm ''
+        function()
+          if not require('cmp').confirm({ select = true }) then
+            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.confirm.value}, true, false, true)
+
+            vim.fn.feedkeys(termcode, 'n')
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.next ''
+        function()
+          local has_words_before = function()
+            local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+            return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+          end
+
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_next_item()
+          elseif vim.fn['vsnip#available'](1) == 1 then
+            feedkey("<Plug>(vsnip-expand-or-jump)", "")
+          elseif has_words_before() then
+            cmp.complete()
+          else
+            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
+
+            vim.fn.feedkeys(termcode, 'n')
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.previous ''
+        function()
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_prev_item()
+          elseif vim.fn['vsnip#available'](-1) == 1 then
+            feedkeys("<Plug>(vsnip-jump-prev)", "")
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.close ''
+        require('cmp').mapping.abort()
+      '')
+      (mkSetLuaBinding mappings.scrollDocsUp ''
+        require('cmp').mapping.scroll_docs(-4)
+      '')
+      (mkSetLuaBinding mappings.scrollDocsDown ''
+        require('cmp').mapping.scroll_docs(4)
+      '')
+    ];
+
+    vim.maps.command = mkMerge [
+      (mkSetLuaBinding mappings.complete ''
+        require('cmp').complete
+      '')
+      (mkSetLuaBinding mappings.close ''
+        require('cmp').mapping.close()
+      '')
+      (mkSetLuaBinding mappings.scrollDocsUp ''
+        require('cmp').mapping.scroll_docs(-4)
+      '')
+      (mkSetLuaBinding mappings.scrollDocsDown ''
+        require('cmp').mapping.scroll_docs(4)
+      '')
+    ];
+
+    vim.maps.select = mkMerge [
+      (mkSetLuaBinding mappings.next ''
+        function()
+          local cmp = require('cmp')
+          local has_words_before = function()
+            local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+            return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+          end
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_next_item()
+          elseif vim.fn['vsnip#available'](1) == 1 then
+            feedkey("<Plug>(vsnip-expand-or-jump)", "")
+          elseif has_words_before() then
+            cmp.complete()
+          else
+            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
+
+            vim.fn.feedkeys(termcode, 'n')
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.previous ''
+        function()
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_prev_item()
+          elseif vim.fn['vsnip#available'](-1) == 1 then
+            feedkeys("<Plug>(vsnip-jump-prev)", "")
+          end
+        end
+      '')
+    ];
+
+    # TODO: alternative snippet engines to vsnip
+    # https://github.com/hrsh7th/nvim-cmp/blob/main/doc/cmp.txt#L82
+    vim.luaConfigRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
+      local nvim_cmp_menu_map = function(entry, vim_item)
+        -- name for each source
+        vim_item.menu = ({
+          ${builtMaps}
+        })[entry.source.name]
+        print(vim_item.menu)
+        return vim_item
+      end
+
+      ${optionalString lspkindEnabled ''
+        lspkind_opts.before = ${cfg.formatting.format}
+      ''}
+
+      local cmp = require'cmp'
+      cmp.setup({
+        ${optionalString config.vim.ui.borders.enable ''
+        -- explicitly enabled by setting ui.borders.enable = true
+        -- TODO: try to get nvim-cmp to follow global border style
+        window = {
+          completion = cmp.config.window.bordered(),
+          documentation = cmp.config.window.bordered(),
+        },
+      ''}
+
+        snippet = {
+          expand = function(args)
+            vim.fn["vsnip#anonymous"](args.body)
+          end,
+        },
+
+        sources = {
+          ${builtSources}
+        },
+
+        completion = {
+          completeopt = 'menu,menuone,noinsert',
+        },
+
+        formatting = {
+          format =
+      ${
+        if lspkindEnabled
+        then "lspkind.cmp_format(lspkind_opts)"
+        else cfg.formatting.format
+      },
+        }
+      })
+      ${optionalString (config.vim.autopairs.enable && config.vim.autopairs.type == "nvim-autopairs") ''
+        local cmp_autopairs = require('nvim-autopairs.completion.cmp')
+        cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done({ map_char = { text = ""} }))
+      ''}
+    '');
+
+    vim.snippets.vsnip.enable =
+      if (cfg.type == "nvim-cmp")
+      then true
+      else config.vim.snippets.vsnip.enable;
+  };
+}

modules/plugins/completion/nvim-cmp/default.nix

@@ -0,0 +1,6 @@
+_: {
+  imports = [
+    ./config.nix
+    ./nvim-cmp.nix
+  ];
+}

modules/plugins/completion/nvim-cmp/nvim-cmp.nix

@@ -0,0 +1,66 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption literalMD;
+  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib.types) enum attrsOf nullOr str;
+in {
+  options.vim = {
+    autocomplete = {
+      enable = mkEnableOption "enable autocomplete" // {default = false;};
+
+      mappings = {
+        complete = mkMappingOption "Complete [nvim-cmp]" "<C-Space>";
+        confirm = mkMappingOption "Confirm [nvim-cmp]" "<CR>";
+        next = mkMappingOption "Next item [nvim-cmp]" "<Tab>";
+        previous = mkMappingOption "Previous item [nvim-cmp]" "<S-Tab>";
+        close = mkMappingOption "Close [nvim-cmp]" "<C-e>";
+        scrollDocsUp = mkMappingOption "Scroll docs up [nvim-cmp]" "<C-d>";
+        scrollDocsDown = mkMappingOption "Scroll docs down [nvim-cmp]" "<C-f>";
+      };
+
+      type = mkOption {
+        type = enum ["nvim-cmp"];
+        default = "nvim-cmp";
+        description = "Set the autocomplete plugin. Options: [nvim-cmp]";
+      };
+
+      sources = mkOption {
+        description = ''
+          Attribute set of source names for nvim-cmp.
+
+          If an attribute set is provided, then the menu value of
+          `vim_item` in the format will be set to the value (if
+          utilizing the `nvim_cmp_menu_map` function).
+
+          Note: only use a single attribute name per attribute set
+        '';
+        type = attrsOf (nullOr str);
+        default = {};
+        example = ''
+          {nvim-cmp = null; buffer = "[Buffer]";}
+        '';
+      };
+
+      formatting = {
+        format = mkOption {
+          description = ''
+            The function used to customize the appearance of the completion menu.
+
+            If [](#opt-vim.lsp.lspkind.enable) is true, then the function
+            will be called before modifications from lspkind.
+
+            Default is to call the menu mapping function.
+          '';
+          type = str;
+          default = "nvim_cmp_menu_map";
+          example = literalMD ''
+            ```lua
+            function(entry, vim_item)
+              return vim_item
+            end
+            ```
+          '';
+        };
+      };
+    };
+  };
+}

modules/plugins/dashboard/alpha/alpha.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.dashboard.alpha = {
+    enable = mkEnableOption "fast and fully programmable greeter for neovim [alpha.mvim]";
+  };
+}

modules/plugins/dashboard/alpha/config.nix

@@ -0,0 +1,220 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.dashboard.alpha;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = [
+      "alpha-nvim"
+      "nvim-web-devicons"
+    ];
+
+    # the entire credit for this dashboard configuration to https://github.com/Rishabh672003
+    # honestly, excellent work
+    vim.luaConfigRC.alpha = entryAnywhere ''
+      local alpha = require("alpha")
+      local plenary_path = require("plenary.path")
+      local dashboard = require("alpha.themes.dashboard")
+      local cdir = vim.fn.getcwd()
+      local if_nil = vim.F.if_nil
+
+      local nvim_web_devicons = {
+      	enabled = true,
+      	highlight = true,
+      }
+
+      local function get_extension(fn)
+      	local match = fn:match("^.+(%..+)$")
+      	local ext = ""
+      	if match ~= nil then
+      		ext = match:sub(2)
+      	end
+      	return ext
+      end
+
+      local function icon(fn)
+      	local nwd = require("nvim-web-devicons")
+      	local ext = get_extension(fn)
+      	return nwd.get_icon(fn, ext, { default = true })
+      end
+
+      local function file_button(fn, sc, short_fn)
+      	short_fn = short_fn or fn
+      	local ico_txt
+      	local fb_hl = {}
+
+      	if nvim_web_devicons.enabled then
+      		local ico, hl = icon(fn)
+      		local hl_option_type = type(nvim_web_devicons.highlight)
+      		if hl_option_type == "boolean" then
+      			if hl and nvim_web_devicons.highlight then
+      				table.insert(fb_hl, { hl, 0, 3 })
+      			end
+      		end
+      		if hl_option_type == "string" then
+      			table.insert(fb_hl, { nvim_web_devicons.highlight, 0, 3 })
+      		end
+      		ico_txt = ico .. "  "
+      	else
+      		ico_txt = ""
+      	end
+      	local file_button_el = dashboard.button(sc, ico_txt .. short_fn, "<cmd>e " .. fn .. " <CR>")
+      	local fn_start = short_fn:match(".*[/\\]")
+      	if fn_start ~= nil then
+      		table.insert(fb_hl, { "Comment", #ico_txt - 2, #fn_start + #ico_txt })
+      	end
+      	file_button_el.opts.hl = fb_hl
+      	return file_button_el
+      end
+
+      local default_mru_ignore = { "gitcommit" }
+
+      local mru_opts = {
+      	ignore = function(path, ext)
+      		return (string.find(path, "COMMIT_EDITMSG")) or (vim.tbl_contains(default_mru_ignore, ext))
+      	end,
+      }
+
+      --- @param start number
+      --- @param cwd string optional
+      --- @param items_number number optional number of items to generate, default = 10
+      local function mru(start, cwd, items_number, opts)
+      	opts = opts or mru_opts
+      	items_number = if_nil(items_number, 15)
+
+      	local oldfiles = {}
+      	for _, v in pairs(vim.v.oldfiles) do
+      		if #oldfiles == items_number then
+      			break
+      		end
+      		local cwd_cond
+      		if not cwd then
+      			cwd_cond = true
+      		else
+      			cwd_cond = vim.startswith(v, cwd)
+      		end
+      		local ignore = (opts.ignore and opts.ignore(v, get_extension(v))) or false
+      		if (vim.fn.filereadable(v) == 1) and cwd_cond and not ignore then
+      			oldfiles[#oldfiles + 1] = v
+      		end
+      	end
+      	local target_width = 35
+
+      	local tbl = {}
+      	for i, fn in ipairs(oldfiles) do
+      		local short_fn
+      		if cwd then
+      			short_fn = vim.fn.fnamemodify(fn, ":.")
+      		else
+      			short_fn = vim.fn.fnamemodify(fn, ":~")
+      		end
+
+      		if #short_fn > target_width then
+      			short_fn = plenary_path.new(short_fn):shorten(1, { -2, -1 })
+      			if #short_fn > target_width then
+      				short_fn = plenary_path.new(short_fn):shorten(1, { -1 })
+      			end
+      		end
+
+      		local shortcut = tostring(i + start - 1)
+
+      		local file_button_el = file_button(fn, shortcut, short_fn)
+      		tbl[i] = file_button_el
+      	end
+      	return {
+      		type = "group",
+      		val = tbl,
+      		opts = {},
+      	}
+      end
+
+      local default_header = {
+      	type = "text",
+      	val = {
+
+      		[[███    ██ ███████  ██████  ██    ██ ██ ███    ███]],
+      		[[████   ██ ██      ██    ██ ██    ██ ██ ████  ████]],
+      		[[██ ██  ██ █████   ██    ██ ██    ██ ██ ██ ████ ██]],
+      		[[██  ██ ██ ██      ██    ██  ██  ██  ██ ██  ██  ██]],
+      		[[██   ████ ███████  ██████    ████   ██ ██      ██]],
+
+      		-- [[                               __                ]],
+      		-- [[  ___     ___    ___   __  __ /\_\    ___ ___    ]],
+      		-- [[ / _ `\  / __`\ / __`\/\ \/\ \\/\ \  / __` __`\  ]],
+      		-- [[/\ \/\ \/\  __//\ \_\ \ \ \_/ |\ \ \/\ \/\ \/\ \ ]],
+      		-- [[\ \_\ \_\ \____\ \____/\ \___/  \ \_\ \_\ \_\ \_\]],
+      		-- [[ \/_/\/_/\/____/\/___/  \/__/    \/_/\/_/\/_/\/_/]],
+      	},
+      	opts = {
+      		position = "center",
+      		hl = "Type",
+      		-- wrap = "overflow";
+      	},
+      }
+
+      local section_mru = {
+      	type = "group",
+      	val = {
+      		{
+      			type = "text",
+      			val = "Recent files",
+      			opts = {
+      				hl = "SpecialComment",
+      				shrink_margin = false,
+      				position = "center",
+      			},
+      		},
+      		{ type = "padding", val = 1 },
+      		{
+      			type = "group",
+      			val = function()
+      				return { mru(0, cdir) }
+      			end,
+      			opts = { shrink_margin = false },
+      		},
+      	},
+      }
+
+      local buttons = {
+      	type = "group",
+      	val = {
+      		{ type = "text", val = "Quick links", opts = { hl = "SpecialComment", position = "center" } },
+      		{ type = "padding", val = 1 },
+          -- TODO: buttons should be added based on whether or not the relevant plugin is available
+      		dashboard.button("e", "  New file", "<cmd>ene<CR>"), -- available all the time
+      		dashboard.button("SPC F", "󰈞  Find file"), -- telescope
+      		dashboard.button("SPC ff", "󰊄  Live grep"), -- telescope
+      		dashboard.button("SPC p", "  Projects"), -- any project
+      		dashboard.button("q", "󰅚  Quit", "<cmd>qa<CR>"), -- available all the time
+      	},
+      	position = "center",
+      }
+
+      local config = {
+      	layout = {
+      		{ type = "padding", val = 2 },
+      		default_header,
+      		{ type = "padding", val = 2 },
+      		section_mru,
+      		{ type = "padding", val = 2 },
+      		buttons,
+      	},
+      	opts = {
+      		margin = 5,
+      		setup = function()
+      			vim.cmd([[
+                  autocmd alpha_temp DirChanged * lua require('alpha').redraw()
+                  ]])
+      		end,
+      	},
+      }
+
+      alpha.setup(config)
+    '';
+  };
+}

modules/plugins/dashboard/alpha/default.nix

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

modules/plugins/dashboard/dashboard-nvim/config.nix

@@ -0,0 +1,20 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.dashboard.dashboard-nvim;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = [
+      "dashboard-nvim"
+    ];
+
+    vim.luaConfigRC.dashboard-nvim = entryAnywhere ''
+      require("dashboard").setup{}
+    '';
+  };
+}

modules/plugins/dashboard/dashboard-nvim/dashboard-nvim.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.dashboard.dashboard-nvim = {
+    enable = mkEnableOption "Fancy and Blazing Fast start screen plugin of neovim [dashboard.nvim]";
+  };
+}

modules/plugins/dashboard/dashboard-nvim/default.nix

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

modules/plugins/dashboard/default.nix

@@ -0,0 +1,7 @@
+{
+  imports = [
+    ./alpha
+    ./dashboard-nvim
+    ./startify
+  ];
+}

modules/plugins/dashboard/startify/config.nix

@@ -0,0 +1,50 @@
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.vim) mkVimBool;
+
+  cfg = config.vim.dashboard.startify;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = with pkgs.vimPlugins; [vim-startify];
+
+    vim.globals = {
+      "startify_custom_header" =
+        if cfg.customHeader == []
+        then null
+        else cfg.customHeader;
+      "startify_custom_footer" =
+        if cfg.customFooter == []
+        then null
+        else cfg.customFooter;
+      "startify_bookmarks" = cfg.bookmarks;
+      "startify_lists" = cfg.lists;
+      "startify_change_to_dir" = mkVimBool cfg.changeToDir;
+      "startify_change_to_vcs_root" = mkVimBool cfg.changeToVCRoot;
+      "startify_change_cmd" = cfg.changeDirCmd;
+      "startify_skiplist" = cfg.skipList;
+      "startify_update_oldfiles" = mkVimBool cfg.updateOldFiles;
+      "startify_session_autoload" = mkVimBool cfg.sessionAutoload;
+      "startify_commands" = cfg.commands;
+      "startify_files_number" = cfg.filesNumber;
+      "startify_custom_indices" = cfg.customIndices;
+      "startify_disable_at_vimenter" = mkVimBool cfg.disableOnStartup;
+      "startify_enable_unsafe" = mkVimBool cfg.unsafe;
+      "startify_padding_left" = cfg.paddingLeft;
+      "startify_use_env" = mkVimBool cfg.useEnv;
+      "startify_session_before_save" = cfg.sessionBeforeSave;
+      "startify_session_persistence" = mkVimBool cfg.sessionPersistence;
+      "startify_session_delete_buffers" = mkVimBool cfg.sessionDeleteBuffers;
+      "startify_session_dir" = cfg.sessionDir;
+      "startify_skiplist_server" = cfg.skipListServer;
+      "startify_session_remove_lines" = cfg.sessionRemoveLines;
+      "startify_session_savevars" = cfg.sessionSavevars;
+      "startify_session_savecmds" = cfg.sessionSavecmds;
+      "startify_session_sort" = mkVimBool cfg.sessionSort;
+    };
+  };
+}

modules/plugins/dashboard/startify/default.nix

@@ -0,0 +1,6 @@
+_: {
+  imports = [
+    ./startify.nix
+    ./config.nix
+  ];
+}

modules/plugins/dashboard/startify/startify.nix

@@ -0,0 +1,190 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) listOf attrs bool enum str oneOf int;
+in {
+  options.vim.dashboard.startify = {
+    enable = mkEnableOption "dashboard via vim-startify";
+
+    bookmarks = mkOption {
+      default = [];
+      description = ''List of book marks to disaply on start page'';
+      type = listOf attrs;
+      example = {"c" = "~/.vimrc";};
+    };
+
+    changeToDir = mkOption {
+      default = true;
+      description = "Should vim change to the directory of the file you open";
+      type = bool;
+    };
+
+    changeToVCRoot = mkOption {
+      default = false;
+      description = "Should vim change to the version control root when opening a file";
+      type = bool;
+    };
+
+    changeDirCmd = mkOption {
+      default = "lcd";
+      description = "Command to change the current window with. Can be cd, lcd or tcd";
+      type = enum ["cd" "lcd" "tcd"];
+    };
+
+    customHeader = mkOption {
+      default = [];
+      description = "Text to place in the header";
+      type = listOf str;
+    };
+
+    customFooter = mkOption {
+      default = [];
+      description = "Text to place in the footer";
+      type = listOf str;
+    };
+
+    lists = mkOption {
+      default = [
+        {
+          type = "files";
+          header = ["MRU"];
+        }
+        {
+          type = "dir";
+          header = ["MRU Current Directory"];
+        }
+        {
+          type = "sessions";
+          header = ["Sessions"];
+        }
+        {
+          type = "bookmarks";
+          header = ["Bookmarks"];
+        }
+        {
+          type = "commands";
+          header = ["Commands"];
+        }
+      ];
+      description = "Specify the lists and in what order they are displayed on startify.";
+      type = listOf attrs;
+    };
+
+    skipList = mkOption {
+      default = [];
+      description = "List of regex patterns to exclude from MRU lists";
+      type = listOf str;
+    };
+
+    updateOldFiles = mkOption {
+      default = false;
+      description = "Set if you want startify to always update and not just when neovim closes";
+      type = bool;
+    };
+
+    sessionAutoload = mkOption {
+      default = false;
+      description = "Make startify auto load Session.vim files from the current directory";
+      type = bool;
+    };
+
+    commands = mkOption {
+      default = [];
+      description = "Commands that are presented to the user on startify page";
+      type = listOf (oneOf [str attrs (listOf str)]);
+    };
+
+    filesNumber = mkOption {
+      default = 10;
+      description = "How many files to list";
+      type = int;
+    };
+
+    customIndices = mkOption {
+      default = [];
+      description = "Specify a list of default charecters to use instead of numbers";
+      type = listOf str;
+    };
+
+    disableOnStartup = mkOption {
+      default = false;
+      description = "Prevent startify from opening on startup but can be called with :Startify";
+      type = bool;
+    };
+
+    unsafe = mkOption {
+      default = false;
+      description = "Turns on unsafe mode for Startify. Stops resolving links, checking files are readable and filtering bookmark list";
+      type = bool;
+    };
+
+    paddingLeft = mkOption {
+      default = 3;
+      description = "Number of spaces used for left padding.";
+      type = int;
+    };
+
+    useEnv = mkOption {
+      default = false;
+      description = "Show environment variables in path if name is shorter than value";
+      type = bool;
+    };
+
+    sessionBeforeSave = mkOption {
+      default = [];
+      description = "Commands to run before saving a session";
+      type = listOf str;
+    };
+
+    sessionPersistence = mkOption {
+      default = false;
+      description = "Persist session before leaving vim or switching session";
+      type = bool;
+    };
+
+    sessionDeleteBuffers = mkOption {
+      default = true;
+      description = "Delete all buffers when loading or closing a session";
+      type = bool;
+    };
+
+    sessionDir = mkOption {
+      default = "~/.vim/session";
+      description = "Directory to save and load sessions from";
+      type = str;
+    };
+
+    skipListServer = mkOption {
+      default = [];
+      description = "List of vim servers to not load startify for";
+      type = listOf str;
+    };
+
+    sessionRemoveLines = mkOption {
+      default = [];
+      description = "Patterns to remove from session files";
+      type = listOf str;
+    };
+
+    sessionSavevars = mkOption {
+      default = [];
+      description = "List of variables to save into a session file.";
+      type = listOf str;
+    };
+
+    sessionSavecmds = mkOption {
+      default = [];
+      description = "List of commands to run when loading a session.";
+      type = listOf str;
+    };
+
+    sessionSort = mkOption {
+      default = false;
+      description = "Set if you want items sorted by date rather than alphabetically";
+      type = bool;
+    };
+  };
+}

modules/plugins/debugger/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./nvim-dap
+  ];
+}

modules/plugins/debugger/nvim-dap/config.nix

@@ -0,0 +1,72 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.attrsets) mapAttrs;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
+
+  cfg = config.vim.debugger.nvim-dap;
+  self = import ./nvim-dap.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.debugger.nvim-dap.mappings;
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
+in {
+  config = mkMerge [
+    (mkIf cfg.enable {
+      vim.startPlugins = ["nvim-dap"];
+
+      vim.luaConfigRC =
+        {
+          # TODO customizable keymaps
+          nvim-dap = entryAnywhere ''
+            local dap = require("dap")
+            vim.fn.sign_define("DapBreakpoint", { text = "🛑", texthl = "ErrorMsg", linehl = "", numhl = "" })
+          '';
+        }
+        // mapAttrs (_: v: (entryAfter ["nvim-dap"] v)) cfg.sources;
+
+      vim.maps.normal = mkMerge [
+        (mkSetLuaBinding mappings.continue "require('dap').continue")
+        (mkSetLuaBinding mappings.restart "require('dap').restart")
+        (mkSetLuaBinding mappings.terminate "require('dap').terminate")
+        (mkSetLuaBinding mappings.runLast "require('dap').run_last")
+
+        (mkSetLuaBinding mappings.toggleRepl "require('dap').repl.toggle")
+        (mkSetLuaBinding mappings.hover "require('dap.ui.widgets').hover")
+        (mkSetLuaBinding mappings.toggleBreakpoint "require('dap').toggle_breakpoint")
+
+        (mkSetLuaBinding mappings.runToCursor "require('dap').run_to_cursor")
+        (mkSetLuaBinding mappings.stepInto "require('dap').step_into")
+        (mkSetLuaBinding mappings.stepOut "require('dap').step_out")
+        (mkSetLuaBinding mappings.stepOver "require('dap').step_over")
+        (mkSetLuaBinding mappings.stepBack "require('dap').step_back")
+
+        (mkSetLuaBinding mappings.goUp "require('dap').up")
+        (mkSetLuaBinding mappings.goDown "require('dap').down")
+      ];
+    })
+    (mkIf (cfg.enable && cfg.ui.enable) {
+      vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
+
+      vim.luaConfigRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
+          local dapui = require("dapui")
+          dapui.setup()
+        ''
+        + optionalString cfg.ui.autoStart ''
+          dap.listeners.after.event_initialized["dapui_config"] = function()
+            dapui.open()
+          end
+          dap.listeners.before.event_terminated["dapui_config"] = function()
+            dapui.close()
+          end
+          dap.listeners.before.event_exited["dapui_config"] = function()
+            dapui.close()
+          end
+        '');
+      vim.maps.normal = mkSetLuaBinding mappings.toggleDapUI "require('dapui').toggle";
+    })
+  ];
+}

modules/plugins/debugger/nvim-dap/default.nix

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

modules/plugins/debugger/nvim-dap/nvim-dap.nix

@@ -0,0 +1,46 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) bool attrsOf str;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.debugger.nvim-dap = {
+    enable = mkEnableOption "debugging via nvim-dap";
+
+    ui = {
+      enable = mkEnableOption "UI extension for nvim-dap";
+      autoStart = mkOption {
+        type = bool;
+        default = true;
+        description = "Automatically Opens and Closes DAP-UI upon starting/closing a debugging session";
+      };
+    };
+
+    sources = mkOption {
+      default = {};
+      description = "List of debuggers to install";
+      type = attrsOf str;
+    };
+
+    mappings = {
+      continue = mkMappingOption "Contiue" "<leader>dc";
+      restart = mkMappingOption "Restart" "<leader>dR";
+      terminate = mkMappingOption "Terminate" "<leader>dq";
+      runLast = mkMappingOption "Re-run Last Debug Session" "<leader>d.";
+
+      toggleRepl = mkMappingOption "Toggle Repl" "<leader>dr";
+      hover = mkMappingOption "Hover" "<leader>dh";
+      toggleBreakpoint = mkMappingOption "Toggle breakpoint" "<leader>db";
+
+      runToCursor = mkMappingOption "Continue to the current cursor" "<leader>dgc";
+      stepInto = mkMappingOption "Step into function" "<leader>dgi";
+      stepOut = mkMappingOption "Step out of function" "<leader>dgo";
+      stepOver = mkMappingOption "Next step" "<leader>dgj";
+      stepBack = mkMappingOption "Step back" "<leader>dgk";
+
+      goUp = mkMappingOption "Go up stacktrace" "<leader>dvo";
+      goDown = mkMappingOption "Go down stacktrace" "<leader>dvi";
+
+      toggleDapUI = mkMappingOption "Toggle DAP-UI" "<leader>du";
+    };
+  };
+}

modules/plugins/filetree/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./nvimtree
+  ];
+}

modules/plugins/filetree/nvimtree/config.nix

@@ -0,0 +1,85 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+  # TODO: move this to its own module
+  inherit (lib) pushDownDefault;
+
+  cfg = config.vim.filetree.nvimTree;
+  self = import ./nvimtree.nix {inherit pkgs lib;};
+  inherit (self.options.vim.filetree.nvimTree) mappings;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = ["nvim-tree-lua"];
+
+    vim.maps.normal = mkMerge [
+      (mkBinding cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
+      (mkBinding cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
+      (mkBinding cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
+      (mkBinding cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
+    ];
+
+    vim.binds.whichKey.register = pushDownDefault {
+      "<leader>t" = "+NvimTree";
+    };
+
+    vim.luaConfigRC.nvimtreelua = entryAnywhere ''
+      ${
+        optionalString cfg.disableNetrw ''
+          -- disable netrew completely
+          vim.g.loaded_netrw = 1
+          vim.g.loaded_netrwPlugin = 1
+        ''
+      }
+
+      require'nvim-tree'.setup(${toLuaObject cfg.setupOpts})
+
+      ${
+        optionalString cfg.openOnSetup ''
+          -- autostart behaviour
+          -- Open on startup has been deprecated
+          -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup
+
+          -- use a nix eval to dynamically insert the open on startup function
+          local function open_nvim_tree(data)
+            local IGNORED_FT = {
+              "markdown",
+            }
+
+            -- buffer is a real file on the disk
+            local real_file = vim.fn.filereadable(data.file) == 1
+
+            -- buffer is a [No Name]
+              local no_name = data.file == "" and vim.bo[data.buf].buftype == ""
+
+            -- &ft
+            local filetype = vim.bo[data.buf].ft
+
+            -- only files please
+            if not real_file and not no_name then
+              return
+            end
+
+            -- skip ignored filetypes
+            if vim.tbl_contains(IGNORED_FT, filetype) then
+              return
+            end
+
+            -- open the tree but don't focus it
+            require("nvim-tree.api").tree.toggle({ focus = false })
+          end
+
+          -- function to automatically open the tree on VimEnter
+          vim.api.nvim_create_autocmd({ "VimEnter" }, { callback = open_nvim_tree })
+        ''
+      }
+    '';
+  };
+}

modules/plugins/filetree/nvimtree/default.nix

@@ -0,0 +1,6 @@
+_: {
+  imports = [
+    ./config.nix
+    ./nvimtree.nix
+  ];
+}

modules/plugins/git/config.nix

@@ -0,0 +1,88 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (builtins) toJSON;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetExprBinding mkSetLuaBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
+  # TODO: move this to its own module
+  inherit (lib) pushDownDefault;
+
+  cfg = config.vim.git;
+
+  self = import ./git.nix {inherit lib config;};
+  gsMappingDefinitions = self.options.vim.git.gitsigns.mappings;
+
+  gsMappings = addDescriptionsToMappings cfg.gitsigns.mappings gsMappingDefinitions;
+in {
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.gitsigns.enable (mkMerge [
+      {
+        vim.startPlugins = ["gitsigns-nvim"];
+
+        vim.maps.normal = mkMerge [
+          (mkSetExprBinding gsMappings.nextHunk ''
+            function()
+              if vim.wo.diff then return ${toJSON gsMappings.nextHunk.value} end
+
+              vim.schedule(function() package.loaded.gitsigns.next_hunk() end)
+
+              return '<Ignore>'
+            end
+          '')
+          (mkSetExprBinding gsMappings.previousHunk ''
+            function()
+              if vim.wo.diff then return ${toJSON gsMappings.previousHunk.value} end
+
+              vim.schedule(function() package.loaded.gitsigns.prev_hunk() end)
+
+              return '<Ignore>'
+            end
+          '')
+
+          (mkSetLuaBinding gsMappings.stageHunk "package.loaded.gitsigns.stage_hunk")
+          (mkSetLuaBinding gsMappings.resetHunk "package.loaded.gitsigns.reset_hunk")
+          (mkSetLuaBinding gsMappings.undoStageHunk "package.loaded.gitsigns.undo_stage_hunk")
+
+          (mkSetLuaBinding gsMappings.stageBuffer "package.loaded.gitsigns.stage_buffer")
+          (mkSetLuaBinding gsMappings.resetBuffer "package.loaded.gitsigns.reset_buffer")
+
+          (mkSetLuaBinding gsMappings.previewHunk "package.loaded.gitsigns.preview_hunk")
+
+          (mkSetLuaBinding gsMappings.blameLine "function() package.loaded.gitsigns.blame_line{full=true} end")
+          (mkSetLuaBinding gsMappings.toggleBlame "package.loaded.gitsigns.toggle_current_line_blame")
+
+          (mkSetLuaBinding gsMappings.diffThis "package.loaded.gitsigns.diffthis")
+          (mkSetLuaBinding gsMappings.diffProject "function() package.loaded.gitsigns.diffthis('~') end")
+
+          (mkSetLuaBinding gsMappings.toggleDeleted "package.loaded.gitsigns.toggle_deleted")
+        ];
+
+        vim.maps.visual = mkMerge [
+          (mkSetLuaBinding gsMappings.stageHunk "function() package.loaded.gitsigns.stage_hunk {vim.fn.line('.'), vim.fn.line('v')} end")
+          (mkSetLuaBinding gsMappings.resetHunk "function() package.loaded.gitsigns.reset_hunk {vim.fn.line('.'), vim.fn.line('v')} end")
+        ];
+
+        vim.binds.whichKey.register = pushDownDefault {
+          "<leader>g" = "+Gitsigns";
+        };
+
+        vim.luaConfigRC.gitsigns = entryAnywhere ''
+          require('gitsigns').setup{}
+        '';
+      }
+
+      (mkIf cfg.gitsigns.codeActions {
+        vim.lsp.null-ls.enable = true;
+        vim.lsp.null-ls.sources.gitsigns-ca = ''
+          table.insert(
+            ls_sources,
+            null_ls.builtins.code_actions.gitsigns
+          )
+        '';
+      })
+    ]))
+  ]);
+}

modules/plugins/git/default.nix

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

modules/plugins/git/git.nix

@@ -0,0 +1,40 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.git = {
+    enable = mkEnableOption "git integration";
+
+    gitsigns = {
+      enable = mkEnableOption "gitsigns" // {default = config.vim.git.enable;};
+
+      mappings = {
+        nextHunk = mkMappingOption "Next hunk [Gitsigns]" "]c";
+        previousHunk = mkMappingOption "Previous hunk [Gitsigns]" "[c";
+
+        stageHunk = mkMappingOption "Stage hunk [Gitsigns]" "<leader>hs";
+        undoStageHunk = mkMappingOption "Undo stage hunk [Gitsigns]" "<leader>hu";
+        resetHunk = mkMappingOption "Reset hunk [Gitsigns]" "<leader>hr";
+
+        stageBuffer = mkMappingOption "Stage buffer [Gitsigns]" "<leader>hS";
+        resetBuffer = mkMappingOption "Reset buffer [Gitsigns]" "<leader>hR";
+
+        previewHunk = mkMappingOption "Preview hunk [Gitsigns]" "<leader>hP";
+
+        blameLine = mkMappingOption "Blame line [Gitsigns]" "<leader>hb";
+        toggleBlame = mkMappingOption "Toggle blame [Gitsigns]" "<leader>tb";
+
+        diffThis = mkMappingOption "Diff this [Gitsigns]" "<leader>hd";
+        diffProject = mkMappingOption "Diff project [Gitsigns]" "<leader>hD";
+
+        toggleDeleted = mkMappingOption "Toggle deleted [Gitsigns]" "<leader>td";
+      };
+
+      codeActions = mkEnableOption "gitsigns codeactions through null-ls";
+    };
+  };
+}

modules/plugins/languages/bash/bash.nix

@@ -0,0 +1,117 @@
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either package listOf str bool;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption;
+
+  cfg = config.vim.languages.bash;
+
+  defaultServer = "bash-ls";
+  servers = {
+    bash-ls = {
+      package = pkgs.nodePackages.bash-language-server;
+      lspConfig = ''
+        lspconfig.bashls.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/bash-language-server",  "start"}''
+        };
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "shfmt";
+  formats = {
+    shfmt = {
+      package = pkgs.shfmt;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.shfmt.with({
+            command = "${pkgs.shfmt}/bin/shfmt",
+          })
+        )
+      '';
+    };
+  };
+
+  defaultDiagnosticsProvider = ["shellcheck"];
+  diagnosticsProviders = {
+    shellcheck = {
+      package = pkgs.shellcheck;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.shellcheck.with({
+            command = "${pkg}/bin/shellcheck",
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.bash = {
+    enable = mkEnableOption "Bash language support";
+
+    treesitter = {
+      enable = mkEnableOption "Bash treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "bash";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Bash LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "bash-language-server package, or the command to run as a list of strings";
+        example = literalExpression ''[lib.getExe pkgs.nodePackages.bash-language-server "start"]'';
+        type = either package (listOf str);
+        default = pkgs.nodePackages.bash-language-server;
+      };
+    };
+
+    format = {
+      enable = mkOption {
+        description = "Enable Bash formatting";
+        type = bool;
+        default = config.vim.languages.enableFormat;
+      };
+      type = mkOption {
+        description = "Bash formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "Bash formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Bash diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Bash";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+}

modules/plugins/languages/bash/config.nix

@@ -0,0 +1,83 @@
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.lists) isList;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+
+  cfg = config.vim.languages.bash;
+  diagnosticsProviders = {
+    shellcheck = {
+      package = pkgs.shellcheck;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.shellcheck.with({
+            command = "${pkg}/bin/shellcheck",
+          })
+        )
+      '';
+    };
+  };
+
+  formats = {
+    shfmt = {
+      package = pkgs.shfmt;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.shfmt.with({
+            command = "${pkgs.shfmt}/bin/shfmt",
+          })
+        )
+      '';
+    };
+  };
+
+  servers = {
+    bash-ls = {
+      package = pkgs.nodePackages.bash-language-server;
+      lspConfig = ''
+        lspconfig.bashls.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/bash-language-server",  "start"}''
+        };
+        }
+      '';
+    };
+  };
+in {
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.bash-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.bash-format = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "bash";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+  ]);
+}

modules/plugins/languages/bash/default.nix

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

modules/plugins/languages/clang.nix

@@ -0,0 +1,163 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.lists) isList;
+  inherit (lib.strings) optionalString;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) bool enum package either listOf str nullOr;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  packageToCmd = package: defaultCmd:
+    if isList cfg.lsp.package
+    then expToLua cfg.lsp.package
+    else ''{ "${cfg.lsp.package}/bin/${defaultCmd}" }'';
+
+  cfg = config.vim.languages.clang;
+
+  defaultServer = "ccls";
+  servers = {
+    ccls = {
+      package = pkgs.ccls;
+      lspConfig = ''
+        lspconfig.ccls.setup{
+          capabilities = capabilities;
+          on_attach=default_on_attach;
+          cmd = ${packageToCmd cfg.lsp.package "ccls"};
+          ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.opts}"}
+        }
+      '';
+    };
+    clangd = {
+      package = pkgs.clang-tools_16;
+      lspConfig = ''
+        local clangd_cap = capabilities
+        -- use same offsetEncoding as null-ls
+        clangd_cap.offsetEncoding = {"utf-16"}
+        lspconfig.clangd.setup{
+          capabilities = clangd_cap;
+          on_attach=default_on_attach;
+          cmd = ${packageToCmd cfg.lsp.package "clangd"};
+          ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.opts}"}
+        }
+      '';
+    };
+  };
+
+  defaultDebugger = "lldb-vscode";
+  debuggers = {
+    lldb-vscode = {
+      package = pkgs.lldb;
+      dapConfig = ''
+        dap.adapters.lldb = {
+          type = 'executable',
+          command = '${cfg.dap.package}/bin/lldb-vscode',
+          name = 'lldb'
+        }
+        dap.configurations.cpp = {
+          {
+            name = 'Launch',
+            type = 'lldb',
+            request = 'launch',
+            program = function()
+              return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
+            end,
+            cwd = "''${workspaceFolder}",
+            stopOnEntry = false,
+            args = {},
+          },
+        }
+
+        dap.configurations.c = dap.configurations.cpp
+      '';
+    };
+  };
+in {
+  options.vim.languages.clang = {
+    enable = mkEnableOption "C/C++ language support";
+
+    cHeader = mkOption {
+      description = ''
+        C syntax for headers. Can fix treesitter errors, see:
+        https://www.reddit.com/r/neovim/comments/orfpcd/question_does_the_c_parser_from_nvimtreesitter/
+      '';
+      type = bool;
+      default = false;
+    };
+
+    treesitter = {
+      enable = mkEnableOption "C/C++ treesitter" // {default = config.vim.languages.enableTreesitter;};
+      cPackage = mkGrammarOption pkgs "c";
+      cppPackage = mkGrammarOption pkgs "cpp";
+    };
+
+    lsp = {
+      enable = mkEnableOption "clang LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "The clang LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "clang 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;
+      };
+
+      opts = mkOption {
+        description = "Options to pass to clang LSP server";
+        type = nullOr str;
+        default = null;
+      };
+    };
+
+    dap = {
+      enable = mkOption {
+        description = "Enable clang Debug Adapter";
+        type = bool;
+        default = config.vim.languages.enableDAP;
+      };
+      debugger = mkOption {
+        description = "clang debugger to use";
+        type = enum (attrNames debuggers);
+        default = defaultDebugger;
+      };
+      package = mkOption {
+        description = "clang debugger package.";
+        type = package;
+        default = debuggers.${cfg.dap.debugger}.package;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.cHeader {
+      vim.configRC.c-header = entryAnywhere "let g:c_syntax_for_h = 1";
+    })
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.cPackage cfg.treesitter.cppPackage];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+
+      vim.lsp.lspconfig.sources.clang-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.dap.enable {
+      vim.debugger.nvim-dap.enable = true;
+      vim.debugger.nvim-dap.sources.clang-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
+    })
+  ]);
+}

modules/plugins/languages/css.nix

@@ -0,0 +1,79 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.css;
+
+  defaultServer = "vscode-langservers-extracted";
+  servers = {
+    vscode-langservers-extracted = {
+      package = pkgs.nodePackages.vscode-langservers-extracted;
+      lspConfig = ''
+        -- enable (broadcasting) snippet capability for completion
+        -- see <https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#cssls>
+        local css_capabilities = vim.lsp.protocol.make_client_capabilities()
+        css_capabilities.textDocument.completion.completionItem.snippetSupport = true
+
+        -- cssls setup
+        lspconfig.cssls.setup {
+          capabilities = css_capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/vscode-css-language-server", "--stdio"}''
+        }
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.css = {
+    enable = mkEnableOption "CSS language support";
+
+    treesitter = {
+      enable = mkEnableOption "CSS treesitter" // {default = config.vim.languages.enableTreesitter;};
+
+      package = mkGrammarOption pkgs "css";
+    };
+
+    lsp = {
+      enable = mkEnableOption "CSS LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "CSS LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "CSS 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.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.tailwindcss-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+  ]);
+}

modules/plugins/languages/dart/config.nix

@@ -0,0 +1,76 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.lists) isList;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.strings) optionalString;
+  inherit (lib.trivial) boolToString;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.languages.dart;
+  ftcfg = cfg.flutter-tools;
+  servers = {
+    dart = {
+      package = pkgs.dart;
+      lspConfig = ''
+        lspconfig.dartls.setup{
+          capabilities = capabilities;
+          on_attach=default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/dart", "language-server", "--protocol=lsp"}''
+        };
+          ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.dartOpts}"}
+        }
+      '';
+    };
+  };
+in {
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+
+      vim.lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf ftcfg.enable {
+      vim.startPlugins =
+        if ftcfg.enableNoResolvePatch
+        then ["flutter-tools-patched"]
+        else ["flutter-tools"];
+
+      vim.luaConfigRC.flutter-tools = entryAnywhere ''
+        require('flutter-tools').setup {
+          lsp = {
+            color = { -- show the derived colours for dart variables
+              enabled = ${boolToString ftcfg.color.enable}, -- whether or not to highlight color variables at all, only supported on flutter >= 2.10
+              background = ${boolToString ftcfg.color.highlightBackground}, -- highlight the background
+              foreground = ${boolToString ftcfg.color.highlightForeground}, -- highlight the foreground
+              virtual_text = ${boolToString ftcfg.color.virtualText.enable}, -- show the highlight using virtual text
+              virtual_text_str = ${ftcfg.color.virtualText.character} -- the virtual text character to highlight
+            },
+
+            capabilities = capabilities,
+            on_attach = default_on_attach;
+            flags = lsp_flags,
+          },
+          ${optionalString cfg.dap.enable ''
+          debugger = {
+            enabled = true,
+          },
+        ''}
+        }
+      '';
+    })
+  ]);
+}

modules/plugins/languages/dart/dart.nix

@@ -0,0 +1,115 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.lists) isList;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum either listOf package nullOr str bool;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.dart;
+  defaultServer = "dart";
+  servers = {
+    dart = {
+      package = pkgs.dart;
+      lspConfig = ''
+        lspconfig.dartls.setup{
+          capabilities = capabilities;
+          on_attach=default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/dart", "language-server", "--protocol=lsp"}''
+        };
+          ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.dartOpts}"}
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.dart = {
+    enable = mkEnableOption "Dart language support";
+
+    treesitter = {
+      enable = mkEnableOption "Dart treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "dart";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Dart LSP support";
+      server = mkOption {
+        description = "The Dart LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+      package = mkOption {
+        description = "Dart 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;
+      };
+      opts = mkOption {
+        description = "Options to pass to Dart LSP server";
+        type = nullOr str;
+        default = null;
+      };
+    };
+
+    dap = {
+      enable = mkOption {
+        description = "Enable Dart DAP support via flutter-tools";
+        type = bool;
+        default = config.vim.languages.enableDAP;
+      };
+    };
+
+    flutter-tools = {
+      enable = mkOption {
+        description = "Enable flutter-tools for flutter support";
+        type = bool;
+        default = config.vim.languages.enableLSP;
+      };
+
+      enableNoResolvePatch = mkOption {
+        description = ''
+          Patch flutter-tools so that it doesn't resolve symlinks when detecting flutter path.
+          This is required if you want to use a flutter package built with nix.
+          If you are using a flutter SDK installed from a different source and encounter the error "`dart` missing from PATH", disable this option.
+        '';
+        type = bool;
+        default = true;
+      };
+
+      color = {
+        enable = mkEnableOption "Whether or mot to highlight color variables at all";
+
+        highlightBackground = mkOption {
+          type = bool;
+          default = false;
+          description = "Highlight the background";
+        };
+
+        highlightForeground = mkOption {
+          type = bool;
+          default = false;
+          description = "Highlight the foreground";
+        };
+
+        virtualText = {
+          enable = mkEnableOption "Show the highlight using virtual text";
+
+          character = mkOption {
+            type = str;
+            default = "■";
+            description = "Virtual text character to highlight";
+          };
+        };
+      };
+    };
+  };
+}

modules/plugins/languages/dart/default.nix

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

modules/plugins/languages/default.nix

@@ -0,0 +1,37 @@
+{lib, ...}: let
+  inherit (lib.nvim.languages) mkEnable;
+in {
+  imports = [
+    ./bash
+    ./dart
+    ./elixir
+    ./markdown
+    ./tidal
+
+    ./clang.nix
+    ./css.nix
+    ./go.nix
+    ./html.nix
+    ./java.nix
+    ./lua.nix
+    ./nim.nix
+    ./nix.nix
+    ./php.nix
+    ./python.nix
+    ./rust.nix
+    ./sql.nix
+    ./svelte.nix
+    ./tailwind.nix
+    ./terraform.nix
+    ./ts.nix
+    ./zig.nix
+  ];
+
+  options.vim.languages = {
+    enableLSP = mkEnable "LSP";
+    enableDAP = mkEnable "Debug Adapter";
+    enableTreesitter = mkEnable "Treesitter";
+    enableFormat = mkEnable "Formatting";
+    enableExtraDiagnostics = mkEnable "extra diagnostics";
+  };
+}

modules/plugins/languages/elixir/config.nix

@@ -0,0 +1,67 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.languages.elixir;
+in {
+  config = mkIf (cfg.enable) {
+    vim.startPlugins = [
+      "elixir-tools"
+    ];
+
+    vim.luaConfigRC.elixir-tools = entryAnywhere ''
+        local elixir = require("elixir")
+        local elixirls = require("elixir.elixirls")
+
+        elixir.setup {
+          elixirls = {
+          -- alternatively, point to an existing elixir-ls installation (optional)
+          -- not currently supported by elixirls, but can be a table if you wish to pass other args `{"path/to/elixirls", "--foo"}`
+          cmd = "${getExe pkgs.elixir-ls}",
+
+          -- default settings, use the `settings` function to override settings
+          settings = elixirls.settings {
+            dialyzerEnabled = true,
+            fetchDeps = false,
+            enableTestLenses = false,
+            suggestSpecs = false,
+          },
+
+          on_attach = function(client, bufnr)
+            local map_opts = { buffer = true, noremap = true}
+
+            -- run the codelens under the cursor
+            vim.keymap.set("n", "<space>r",  vim.lsp.codelens.run, map_opts)
+            -- remove the pipe operator
+            vim.keymap.set("n", "<space>fp", ":ElixirFromPipe<cr>", map_opts)
+            -- add the pipe operator
+            vim.keymap.set("n", "<space>tp", ":ElixirToPipe<cr>", map_opts)
+            vim.keymap.set("v", "<space>em", ":ElixirExpandMacro<cr>", map_opts)
+
+            -- bindings for standard LSP functions.
+            vim.keymap.set("n", "<space>df", "<cmd>lua vim.lsp.buf.format()<cr>", map_opts)
+            vim.keymap.set("n", "<space>gd", "<cmd>lua vim.diagnostic.open_float()<cr>", map_opts)
+            vim.keymap.set("n", "<space>dt", "<cmd>lua vim.lsp.buf.definition()<cr>", map_opts)
+            vim.keymap.set("n", "<space>K", "<cmd>lua vim.lsp.buf.hover()<cr>", map_opts)
+            vim.keymap.set("n", "<space>gD","<cmd>lua vim.lsp.buf.implementation()<cr>", map_opts)
+            vim.keymap.set("n", "<space>1gD","<cmd>lua vim.lsp.buf.type_definition()<cr>", map_opts)
+
+            -- keybinds for fzf-lsp.nvim: https://github.com/gfanto/fzf-lsp.nvim
+            -- you could also use telescope.nvim: https://github.com/nvim-telescope/telescope.nvim
+            -- there are also core vim.lsp functions that put the same data in the loclist
+            vim.keymap.set("n", "<space>gr", ":References<cr>", map_opts)
+            vim.keymap.set("n", "<space>g0", ":DocumentSymbols<cr>", map_opts)
+            vim.keymap.set("n", "<space>gW", ":WorkspaceSymbols<cr>", map_opts)
+            vim.keymap.set("n", "<leader>d", ":Diagnostics<cr>", map_opts)
+          end
+        }
+      }
+    '';
+  };
+}

modules/plugins/languages/elixir/default.nix

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

modules/plugins/languages/elixir/elixir-tools.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.languages.elixir = {
+    enable = mkEnableOption "Elixir language support";
+  };
+}

modules/plugins/languages/go.nix

@@ -0,0 +1,138 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
+  inherit (lib.types) bool enum either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.go;
+
+  defaultServer = "gopls";
+  servers = {
+    gopls = {
+      package = pkgs.gopls;
+      lspConfig = ''
+        lspconfig.gopls.setup {
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/gopls", "serve"}''
+        },
+        }
+      '';
+    };
+  };
+
+  defaultDebugger = "delve";
+  debuggers = {
+    delve = {
+      package = pkgs.delve;
+      dapConfig = ''
+        dap.adapters.delve = {
+          type = "server",
+          port = "''${port}",
+          executable = {
+            command = "${getExe cfg.dap.package}",
+            args = { "dap", "-l", "127.0.0.1:''${port}" },
+          },
+        }
+
+        dap.configurations.go = {
+          {
+            type = "delve",
+            name = "Debug",
+            request = "launch",
+            program = "''${file}",
+          },
+          {
+            type = "delve",
+            name = "Debug test", -- configuration for debugging test files
+            request = "launch",
+            mode = "test",
+            program = "''${file}",
+          },
+          -- works with go.mod packages and sub packages
+          {
+            type = "delve",
+            name = "Debug test (go.mod)",
+            request = "launch",
+            mode = "test",
+            program = "./''${relativeFileDirname}",
+          },
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.go = {
+    enable = mkEnableOption "Go language support";
+
+    treesitter = {
+      enable = mkEnableOption "Go treesitter" // {default = config.vim.languages.enableTreesitter;};
+
+      package = mkGrammarOption pkgs "go";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Go LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Go LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Go 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;
+      };
+    };
+
+    dap = {
+      enable = mkOption {
+        description = "Enable Go Debug Adapter";
+        type = bool;
+        default = config.vim.languages.enableDAP;
+      };
+      debugger = mkOption {
+        description = "Go debugger to use";
+        type = enum (attrNames debuggers);
+        default = defaultDebugger;
+      };
+      package = mkOption {
+        description = "Go debugger package.";
+        type = package;
+        default = debuggers.${cfg.dap.debugger}.package;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.go-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.dap.enable {
+      vim.debugger.nvim-dap.enable = true;
+      vim.debugger.nvim-dap.sources.go-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
+    })
+  ]);
+}

modules/plugins/languages/html.nix

@@ -0,0 +1,45 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.types) bool;
+  inherit (lib.lists) optional;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.languages.html;
+in {
+  options.vim.languages.html = {
+    enable = mkEnableOption "HTML language support";
+    treesitter = {
+      enable = mkEnableOption "HTML treesitter support" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "html";
+      autotagHtml = mkOption {
+        description = "Enable autoclose/autorename of html tags (nvim-ts-autotag)";
+        type = bool;
+        default = true;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim = {
+        startPlugins = optional cfg.treesitter.autotagHtml "nvim-ts-autotag";
+
+        treesitter = {
+          enable = true;
+          grammars = [cfg.treesitter.package];
+        };
+
+        luaConfigRC.html-autotag = mkIf cfg.treesitter.autotagHtml (entryAnywhere ''
+          require('nvim-ts-autotag').setup()
+        '');
+      };
+    })
+  ]);
+}

modules/plugins/languages/java.nix

@@ -0,0 +1,57 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
+  inherit (lib.types) either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.java;
+in {
+  options.vim.languages.java = {
+    enable = mkEnableOption "Java language support";
+
+    treesitter = {
+      enable = mkEnableOption "Java treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "java";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.languages.enableLSP;};
+      package = mkOption {
+        description = "java language 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 = pkgs.jdt-language-server;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.jdtls = ''
+        lspconfig.jdtls.setup {
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${getExe cfg.lsp.package}", "-data", vim.fn.stdpath("cache").."/jdtls/workspace"}''
+        },
+        }
+      '';
+    })
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+  ]);
+}

modules/plugins/languages/lua.nix

@@ -0,0 +1,70 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
+  inherit (lib.strings) optionalString;
+  inherit (lib.types) either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.dag) entryBefore;
+
+  cfg = config.vim.languages.lua;
+in {
+  options.vim.languages.lua = {
+    enable = mkEnableOption "Lua language support";
+    treesitter = {
+      enable = mkEnableOption "Lua Treesitter support" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "lua";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.languages.enableLSP;};
+
+      package = mkOption {
+        description = "LuaLS package, or the command to run as a list of strings";
+        type = either package (listOf str);
+        default = pkgs.lua-language-server;
+      };
+
+      neodev.enable = mkEnableOption "neodev.nvim integration, useful for neovim plugin developers";
+    };
+  };
+
+  config = mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.enable (mkMerge [
+      (mkIf cfg.lsp.enable {
+        vim.lsp.lspconfig.enable = true;
+        vim.lsp.lspconfig.sources.lua-lsp = ''
+          lspconfig.lua_ls.setup {
+            capabilities = capabilities;
+            on_attach = default_on_attach;
+            ${optionalString cfg.lsp.neodev.enable "before_init = require('neodev.lsp').before_init;"}
+            cmd = ${
+            if isList cfg.lsp.package
+            then expToLua cfg.lsp.package
+            else ''{"${getExe cfg.lsp.package}"}''
+          };
+          }
+        '';
+      })
+
+      (mkIf cfg.lsp.neodev.enable {
+        vim.startPlugins = ["neodev-nvim"];
+        vim.luaConfigRC.neodev = entryBefore ["lua-lsp"] ''
+          require("neodev").setup({})
+        '';
+      })
+    ]))
+  ];
+}

modules/plugins/languages/markdown/config.nix

@@ -0,0 +1,40 @@
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+
+  cfg = config.vim.languages.markdown;
+  servers = {
+    marksman = {
+      package = pkgs.marksman;
+      lspConfig = ''
+        lspconfig.marksman.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/marksman", "server"}''
+        },
+        }
+      '';
+    };
+  };
+in {
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.mdPackage cfg.treesitter.mdInlinePackage];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.markdown-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+  ]);
+}

modules/plugins/languages/markdown/default.nix

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

modules/plugins/languages/markdown/markdown.nix

@@ -0,0 +1,63 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.lists) isList;
+  inherit (lib.types) bool enum either package listOf str;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.markdown;
+  defaultServer = "marksman";
+  servers = {
+    marksman = {
+      package = pkgs.marksman;
+      lspConfig = ''
+        lspconfig.marksman.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/marksman", "server"}''
+        },
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.markdown = {
+    enable = mkEnableOption "Markdown markup language support";
+
+    treesitter = {
+      enable = mkOption {
+        description = "Enable Markdown treesitter";
+        type = bool;
+        default = config.vim.languages.enableTreesitter;
+      };
+      mdPackage = mkGrammarOption pkgs "markdown";
+      mdInlinePackage = mkGrammarOption pkgs "markdown-inline";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Markdown LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Markdown 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;
+      };
+    };
+  };
+}

modules/plugins/languages/nim.nix

@@ -0,0 +1,117 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.nim;
+
+  defaultServer = "nimlsp";
+  servers = {
+    nimlsp = {
+      package = pkgs.nimlsp;
+      lspConfig = ''
+        lspconfig.nimls.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''
+            {"${cfg.lsp.package}/bin/nimlsp"}
+          ''
+        };
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "nimpretty";
+  formats = {
+    nimpretty = {
+      package = pkgs.nim;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.nimpretty.with({
+            command = "${pkgs.nim}/bin/nimpretty",
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.nim = {
+    enable = mkEnableOption "Nim language support";
+
+    treesitter = {
+      enable = mkEnableOption "Nim treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "nim";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Nim LSP support" // {default = config.vim.languages.enableLSP;};
+      server = mkOption {
+        description = "Nim LSP server to use";
+        type = str;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Nim LSP server package, or the command to run as a list of strings";
+        example = ''[lib.getExe pkgs.nimlsp]'';
+        type = either package (listOf str);
+        default = servers.${cfg.lsp.server}.package;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "Nim formatting" // {default = config.vim.languages.enableFormat;};
+      type = mkOption {
+        description = "Nim formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "Nim formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    {
+      assertions = [
+        {
+          assertion = !pkgs.stdenv.isDarwin;
+          message = "Nim language support is only available on Linux";
+        }
+      ];
+    }
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.nim-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.nim-format = formats.${cfg.format.type}.nullConfig;
+    })
+  ]);
+}

modules/plugins/languages/nix.nix

@@ -0,0 +1,208 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.strings) optionalString;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+
+  cfg = config.vim.languages.nix;
+
+  useFormat = "on_attach = default_on_attach";
+  noFormat = "on_attach = attach_keymaps";
+
+  defaultServer = "nil";
+  packageToCmd = package: defaultCmd:
+    if isList package
+    then expToLua package
+    else ''{"${package}/bin/${defaultCmd}"}'';
+  servers = {
+    rnix = {
+      package = pkgs.rnix-lsp;
+      internalFormatter = cfg.format.type == "nixpkgs-fmt";
+      lspConfig = ''
+        lspconfig.rnix.setup{
+          capabilities = capabilities,
+        ${
+          if (cfg.format.enable && cfg.format.type == "nixpkgs-fmt")
+          then useFormat
+          else noFormat
+        },
+          cmd = ${packageToCmd cfg.lsp.package "rnix-lsp"},
+        }
+      '';
+    };
+
+    nil = {
+      package = pkgs.nil;
+      internalFormatter = true;
+      lspConfig = ''
+        lspconfig.nil_ls.setup{
+          capabilities = capabilities,
+        ${
+          if cfg.format.enable
+          then useFormat
+          else noFormat
+        },
+          cmd = ${packageToCmd cfg.lsp.package "nil"},
+        ${optionalString cfg.format.enable ''
+          settings = {
+            ["nil"] = {
+          ${optionalString (cfg.format.type == "alejandra")
+            ''
+              formatting = {
+                command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
+              },
+            ''}
+          ${optionalString (cfg.format.type == "nixpkgs-fmt")
+            ''
+              formatting = {
+                command = {"${cfg.format.package}/bin/nixpkgs-fmt"},
+              },
+            ''}
+            },
+          },
+        ''}
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "alejandra";
+  formats = {
+    alejandra = {
+      package = pkgs.alejandra;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.alejandra.with({
+            command = "${cfg.format.package}/bin/alejandra"
+          })
+        )
+      '';
+    };
+
+    nixpkgs-fmt = {
+      package = pkgs.nixpkgs-fmt;
+      # Never need to use null-ls for nixpkgs-fmt
+    };
+  };
+
+  defaultDiagnosticsProvider = ["statix" "deadnix"];
+  diagnosticsProviders = {
+    statix = {
+      package = pkgs.statix;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.statix.with({
+            command = "${pkg}/bin/statix",
+          })
+        )
+      '';
+    };
+
+    deadnix = {
+      package = pkgs.deadnix;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.deadnix.with({
+            command = "${pkg}/bin/deadnix",
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.nix = {
+    enable = mkEnableOption "Nix language support";
+
+    treesitter = {
+      enable = mkEnableOption "Nix treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "nix";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
+      server = mkOption {
+        description = "Nix LSP server to use";
+        type = str;
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Nix 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;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "Nix formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "Nix formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+      package = mkOption {
+        description = "Nix formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Nix diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "Nix";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    {
+      vim.configRC.nix = entryAnywhere ''
+        autocmd filetype nix setlocal tabstop=2 shiftwidth=2 softtabstop=2
+      '';
+    }
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.nix-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf (cfg.format.enable && !servers.${cfg.lsp.server}.internalFormatter) {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.nix-format = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "nix";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+  ]);
+}

modules/plugins/languages/php.nix

@@ -0,0 +1,107 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.php;
+
+  defaultServer = "phpactor";
+  servers = {
+    phpactor = {
+      package = pkgs.phpactor;
+      lspConfig = ''
+        lspconfig.phpactor.setup{
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''
+            {
+              "${getExe cfg.lsp.package}",
+              "language-server"
+            },
+          ''
+        }
+        }
+      '';
+    };
+
+    phan = {
+      package = pkgs.php81Packages.phan;
+      lspConfig = ''
+        lspconfig.phan.setup{
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''
+              {
+                "${getExe cfg.lsp.package}",
+                "-m",
+                "json",
+                "--no-color",
+                "--no-progress-bar",
+                "-x",
+                "-u",
+                "-S",
+                "--language-server-on-stdin",
+                "--allow-polyfill-parser"
+            },
+          ''
+        }
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.php = {
+    enable = mkEnableOption "PHP language support";
+
+    treesitter = {
+      enable = mkEnableOption "PHP treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "php";
+    };
+
+    lsp = {
+      enable = mkEnableOption "PHP LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "PHP LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "PHP 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.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig = {
+        enable = true;
+        sources.php-lsp = servers.${cfg.lsp.server}.lspConfig;
+      };
+    })
+  ]);
+}

modules/plugins/languages/python.nix

@@ -0,0 +1,235 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str bool;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.python;
+
+  defaultServer = "pyright";
+  servers = {
+    pyright = {
+      package = pkgs.nodePackages.pyright;
+      lspConfig = ''
+        lspconfig.pyright.setup{
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/pyright-langserver", "--stdio"}''
+        }
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "black";
+  formats = {
+    black = {
+      package = pkgs.black;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.black.with({
+            command = "${cfg.format.package}/bin/black",
+          })
+        )
+      '';
+    };
+
+    isort = {
+      package = pkgs.isort;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.isort.with({
+            command = "${cfg.format.package}/bin/isort",
+          })
+        )
+      '';
+    };
+
+    black-and-isort = {
+      package = pkgs.writeShellApplication {
+        name = "black";
+        text = ''
+          black --quiet - "$@" | isort --profile black -
+        '';
+        runtimeInputs = [pkgs.black pkgs.isort];
+      };
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.black.with({
+            command = "${cfg.format.package}/bin/black",
+          })
+        )
+      '';
+    };
+  };
+
+  defaultDebugger = "debugpy";
+  debuggers = {
+    debugpy = {
+      # idk if this is the best way to install/run debugpy
+      package = pkgs.python3.withPackages (ps: with ps; [debugpy]);
+      dapConfig = ''
+        dap.adapters.python = function(cb, config)
+          if config.request == 'attach' then
+            ---@diagnostic disable-next-line: undefined-field
+            local port = (config.connect or config).port
+            ---@diagnostic disable-next-line: undefined-field
+            local host = (config.connect or config).host or '127.0.0.1'
+            cb({
+              type = 'server',
+              port = assert(port, '`connect.port` is required for a python `attach` configuration'),
+              host = host,
+              options = {
+                source_filetype = 'python',
+              },
+            })
+          else
+            cb({
+              type = 'executable',
+              command = '${getExe cfg.dap.package}',
+              args = { '-m', 'debugpy.adapter' },
+              options = {
+                source_filetype = 'python',
+              },
+            })
+          end
+        end
+
+        dap.configurations.python = {
+          {
+            -- The first three options are required by nvim-dap
+            type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
+            request = 'launch';
+            name = "Launch file";
+
+            -- Options below are for debugpy, see https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings for supported options
+
+            program = "''${file}"; -- This configuration will launch the current file if used.
+            pythonPath = function()
+              -- debugpy supports launching an application with a different interpreter then the one used to launch debugpy itself.
+              -- The code below looks for a `venv` or `.venv` folder in the current directly and uses the python within.
+              -- You could adapt this - to for example use the `VIRTUAL_ENV` environment variable.
+              local cwd = vim.fn.getcwd()
+              if vim.fn.executable(cwd .. '/venv/bin/python') == 1 then
+                return cwd .. '/venv/bin/python'
+              elseif vim.fn.executable(cwd .. '/.venv/bin/python') == 1 then
+                return cwd .. '/.venv/bin/python'
+              elseif vim.fn.executable("python") == 1 then
+                return vim.fn.exepath("python")
+              else -- WARNING cfg.dap.package probably has NO libraries other than builtins and debugpy
+                return '${getExe cfg.dap.package}'
+              end
+            end;
+          },
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.python = {
+    enable = mkEnableOption "Python language support";
+
+    treesitter = {
+      enable = mkEnableOption "Python treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkOption {
+        description = "Python treesitter grammar to use";
+        type = package;
+        default = pkgs.vimPlugins.nvim-treesitter.builtGrammars.python;
+      };
+    };
+
+    lsp = {
+      enable = mkEnableOption "Python LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Python LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "python 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;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "Python formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "Python formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "Python formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    # TODO this implementation is very bare bones, I don't know enough python to implement everything
+    dap = {
+      enable = mkOption {
+        description = "Enable Python Debug Adapter";
+        type = bool;
+        default = config.vim.languages.enableDAP;
+      };
+
+      debugger = mkOption {
+        description = "Python debugger to use";
+        type = enum (attrNames debuggers);
+        default = defaultDebugger;
+      };
+
+      package = mkOption {
+        type = package;
+        default = debuggers.${cfg.dap.debugger}.package;
+        example = literalExpression "with pkgs; python39.withPackages (ps: with ps; [debugpy])";
+        description = ''
+          Python debugger package.
+          This is a python package with debugpy installed, see https://nixos.wiki/wiki/Python#Install_Python_Packages.
+        '';
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.python-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.python-format = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.dap.enable {
+      vim.debugger.nvim-dap.enable = true;
+      vim.debugger.nvim-dap.sources.python-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
+    })
+  ]);
+}

modules/plugins/languages/rust.nix

@@ -0,0 +1,160 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.strings) optionalString;
+  inherit (lib.trivial) boolToString;
+  inherit (lib.lists) isList optionals;
+  inherit (lib.types) bool package str listOf either;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.languages.rust;
+in {
+  options.vim.languages.rust = {
+    enable = mkEnableOption "Rust language support";
+
+    treesitter = {
+      enable = mkEnableOption "Rust treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "rust";
+    };
+
+    crates = {
+      enable = mkEnableOption "crates-nvim, tools for managing dependencies";
+      codeActions = mkOption {
+        description = "Enable code actions through null-ls";
+        type = bool;
+        default = true;
+      };
+    };
+
+    lsp = {
+      enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.languages.enableLSP;};
+      package = mkOption {
+        description = "rust-analyzer 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 = pkgs.rust-analyzer;
+      };
+
+      opts = mkOption {
+        description = "Options to pass to rust analyzer";
+        type = str;
+        default = "";
+      };
+    };
+
+    dap = {
+      enable = mkOption {
+        description = "Rust Debug Adapter support";
+        type = bool;
+        default = config.vim.languages.enableDAP;
+      };
+
+      package = mkOption {
+        description = "lldb pacakge";
+        type = package;
+        default = pkgs.lldb;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.crates.enable {
+      vim = {
+        startPlugins = ["crates-nvim"];
+        lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
+        autocomplete.sources = {"crates" = "[Crates]";};
+        luaConfigRC.rust-crates = entryAnywhere ''
+          require('crates').setup {
+            null_ls = {
+              enabled = ${boolToString cfg.crates.codeActions},
+              name = "crates.nvim",
+            }
+          }
+        '';
+      };
+    })
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf (cfg.lsp.enable || cfg.dap.enable) {
+      vim = {
+        startPlugins = ["rust-tools"] ++ optionals cfg.dap.enable [cfg.dap.package];
+
+        lsp.lspconfig = {
+          enable = true;
+          sources.rust-lsp = ''
+            local rt = require('rust-tools')
+            rust_on_attach = function(client, bufnr)
+              default_on_attach(client, bufnr)
+              local opts = { noremap=true, silent=true, buffer = bufnr }
+              vim.keymap.set("n", "<leader>ris", rt.inlay_hints.set, opts)
+              vim.keymap.set("n", "<leader>riu", rt.inlay_hints.unset, opts)
+              vim.keymap.set("n", "<leader>rr", rt.runnables.runnables, opts)
+              vim.keymap.set("n", "<leader>rp", rt.parent_module.parent_module, opts)
+              vim.keymap.set("n", "<leader>rm", rt.expand_macro.expand_macro, opts)
+              vim.keymap.set("n", "<leader>rc", rt.open_cargo_toml.open_cargo_toml, opts)
+              vim.keymap.set("n", "<leader>rg", function() rt.crate_graph.view_crate_graph("x11", nil) end, opts)
+              ${optionalString cfg.dap.enable ''
+              vim.keymap.set("n", "<leader>rd", ":RustDebuggables<cr>", opts)
+              vim.keymap.set(
+                "n", "${config.vim.debugger.nvim-dap.mappings.continue}",
+                function()
+                  local dap = require("dap")
+                  if dap.status() == "" then
+                    vim.cmd "RustDebuggables"
+                  else
+                    dap.continue()
+                  end
+                end,
+                opts
+              )
+            ''}
+            end
+            local rustopts = {
+              tools = {
+                autoSetHints = true,
+                hover_with_actions = false,
+                inlay_hints = {
+                  only_current_line = false,
+                }
+              },
+              server = {
+                capabilities = capabilities,
+                on_attach = rust_on_attach,
+                cmd = ${
+              if isList cfg.lsp.package
+              then expToLua cfg.lsp.package
+              else ''{"${cfg.lsp.package}/bin/rust-analyzer"}''
+            },
+                settings = {
+                  ${cfg.lsp.opts}
+                }
+              },
+
+              ${optionalString cfg.dap.enable ''
+              dap = {
+                adapter = {
+                  type = "executable",
+                  command = "${cfg.dap.package}/bin/lldb-vscode",
+                  name = "rt_lldb",
+                },
+              },
+            ''}
+            }
+            rt.setup(rustopts)
+          '';
+        };
+      };
+    })
+  ]);
+}

modules/plugins/languages/sql.nix

@@ -0,0 +1,166 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+  inherit (lib.nvim.types) diagnostics;
+
+  cfg = config.vim.languages.sql;
+  sqlfluffDefault = pkgs.sqlfluff;
+
+  defaultServer = "sqls";
+  servers = {
+    sqls = {
+      package = pkgs.sqls;
+      lspConfig = ''
+        lspconfig.sqls.setup {
+          on_attach = function(client)
+            client.server_capabilities.execute_command = true
+            on_attach_keymaps(client, bufnr)
+            require'sqls'.setup{}
+          end,
+          cmd = ${
+          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()) }''
+        }
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "sqlfluff";
+  formats = {
+    sqlfluff = {
+      package = sqlfluffDefault;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.sqlfluff.with({
+            command = "${cfg.format.package}/bin/sqlfluff",
+            extra_args = {"--dialect", "${cfg.dialect}"}
+          })
+        )
+      '';
+    };
+  };
+
+  defaultDiagnosticsProvider = ["sqlfluff"];
+  diagnosticsProviders = {
+    sqlfluff = {
+      package = sqlfluffDefault;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.sqlfluff.with({
+            command = "${pkg}/bin/sqlfluff",
+            extra_args = {"--dialect", "${cfg.dialect}"}
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.sql = {
+    enable = mkEnableOption "SQL language support";
+
+    dialect = mkOption {
+      description = "SQL dialect for sqlfluff (if used)";
+      type = str;
+      default = "ansi";
+    };
+
+    treesitter = {
+      enable = mkEnableOption "SQL treesitter" // {default = config.vim.languages.enableTreesitter;};
+
+      package = mkOption {
+        description = "SQL treesitter grammar to use";
+        type = package;
+        default = pkgs.vimPlugins.nvim-treesitter.builtGrammars.sql;
+      };
+    };
+
+    lsp = {
+      enable = mkEnableOption "SQL LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "SQL LSP server to use";
+        type = enum (attrNames servers);
+        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;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "SQL formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "SQL formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "SQL formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra SQL diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "SQL";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim = {
+        startPlugins = ["sqls-nvim"];
+
+        lsp.lspconfig = {
+          enable = true;
+          sources.sql-lsp = servers.${cfg.lsp.server}.lspConfig;
+        };
+      };
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources."sql-format" = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "sql";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+  ]);
+}

modules/plugins/languages/svelte.nix

@@ -0,0 +1,147 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  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 either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+
+  cfg = config.vim.languages.svelte;
+
+  defaultServer = "svelte";
+  servers = {
+    svelte = {
+      package = pkgs.nodePackages.svelte-language-server;
+      lspConfig = ''
+        lspconfig.svelte.setup {
+          capabilities = capabilities;
+          on_attach = attach_keymaps,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/svelteserver", "--stdio"}''
+        }
+        }
+      '';
+    };
+  };
+
+  # TODO: specify packages
+  defaultFormat = "prettier";
+  formats = {
+    prettier = {
+      package = pkgs.nodePackages.prettier;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.prettier.with({
+            command = "${cfg.format.package}/bin/prettier",
+          })
+        )
+      '';
+    };
+  };
+
+  # TODO: specify packages
+  defaultDiagnosticsProvider = ["eslint_d"];
+  diagnosticsProviders = {
+    eslint_d = {
+      package = pkgs.nodePackages.eslint_d;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.eslint_d.with({
+            command = "${getExe pkg}",
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.svelte = {
+    enable = mkEnableOption "Svelte language support";
+
+    treesitter = {
+      enable = mkEnableOption "Svelte treesitter" // {default = config.vim.languages.enableTreesitter;};
+
+      sveltePackage = mkGrammarOption pkgs "svelte";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Svelte LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Svelte LSP server to use";
+        type = enum (attrNames servers);
+        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;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "Svelte formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "Svelte formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "Svelte formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Svelte diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "Svelte";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.sveltePackage];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.svelte-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.svelte-format = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "svelte";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+  ]);
+}

modules/plugins/languages/tailwind.nix

@@ -0,0 +1,61 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.tailwind;
+
+  defaultServer = "tailwindcss-language-server";
+  servers = {
+    tailwindcss-language-server = {
+      package = pkgs.tailwindcss-language-server;
+      lspConfig = ''
+        lspconfig.tailwindcss.setup {
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/tailwindcss-language-server", "--stdio"}''
+        }
+        }
+      '';
+    };
+  };
+in {
+  options.vim.languages.tailwind = {
+    enable = mkEnableOption "Tailwindcss language support";
+
+    lsp = {
+      enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Tailwindcss LSP server to use";
+        type = enum (attrNames servers);
+        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.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.css-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+  ]);
+}

modules/plugins/languages/terraform.nix

@@ -0,0 +1,49 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.types) package;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.terraform;
+in {
+  options.vim.languages.terraform = {
+    enable = mkEnableOption "Terraform/HCL support";
+
+    treesitter = {
+      enable = mkEnableOption "Terraform treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "terraform";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
+
+      package = mkOption {
+        description = "terraform-ls package";
+        type = package;
+        default = pkgs.terraform-ls;
+      };
+    };
+  };
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.terraform-ls = ''
+        lspconfig.terraformls.setup {
+          capabilities = capabilities,
+          on_attach=default_on_attach,
+          cmd = {"${cfg.lsp.package}/bin/terraform-ls", "serve"},
+        }
+      '';
+    })
+  ]);
+}

modules/plugins/languages/tidal/config.nix

@@ -0,0 +1,23 @@
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.tidal;
+in {
+  config = mkIf (cfg.enable) {
+    vim.startPlugins = [
+      # From tidalcycles flake
+      pkgs.vimPlugins.vim-tidal
+    ];
+
+    vim.globals = {
+      "tidal_target" = "terminal";
+      "tidal_flash_duration" = 150;
+      "tidal_sc_enable" = cfg.openSC;
+    };
+  };
+}

modules/plugins/languages/tidal/default.nix

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

modules/plugins/languages/tidal/tidal.nix

@@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) int bool;
+in {
+  options.vim.tidal = {
+    enable = mkEnableOption "tidalcycles tools and plugins";
+
+    flash = mkOption {
+      description = ''When sending a paragraph or a single line, vim-tidal will "flash" the selection for some milliseconds'';
+      type = int;
+      default = 150;
+    };
+
+    openSC = mkOption {
+      description = "Automatically run the supercollider CLI, sclang, alongside the Tidal GHCI terminal.";
+      type = bool;
+      default = true;
+    };
+  };
+}

modules/plugins/languages/ts.nix

@@ -0,0 +1,173 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  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 either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.languages) diagnosticsToLua;
+
+  cfg = config.vim.languages.ts;
+
+  defaultServer = "tsserver";
+  servers = {
+    tsserver = {
+      package = pkgs.nodePackages.typescript-language-server;
+      lspConfig = ''
+        lspconfig.tsserver.setup {
+          capabilities = capabilities;
+          on_attach = attach_keymaps,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}''
+        }
+        }
+      '';
+    };
+    denols = {
+      package = pkgs.deno;
+      lspConfig = ''
+        vim.g.markdown_fenced_languages = { "ts=typescript" }
+        lspconfig.denols.setup {
+          capabilities = capabilities;
+          on_attach = attach_keymaps,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/deno", "lsp"}''
+        }
+        }
+      '';
+    };
+  };
+
+  # TODO: specify packages
+  defaultFormat = "prettier";
+  formats = {
+    prettier = {
+      package = pkgs.nodePackages.prettier;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.prettier.with({
+            command = "${cfg.format.package}/bin/prettier",
+          })
+        )
+      '';
+    };
+    prettierd = {
+      package = pkgs.prettierd;
+      nullConfig = ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.formatting.prettier.with({
+            command = "${cfg.format.package}/bin/prettierd",
+          })
+        )
+      '';
+    };
+  };
+
+  # TODO: specify packages
+  defaultDiagnosticsProvider = ["eslint_d"];
+  diagnosticsProviders = {
+    eslint_d = {
+      package = pkgs.nodePackages.eslint_d;
+      nullConfig = pkg: ''
+        table.insert(
+          ls_sources,
+          null_ls.builtins.diagnostics.eslint_d.with({
+            command = "${getExe pkg}",
+          })
+        )
+      '';
+    };
+  };
+in {
+  options.vim.languages.ts = {
+    enable = mkEnableOption "Typescript/Javascript language support";
+
+    treesitter = {
+      enable = mkEnableOption "Typescript/Javascript treesitter" // {default = config.vim.languages.enableTreesitter;};
+      tsPackage = mkGrammarOption pkgs "tsx";
+      jsPackage = mkGrammarOption pkgs "javascript";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.languages.enableLSP;};
+
+      server = mkOption {
+        description = "Typescript/Javascript LSP server to use";
+        type = enum (attrNames servers);
+        default = defaultServer;
+      };
+
+      package = mkOption {
+        description = "Typescript/Javascript 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;
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "Typescript/Javascript formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "Typescript/Javascript formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "Typescript/Javascript formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Typescript/Javascript diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "Typescript/Javascript";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.tsPackage cfg.treesitter.jsPackage];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.ts-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources.ts-format = formats.${cfg.format.type}.nullConfig;
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls.sources = diagnosticsToLua {
+        lang = "ts";
+        config = cfg.extraDiagnostics.types;
+        inherit diagnosticsProviders;
+      };
+    })
+  ]);
+}

modules/plugins/languages/zig.nix

@@ -0,0 +1,68 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.types) either listOf package str;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.zig;
+in {
+  options.vim.languages.zig = {
+    enable = mkEnableOption "Zig language support";
+
+    treesitter = {
+      enable = mkEnableOption "Zig treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "zig";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Zig LSP support (zls)" // {default = config.vim.languages.enableLSP;};
+
+      package = mkOption {
+        description = "ZLS 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 = pkgs.zls;
+      };
+
+      zigPackage = mkOption {
+        description = "Zig package used by ZLS";
+        type = package;
+        default = pkgs.zig;
+      };
+    };
+  };
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.zig-lsp = ''
+        lspconfig.zls.setup {
+          capabilities = capabilities,
+          on_attach=default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/zls"}''
+        },
+          settings = {
+            ["zls"] = {
+              zig_exe_path = "${cfg.lsp.zigPackage}/bin/zig",
+              zig_lib_path = "${cfg.lsp.zigPackage}/lib/zig",
+            }
+          }
+        }
+      '';
+    })
+  ]);
+}

modules/plugins/lsp/config.nix

@@ -0,0 +1,120 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.lists) optional;
+  inherit (lib.strings) optionalString;
+  inherit (lib.trivial) boolToString;
+  inherit (lib.nvim.binds) addDescriptionsToMappings;
+
+  cfg = config.vim.lsp;
+  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
+  self = import ./module.nix {inherit config lib pkgs;};
+
+  mappingDefinitions = self.options.vim.lsp.mappings;
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
+  mkBinding = binding: action: "vim.api.nvim_buf_set_keymap(bufnr, 'n', '${binding.value}', '<cmd>lua ${action}<CR>', {noremap=true, silent=true, desc='${binding.description}'})";
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      startPlugins = optional usingNvimCmp "cmp-nvim-lsp";
+
+      autocomplete.sources = {"nvim_lsp" = "[LSP]";};
+
+      luaConfigRC.lsp-setup = ''
+        vim.g.formatsave = ${boolToString cfg.formatOnSave};
+
+        local attach_keymaps = function(client, bufnr)
+          ${mkBinding mappings.goToDeclaration "vim.lsp.buf.declaration()"}
+          ${mkBinding mappings.goToDefinition "vim.lsp.buf.definition()"}
+          ${mkBinding mappings.goToType "vim.lsp.buf.type_definition()"}
+          ${mkBinding mappings.listImplementations "vim.lsp.buf.implementation()"}
+          ${mkBinding mappings.listReferences "vim.lsp.buf.references()"}
+          ${mkBinding mappings.nextDiagnostic "vim.diagnostic.goto_next()"}
+          ${mkBinding mappings.previousDiagnostic "vim.diagnostic.goto_prev()"}
+          ${mkBinding mappings.openDiagnosticFloat "vim.diagnostic.open_float()"}
+          ${mkBinding mappings.documentHighlight "vim.lsp.buf.document_highlight()"}
+          ${mkBinding mappings.listDocumentSymbols "vim.lsp.buf.document_symbol()"}
+          ${mkBinding mappings.addWorkspaceFolder "vim.lsp.buf.add_workspace_folder()"}
+          ${mkBinding mappings.removeWorkspaceFolder "vim.lsp.buf.remove_workspace_folder()"}
+          ${mkBinding mappings.listWorkspaceFolders "print(vim.inspect(vim.lsp.buf.list_workspace_folders()))"}
+          ${mkBinding mappings.listWorkspaceSymbols "vim.lsp.buf.workspace_symbol()"}
+          ${mkBinding mappings.hover "vim.lsp.buf.hover()"}
+          ${mkBinding mappings.signatureHelp "vim.lsp.buf.signature_help()"}
+          ${mkBinding mappings.renameSymbol "vim.lsp.buf.rename()"}
+          ${mkBinding mappings.codeAction "vim.lsp.buf.code_action()"}
+          ${mkBinding mappings.format "vim.lsp.buf.format()"}
+          ${mkBinding mappings.toggleFormatOnSave "vim.b.disableFormatSave = not vim.b.disableFormatSave"}
+        end
+
+        -- Enable formatting
+        local augroup = vim.api.nvim_create_augroup("LspFormatting", {})
+
+        format_callback = function(client, bufnr)
+          if vim.g.formatsave then
+            vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
+            vim.api.nvim_create_autocmd("BufWritePre", {
+              group = augroup,
+              buffer = bufnr,
+              callback = function()
+                ${
+          if config.vim.lsp.null-ls.enable
+          then ''
+            if vim.b.disableFormatSave then
+              return
+            end
+
+            local function is_null_ls_formatting_enabled(bufnr)
+                local file_type = vim.api.nvim_buf_get_option(bufnr, "filetype")
+                local generators = require("null-ls.generators").get_available(
+                    file_type,
+                    require("null-ls.methods").internal.FORMATTING
+                )
+                return #generators > 0
+            end
+
+            if is_null_ls_formatting_enabled(bufnr) then
+               vim.lsp.buf.format({
+                  bufnr = bufnr,
+                  filter = function(client)
+                    return client.name == "null-ls"
+                  end
+                })
+            else
+                vim.lsp.buf.format({
+                  bufnr = bufnr,
+                })
+            end
+          ''
+          else "
+              vim.lsp.buf.format({
+                bufnr = bufnr,
+              })
+        "
+        }
+              end,
+            })
+          end
+        end
+
+        ${optionalString (config.vim.ui.breadcrumbs.enable) ''local navic = require("nvim-navic")''}
+        default_on_attach = function(client, bufnr)
+          attach_keymaps(client, bufnr)
+          format_callback(client, bufnr)
+          ${optionalString (config.vim.ui.breadcrumbs.enable) ''
+          -- let navic attach to buffers
+          if client.server_capabilities.documentSymbolProvider then
+            navic.attach(client, bufnr)
+          end
+        ''}
+        end
+
+        local capabilities = vim.lsp.protocol.make_client_capabilities()
+        ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
+      '';
+    };
+  };
+}

modules/plugins/lsp/default.nix

@@ -0,0 +1,21 @@
+{
+  imports = [
+    # nvim lsp support
+    ./config.nix
+    ./module.nix
+
+    ./lspconfig
+    ./lspsaga
+    ./null-ls
+
+    # lsp plugins
+    ./lspsaga
+    ./nvim-code-action-menu
+    ./trouble
+    ./lsp-signature
+    ./lightbulb
+    ./lspkind
+    ./lsplines
+    ./nvim-docs-view
+  ];
+}

modules/plugins/lsp/lightbulb/config.nix

@@ -0,0 +1,23 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf (cfg.enable && cfg.lightbulb.enable) {
+    vim = {
+      startPlugins = ["nvim-lightbulb"];
+
+      luaConfigRC.lightbulb = entryAnywhere ''
+        vim.api.nvim_command('autocmd CursorHold,CursorHoldI * lua require\'nvim-lightbulb\'.update_lightbulb()')
+
+        -- Enable trouble diagnostics viewer
+        require'nvim-lightbulb'.setup()
+      '';
+    };
+  };
+}

modules/plugins/lsp/lightbulb/default.nix

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

modules/plugins/lsp/lightbulb/lightbulb.nix

@@ -0,0 +1,9 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.lsp = {
+    lightbulb = {
+      enable = mkEnableOption "Lightbulb for code actions. Requires an emoji font";
+    };
+  };
+}

modules/plugins/lsp/lsp-signature/config.nix

@@ -0,0 +1,29 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf (cfg.enable && cfg.lspSignature.enable) {
+    vim = {
+      startPlugins = [
+        "lsp-signature"
+      ];
+
+      lsp.lspSignature.setupOpts = {
+        bind = config.vim.ui.borders.plugins.lsp-signature.enable;
+        handler_opts.border = config.vim.ui.borders.plugins.lsp-signature.style;
+      };
+
+      luaConfigRC.lsp-signature = entryAnywhere ''
+        -- Enable lsp signature viewer
+        require("lsp_signature").setup(${toLuaObject cfg.lspSignature.setupOpts})
+      '';
+    };
+  };
+}

modules/plugins/lsp/lsp-signature/default.nix

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

modules/plugins/lsp/lsp-signature/lsp-signature.nix

@@ -0,0 +1,10 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.lsp = {
+    lspSignature = {
+      enable = mkEnableOption "lsp signature viewer";
+      setupOpts = lib.nvim.types.mkPluginSetupOption "lsp-signature" {};
+    };
+  };
+}

modules/plugins/lsp/lspconfig/config.nix

@@ -0,0 +1,35 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.strings) optionalString;
+  inherit (lib.attrsets) mapAttrs;
+  inherit (lib.nvim.dag) entryAfter;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf cfg.lspconfig.enable (mkMerge [
+    {
+      vim = {
+        lsp.enable = true;
+
+        startPlugins = ["nvim-lspconfig"];
+
+        luaConfigRC.lspconfig = entryAfter ["lsp-setup"] ''
+          local lspconfig = require('lspconfig')
+
+          ${
+            optionalString config.vim.ui.borders.enable ''
+              require('lspconfig.ui.windows').default_options.border = '${config.vim.ui.borders.globalStyle}'
+            ''
+          }
+        '';
+      };
+    }
+    {
+      vim.luaConfigRC = mapAttrs (_: v: (entryAfter ["lspconfig"] v)) cfg.lspconfig.sources;
+    }
+  ]);
+}

modules/plugins/lsp/lspconfig/default.nix

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

modules/plugins/lsp/lspconfig/lspconfig.nix

@@ -0,0 +1,14 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) attrsOf str;
+in {
+  options.vim.lsp.lspconfig = {
+    enable = mkEnableOption "nvim-lspconfig, also enabled automatically";
+
+    sources = mkOption {
+      description = "nvim-lspconfig sources";
+      type = attrsOf str;
+      default = {};
+    };
+  };
+}

modules/plugins/lsp/lspkind/config.nix

@@ -0,0 +1,20 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf (cfg.enable && cfg.lspkind.enable) {
+    vim.startPlugins = ["lspkind"];
+    vim.luaConfigRC.lspkind = entryAnywhere ''
+      local lspkind = require'lspkind'
+      local lspkind_opts = {
+        mode = '${cfg.lspkind.mode}'
+      }
+    '';
+  };
+}

modules/plugins/lsp/lspkind/default.nix

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

modules/plugins/lsp/lspkind/lspkind.nix

@@ -0,0 +1,16 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum;
+in {
+  options.vim.lsp = {
+    lspkind = {
+      enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
+
+      mode = mkOption {
+        description = "Defines how annotations are shown";
+        type = enum ["text" "text_symbol" "symbol_text" "symbol"];
+        default = "symbol_text";
+      };
+    };
+  };
+}

modules/plugins/lsp/lsplines/config.nix

@@ -0,0 +1,21 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAfter;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf (cfg.enable && cfg.lsplines.enable) {
+    vim.startPlugins = ["lsp-lines"];
+    vim.luaConfigRC.lsplines = entryAfter ["lspconfig"] ''
+      require("lsp_lines").setup()
+
+      vim.diagnostic.config({
+        virtual_text = false,
+      })
+    '';
+  };
+}

modules/plugins/lsp/lsplines/default.nix

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

modules/plugins/lsp/lsplines/lsplines.nix

@@ -0,0 +1,11 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.lsp = {
+    lsplines = {
+      enable = mkEnableOption ''
+        diagnostics using virtual lines on top of the real line of code. [lsp_lines]
+      '';
+    };
+  };
+}

modules/plugins/lsp/lspsaga/config.nix

@@ -0,0 +1,53 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
+
+  cfg = config.vim.lsp;
+  self = import ./lspsaga.nix {inherit lib;};
+
+  mappingDefinitions = self.options.vim.lsp.lspsaga.mappings;
+  mappings = addDescriptionsToMappings cfg.lspsaga.mappings mappingDefinitions;
+in {
+  config = mkIf (cfg.enable && cfg.lspsaga.enable) {
+    vim = {
+      startPlugins = ["lspsaga"];
+
+      maps = {
+        visual = mkSetLuaBinding mappings.codeAction "require('lspsaga.codeaction').range_code_action";
+        normal = mkMerge [
+          (mkSetLuaBinding mappings.lspFinder "require('lspsaga.provider').lsp_finder")
+          (mkSetLuaBinding mappings.renderHoveredDoc "require('lspsaga.hover').render_hover_doc")
+
+          (mkSetLuaBinding mappings.smartScrollUp "function() require('lspsaga.action').smart_scroll_with_saga(-1) end")
+          (mkSetLuaBinding mappings.smartScrollDown "function() require('lspsaga.action').smart_scroll_with_saga(1) end")
+
+          (mkSetLuaBinding mappings.rename "require('lspsaga.rename').rename")
+          (mkSetLuaBinding mappings.previewDefinition "require('lspsaga.provider').preview_definition")
+
+          (mkSetLuaBinding mappings.showLineDiagnostics "require('lspsaga.diagnostic').show_line_diagnostics")
+          (mkSetLuaBinding mappings.showCursorDiagnostics "require('lspsaga.diagnostic').show_cursor_diagnostics")
+
+          (mkSetLuaBinding mappings.nextDiagnostic "require('lspsaga.diagnostic').navigate('next')")
+          (mkSetLuaBinding mappings.previousDiagnostic "require('lspsaga.diagnostic').navigate('prev')")
+
+          (mkIf (!cfg.nvimCodeActionMenu.enable) (mkSetLuaBinding mappings.codeAction "require('lspsaga.codeaction').code_action"))
+          (mkIf (!cfg.lspSignature.enable) (mkSetLuaBinding mappings.signatureHelp "require('lspsaga.signaturehelp').signature_help"))
+        ];
+      };
+
+      luaConfigRC.lspsaga = entryAnywhere ''
+        require('lspsaga').init_lsp_saga({
+          ${optionalString config.vim.ui.borders.plugins.lspsaga.enable ''
+          border_style = '${config.vim.ui.borders.plugins.lspsaga.style}',
+        ''}
+        })
+      '';
+    };
+  };
+}

modules/plugins/lsp/lspsaga/default.nix

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

modules/plugins/lsp/lspsaga/lspsaga.nix

@@ -0,0 +1,29 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.lsp.lspsaga = {
+    enable = mkEnableOption "LSP Saga";
+
+    mappings = {
+      lspFinder = mkMappingOption "LSP Finder [LSPSaga]" "<leader>lf";
+      renderHoveredDoc = mkMappingOption "Rendered hovered docs [LSPSaga]" "<leader>lh";
+
+      smartScrollUp = mkMappingOption "Smart scroll up [LSPSaga]" "<C-f>";
+      smartScrollDown = mkMappingOption "Smart scroll up [LSPSaga]" "<C-b>";
+
+      rename = mkMappingOption "Rename [LSPSaga]" "<leader>lr";
+      previewDefinition = mkMappingOption "Preview definition [LSPSaga]" "<leader>ld";
+
+      showLineDiagnostics = mkMappingOption "Show line diagnostics [LSPSaga]" "<leader>ll";
+      showCursorDiagnostics = mkMappingOption "Show cursor diagnostics [LSPSaga]" "<leader>lc";
+
+      nextDiagnostic = mkMappingOption "Next diagnostic [LSPSaga]" "<leader>ln";
+      previousDiagnostic = mkMappingOption "Previous diagnostic [LSPSaga]" "<leader>lp";
+
+      codeAction = mkMappingOption "Code action [LSPSaga]" "<leader>ca";
+
+      signatureHelp = mkMappingOption "Signature help [LSPSaga]" "<leader>ls";
+    };
+  };
+}

modules/plugins/lsp/module.nix

@@ -0,0 +1,71 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.lsp = {
+    enable = mkEnableOption "LSP, also enabled automatically through null-ls and lspconfig options";
+    formatOnSave = mkEnableOption "format on save";
+    mappings = {
+      goToDefinition =
+        mkMappingOption "Go to definition"
+        "<leader>lgd";
+      goToDeclaration =
+        mkMappingOption "Go to declaration"
+        "<leader>lgD";
+      goToType =
+        mkMappingOption "Go to type"
+        "<leader>lgt";
+      listImplementations =
+        mkMappingOption "List implementations"
+        "<leader>lgi";
+      listReferences =
+        mkMappingOption "List references"
+        "<leader>lgr";
+      nextDiagnostic =
+        mkMappingOption "Go to next diagnostic"
+        "<leader>lgn";
+      previousDiagnostic =
+        mkMappingOption "Go to previous diagnostic"
+        "<leader>lgp";
+      openDiagnosticFloat =
+        mkMappingOption "Open diagnostic float"
+        "<leader>le";
+      documentHighlight =
+        mkMappingOption "Document highlight"
+        "<leader>lH";
+      listDocumentSymbols =
+        mkMappingOption "List document symbols"
+        "<leader>lS";
+      addWorkspaceFolder =
+        mkMappingOption "Add workspace folder"
+        "<leader>lwa";
+      removeWorkspaceFolder =
+        mkMappingOption "Remove workspace folder"
+        "<leader>lwr";
+      listWorkspaceFolders =
+        mkMappingOption "List workspace folders"
+        "<leader>lwl";
+      listWorkspaceSymbols =
+        mkMappingOption "List workspace symbols"
+        "<leader>lws";
+      hover =
+        mkMappingOption "Trigger hover"
+        "<leader>lh";
+      signatureHelp =
+        mkMappingOption "Signature help"
+        "<leader>ls";
+      renameSymbol =
+        mkMappingOption "Rename symbol"
+        "<leader>ln";
+      codeAction =
+        mkMappingOption "Code action"
+        "<leader>la";
+      format =
+        mkMappingOption "Format"
+        "<leader>lf";
+      toggleFormatOnSave =
+        mkMappingOption "Toggle format on save"
+        "<leader>ltf";
+    };
+  };
+}

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

@@ -0,0 +1,41 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.attrsets) mapAttrs;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter entryBetween;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkIf cfg.null-ls.enable (mkMerge [
+    {
+      vim = {
+        lsp.enable = true;
+        startPlugins = ["none-ls"];
+
+        luaConfigRC.null_ls-setup = entryAnywhere ''
+          local null_ls = require("null-ls")
+          local null_helpers = require("null-ls.helpers")
+          local null_methods = require("null-ls.methods")
+          local ls_sources = {}
+        '';
+
+        luaConfigRC.null_ls = entryAfter ["null_ls-setup" "lsp-setup"] ''
+          require('null-ls').setup({
+            debug = false,
+            diagnostics_format = "[#{m}] #{s} (#{c})",
+            debounce = 250,
+            default_timeout = 5000,
+            sources = ls_sources,
+            on_attach = default_on_attach
+          })
+        '';
+      };
+    }
+    {
+      vim.luaConfigRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
+    }
+  ]);
+}

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

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

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

@@ -0,0 +1,14 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) attrsOf str;
+in {
+  options.vim.lsp.null-ls = {
+    enable = mkEnableOption "null-ls, also enabled automatically";
+
+    sources = mkOption {
+      description = "null-ls sources";
+      type = attrsOf str;
+      default = {};
+    };
+  };
+}

modules/plugins/lsp/nvim-code-action-menu/config.nix

@@ -0,0 +1,37 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.binds) mkSetBinding addDescriptionsToMappings pushDownDefault;
+
+  cfg = config.vim.lsp;
+
+  self = import ./nvim-code-action-menu.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.lsp.nvimCodeActionMenu.mappings;
+  mappings = addDescriptionsToMappings cfg.nvimCodeActionMenu.mappings mappingDefinitions;
+in {
+  config = mkIf (cfg.enable && cfg.nvimCodeActionMenu.enable) {
+    vim = {
+      startPlugins = ["nvim-code-action-menu"];
+
+      maps.normal = mkSetBinding mappings.open ":CodeActionMenu<CR>";
+
+      binds.whichKey.register = pushDownDefault {
+        "<leader>c" = "+CodeAction";
+      };
+
+      luaConfigRC.code-action-menu = entryAnywhere ''
+        -- border configuration
+        vim.g.code_action_menu_window_border = '${config.vim.ui.borders.plugins.code-action-menu.style}'
+
+        -- show individual sections of the code action menu
+        ${lib.optionalString cfg.nvimCodeActionMenu.show.details "vim.g.code_action_menu_show_details = true"}
+        ${lib.optionalString cfg.nvimCodeActionMenu.show.diff "vim.g.code_action_menu_show_diff = true"}
+        ${lib.optionalString cfg.nvimCodeActionMenu.show.actionKind "vim.g.code_action_menu_show_action_kind = true"}
+      '';
+    };
+  };
+}

modules/plugins/lsp/nvim-code-action-menu/default.nix

@@ -0,0 +1,6 @@
+{
+  imports = [
+    ./nvim-code-action-menu.nix
+    ./config.nix
+  ];
+}

modules/plugins/lsp/nvim-code-action-menu/nvim-code-action-menu.nix

@@ -0,0 +1,20 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+in {
+  options.vim.lsp = {
+    nvimCodeActionMenu = {
+      enable = mkEnableOption "nvim code action menu";
+
+      show = {
+        details = mkEnableOption "Show details" // {default = true;};
+        diff = mkEnableOption "Show diff" // {default = true;};
+        actionKind = mkEnableOption "Show action kind" // {default = true;};
+      };
+
+      mappings = {
+        open = mkMappingOption "Open code action menu [nvim-code-action-menu]" "<leader>ca";
+      };
+    };
+  };
+}

modules/plugins/lsp/nvim-docs-view/config.nix

@@ -0,0 +1,32 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.lsp.nvim-docs-view;
+  self = import ./nvim-docs-view.nix {inherit lib;};
+
+  mappingDefinitions = self.options.vim.lsp.nvim-docs-view.mappings;
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      lsp.enable = true;
+      startPlugins = ["nvim-docs-view"];
+
+      luaConfigRC.nvim-docs-view = entryAnywhere ''
+        require("docs-view").setup ${toLuaObject cfg.setupOpts}
+      '';
+
+      maps.normal = mkMerge [
+        (mkSetBinding mappings.viewToggle "<cmd>DocsViewToggle<CR>")
+        (mkSetBinding mappings.viewUpdate "<cmd>DocsViewUpdate<CR>")
+      ];
+    };
+  };
+}

modules/plugins/lsp/nvim-docs-view/default.nix

@@ -0,0 +1,6 @@
+{
+  imports = [
+    ./config.nix
+    ./nvim-docs-view.nix
+  ];
+}

modules/plugins/lsp/nvim-docs-view/nvim-docs-view.nix

@@ -0,0 +1,62 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.nvim.binds) mkMappingOption;
+  inherit (lib) types mkRenamedOptionModule;
+in {
+  imports = let
+    renamedSetupOption = oldPath: newPath:
+      mkRenamedOptionModule
+      (["vim" "lsp" "nvim-docs-view"] ++ oldPath)
+      (["vim" "lsp" "nvim-docs-view" "setupOpts"] ++ newPath);
+  in [
+    (renamedSetupOption ["position"] ["position"])
+    (renamedSetupOption ["width"] ["width"])
+    (renamedSetupOption ["height"] ["height"])
+    (renamedSetupOption ["updateMode"] ["update_mode"])
+  ];
+
+  options.vim.lsp.nvim-docs-view = {
+    enable = mkEnableOption "nvim-docs-view, for displaying lsp hover documentation in a side panel.";
+
+    setupOpts = lib.nvim.types.mkPluginSetupOption "nvim-docs-view" {
+      position = mkOption {
+        type = types.enum ["left" "right" "top" "bottom"];
+        default = "right";
+        description = ''
+          Where to open the docs view panel
+        '';
+      };
+
+      height = mkOption {
+        type = types.int;
+        default = 10;
+        description = ''
+          Height of the docs view panel if the position is set to either top or bottom
+        '';
+      };
+
+      width = mkOption {
+        type = types.int;
+        default = 60;
+        description = ''
+          Width of the docs view panel if the position is set to either left or right
+        '';
+      };
+
+      update_mode = mkOption {
+        type = types.enum ["auto" "manual"];
+        default = "auto";
+        description = ''
+          Determines the mechanism used to update the docs view panel content.
+          - If auto, the content will update upon cursor move.
+          - If manual, the content will only update once :DocsViewUpdate is called
+        '';
+      };
+    };
+
+    mappings = {
+      viewToggle = mkMappingOption "Open or close the docs view panel" "lvt";
+      viewUpdate = mkMappingOption "Manually update the docs view panel" "lvu";
+    };
+  };
+}