progress

because diniamo loves it so much

configuration.nix

@@ -46,18 +46,14 @@ isMaximal: {
 
       nix.enable = true;
 
-      # Assembly is not common, and the asm LSP is a major hit-or-miss
-      assembly.enable = false;
       markdown.enable = isMaximal;
       html.enable = isMaximal;
       css.enable = isMaximal;
       sql.enable = isMaximal;
       java.enable = isMaximal;
-      kotlin.enable = isMaximal;
       ts.enable = isMaximal;
       svelte.enable = isMaximal;
       go.enable = isMaximal;
-      lua.enable = isMaximal;
       elixir.enable = isMaximal;
       zig.enable = isMaximal;
       ocaml.enable = isMaximal;
@@ -67,29 +63,32 @@ isMaximal: {
       r.enable = isMaximal;
       tailwind.enable = isMaximal;
       typst.enable = isMaximal;
-      clang.enable = isMaximal;
+      clang = {
-      scala.enable = isMaximal;
+        enable = isMaximal;
+        lsp.server = "clangd";
+      };
+
       rust = {
         enable = isMaximal;
         crates.enable = isMaximal;
       };
-      csharp.enable = isMaximal;
-      julia.enable = isMaximal;
-      vala.enable = isMaximal;
     };
 
     visuals = {
-      nvim-scrollbar.enable = isMaximal;
+      enable = true;
-      nvim-web-devicons.enable = true;
+      nvimWebDevicons.enable = true;
-      nvim-cursorline.enable = true;
+      scrollBar.enable = isMaximal;
-      cinnamon-nvim.enable = true;
+      smoothScroll.enable = true;
+      cellularAutomaton.enable = false;
       fidget-nvim.enable = true;
-
       highlight-undo.enable = true;
-      indent-blankline.enable = true;
 
-      # Fun
+      indentBlankline.enable = true;
-      cellular-automaton.enable = false;
+
+      cursorline = {
+        enable = true;
+        lineTimeout = 0;
+      };
     };
 
     statusline = {
@@ -106,10 +105,12 @@ isMaximal: {
       transparent = false;
     };
 
-    autopairs.nvim-autopairs.enable = true;
+    autopairs.enable = true;
 
-    autocomplete.nvim-cmp.enable = true;
+    autocomplete = {
-    snippets.luasnip.enable = true;
+      enable = true;
+      type = "nvim-cmp";
+    };
 
     filetree = {
       nvimTree = {
@@ -163,7 +164,6 @@ isMaximal: {
       motion = {
         hop.enable = true;
         leap.enable = true;
-        precognition.enable = isMaximal;
       };
 
       images = {
@@ -173,7 +173,6 @@ isMaximal: {
 
     notes = {
       obsidian.enable = false; # FIXME: neovim fails to build if obsidian is enabled
-      neorg.enable = false;
       orgmode.enable = false;
       mind-nvim.enable = isMaximal;
       todo-comments.enable = true;

docs/manual/configuring/custom-plugins.md

@@ -20,7 +20,6 @@ custom plugins that you might have added to your configuration.
 
 ```{=include=} sections
 custom-plugins/configuring.md
-custom-plugins/lazy-method.md
+custom-plugins/new-method.md
-custom-plugins/non-lazy-method.md
+custom-plugins/old-method.md
-custom-plugins/legacy-method.md
 ```

docs/manual/configuring/custom-plugins/configuring.md

@@ -1,32 +1,12 @@
 # Configuring {#sec-configuring-plugins}
 
-Just making the plugin to your Neovim configuration available might not always be enough. In that
+Just making the plugin to your Neovim configuration available might not always
-case, you can write custom lua config using either `config.vim.lazy.plugins.*.setupOpts`
+be enough. In that case, you can write custom lua config using either
-`config.vim.extraPlugins.*.setup` or `config.vim.luaConfigRC`. 
+`config.vim.extraPlugins` (which has the `setup` field) or
-
+`config.vim.luaConfigRC`. The first option uses an attribute set, which maps DAG
-The first option uses an extended version of `lz.n`'s PluginSpec. `setupModule` and `setupOpt` can
+section names to a custom type, which has the fields `package`, `after`,
-be used if the plugin uses a `require('module').setup(...)` pattern. Otherwise, the `before` and
+`setup`. They allow you to set the package of the plugin, the sections its setup
-`after` hooks should do what you need.
+code should be after (note that the `extraPlugins` option has its own DAG
-
-```nix
-{
-  config.vim.lazy.plugins = {
-    aerial.nvim = {
-    # ^^^^^^^^^ this name should match the package.pname or package.name
-      package = aerial-nvim;
-
-      setupModule = "aerial";
-      setupOpts = {option_name = false;};
-
-      after = "print('aerial loaded')";
-    };
-  };
-}
-```
-
-The second option uses an attribute set, which maps DAG section names to a custom type, which has
-the fields `package`, `after`, `setup`. They allow you to set the package of the plugin, the
-sections its setup code should be after (note that the `extraPlugins` option has its own DAG
 scope), and the its setup code respectively. For example:
 
 ```nix
@@ -44,7 +24,7 @@ config.vim.extraPlugins = with pkgs.vimPlugins; {
 }
 ```
 
-The third option also uses an attribute set, but this one is resolved as a DAG
+The second option also uses an attribute set, but this one is resolved as a DAG
 directly. The attribute names denote the section names, and the values lua code.
 For example:
 

docs/manual/configuring/custom-plugins/lazy-method.md

@@ -1,40 +0,0 @@
-# Lazy Method {#sec-lazy-method}
-
-As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
-`lz.n` and `lzn-auto-require`.
-
-```nix
-{
-  config.vim.lazy.plugins = {
-    "aerial.nvim" = {
-      package = pkgs.vimPlugins.aerial-nvim;
-      setupModule = "aerial";
-      setupOpts = {
-        option_name = true;
-      };
-      after = ''
-        -- custom lua code to run after plugin is loaded
-        print('aerial loaded')
-      '';
-
-      # Explicitly mark plugin as lazy. You don't need this if you define one of
-      # the trigger "events" below
-      lazy = true;
-
-      # load on command
-      cmd = ["AerialOpen"];
-
-      # load on event
-      event = ["BufEnter"];
-
-      # load on keymap
-      keys = [
-        {
-          key = "<leader>a";
-          action = ":AerialToggle<CR>";
-        }
-      ];
-    };
-  };
-}
-```

docs/manual/configuring/custom-plugins/new-method.md

@@ -1,4 +1,4 @@
-# Non-lazy Method {#sec-non-lazy-method}
+# New Method {#sec-new-method}
 
 As of version **0.5**, we have a more extensive API for configuring plugins,
 under `vim.extraPlugins`. Instead of using DAGs exposed by the library, you may

docs/manual/configuring/custom-plugins/old-method.md

@@ -1,4 +1,4 @@
-# Legacy Method {#sec-legacy-method}
+# Old Method {#sec-old-method}
 
 Prior to version 0.5, the method of adding new plugins was adding the plugin
 package to `vim.startPlugins` and add its configuration as a DAG under one of

docs/manual/configuring/dag-entries.md

@@ -12,14 +12,12 @@ entries in nvf:
 2. `globalsScript` - used to set globals defined in `vim.globals`
 3. `basic` - used to set basic configuration options
 4. `optionsScript` - used to set options defined in `vim.o`
-5. `theme` (this is simply placed before `pluginConfigs` and `lazyConfigs`, meaning that
+5. `theme` (this is simply placed before `pluginConfigs`, meaning that
-   surrounding entries don't depend on it) - used to set up the theme, which has to be done before
+   surrounding entries don't depend on it) - used to set up the theme, which has
-   other plugins
+   to be done before other plugins
-6. `lazyConfigs` - `lz.n` and `lzn-auto-require` configs. If `vim.lazy.enable`
+6. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
-   is false, this will contain each plugin's config instead.
-7. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
    see the [Custom Plugins](/index.xhtml#ch-custom-plugins) page for adding your
    own plugins) DAG, used to set up internal plugins
-8. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
+7. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
    direct DAG, but is converted to, and resolved as one internally
-9. `mappings` - the result of `vim.maps`
+8. `mappings` - the result of `vim.maps`

docs/manual/hacking/additional-plugins.md

@@ -124,61 +124,3 @@ vim.your-plugin.setupOpts = {
   '';
 }
 ```
-
-## Lazy plugins {#sec-lazy-plugins}
-
-If the plugin can be lazy-loaded, `vim.lazy.plugins` should be used to add it. Lazy
-plugins are managed by `lz.n`.
-
-```nix
-# in modules/.../your-plugin/config.nix
-{lib, config, ...}:
-let
-  cfg = config.vim.your-plugin;
-in {
-  vim.lazy.plugins.your-plugin = {
-    # instead of vim.startPlugins, use this:
-    package = "your-plugin";
-
-    # if your plugin uses the `require('your-plugin').setup{...}` pattern
-    setupModule = "your-plugin";
-    inherit (cfg) setupOpts;
-
-    # events that trigger this plugin to be loaded
-    event = ["DirChanged"];
-    cmd = ["YourPluginCommand"];
-
-    # keymaps
-    keys = [
-      # we'll cover this in detail in the keymaps section
-      {
-        key = "<leader>d";
-        mode = "n";
-        action = ":YourPluginCommand";
-      }
-    ];
-  };
-;
-}
-```
-
-This results in the following lua code:
-```lua
-require('lz.n').load({
-  {
-    "name-of-your-plugin",
-    after = function()
-      require('your-plugin').setup({--[[ your setupOpts ]]})
-    end,
-
-    event = {"DirChanged"},
-    cmd = {"YourPluginCommand"},
-    keys = {
-      {"<leader>d", ":YourPluginCommand", mode = {"n"}},
-    },
-  }
-})
-```
-
-A full list of options can be found
-[here](https://notashelf.github.io/nvf/options.html#opt-vim.lazy.plugins

docs/release-notes/rl-0.7.md

@@ -28,11 +28,10 @@ configuration formats.
 
 ### `vim.maps` rewrite {#sec-vim-maps-rewrite}
 
-Instead of specifying map modes using submodules (eg.: `vim.maps.normal`), a new
+Instead of specifying map modes using submodules (eg.: `vim.maps.normal`), a new `vim.keymaps`
-`vim.keymaps` submodule with support for a `mode` option has been introduced. It
+submodule with support for a `mode` option has been introduced. It can be either a string, or a
-can be either a string, or a list of strings, where a string represents the
+list of strings, where a string represents the short-name of the map mode(s), that the mapping
-short-name of the map mode(s), that the mapping should be set for. See
+should be set for. See `:help map-modes` for more information.
-`:help map-modes` for more information.
 
 For example:
 
@@ -63,23 +62,6 @@ Note that we are looking to add more alternatives in the future like
 dressing.nvim and actions-preview.nvim, in case fastaction doesn't work for
 everyone.
 
-### `type` based modules removed {#sec-type-based-modules-removed}
-
-As part of the autocompletion rewrite, modules that used to use a `type` option
-have been replaced by per-plugin modules instead. Since both modules only had
-one type, you can simply change
-
-- `vim.autocomplete.*` -> `vim.autocomplete.nvim-cmp.*`
-- `vim.autopairs.enable` -> `vim.autopairs.nvim-autopairs.enable`
-
-### `nixpkgs-fmt` removed in favor of `nixfmt` {#sec-nixpkgs-fmt-deprecation}
-
-`nixpkgs-fmt` has been archived for a while, and it's finally being removed in
-favor of nixfmt (more information can be found
-[here](https://github.com/nix-community/nixpkgs-fmt?tab=readme-ov-file#nixpkgs-fmt---nix-code-formatter-for-nixpkgs).
-
-To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
-`nixfmt`.
 
 ## Changelog {#sec-release-0.7-changelog}
 
@@ -111,9 +93,6 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
 - Add dap-go for better dap configurations
 - Make noice.nvim customizable
 - Standardize border style options and add custom borders
-- Remove `vim.disableDefaultRuntimePaths` in wrapper options.
-  - As nvf uses `$NVIM_APP_NAME` as of recent changes, we can safely assume any
-    configuration in `$XDG_CONFIG_HOME/nvf` is intentional.
 
 [rust-tools.nvim]: https://github.com/simrat39/rust-tools.nvim
 [rustaceanvim]: https://github.com/mrcjkb/rustaceanvim
@@ -123,10 +102,6 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
   recommended to go through rustacean.nvim's README to take a closer look at its
   features and usage
 
-- Add [lz.n] support and lazy-load some builtin plugins.
-
-[lz.n]: https://github.com/mrcjkb/lz.n
-
 [jacekpoz](https://jacekpoz.pl):
 
 [ocaml-lsp]: https://github.com/ocaml/ocaml-lsp
@@ -175,37 +150,12 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
 - Replace `vim.lsp.nvimCodeActionMenu` with `vim.ui.fastaction`, see the
   breaking changes section above for more details
 
-- Add a `setupOpts` option to nvim-surround, which allows modifying options that
+- Add a `setupOpts` option to nvim-surround, which allows modifying options that aren't defined in nvf. Move the alternate nvim-surround keybinds to use `setupOpts`.
-  aren't defined in nvf. Move the alternate nvim-surround keybinds to use
-  `setupOpts`.
-
-- Remove `autopairs.type`, and rename `autopairs.enable` to
-  `autopairs.nvim-autopairs.enable`. The new
-  [](#opt-vim.autopairs.nvim-autopairs.enable) supports `setupOpts` format by
-  default.
-
-- Refactor of `nvim-cmp` and completion related modules
-
-  - Remove `autocomplete.type` in favor of per-plugin enable options such as
-    [](#opt-vim.autocomplete.nvim-cmp.enable).
-  - Deprecate legacy Vimsnip in favor of Luasnip, and integrate
-    friendly-snippets for bundled snippets. [](#opt-vim.snippets.luasnip.enable)
-    can be used to toggle Luasnip.
-  - Add sorting function options for completion sources under
-    [](#opt-vim.autocomplete.nvim-cmp.setupOpts.sorting.comparators)
-
-- Add C# support under `vim.languages.csharp`, with support for both
-  omnisharp-roslyn and csharp-language-server.
-
-- Add Julia support under `vim.languages.julia`. Note that the entirety of Julia
-  is bundled with nvf, if you enable the module, since there is no way to
-  provide only the LSP server.
 
 [Neovim documentation on `vim.cmd`]: https://neovim.io/doc/user/lua.html#vim.cmd()
 
 - Make Neovim's configuration file entirely Lua based. This comes with a few
   breaking changes:
-
   - `vim.configRC` has been removed. You will need to migrate your entries to
     Neovim-compliant Lua code, and add them to `vim.luaConfigRC` instead.
     Existing vimscript configurations may be preserved in `vim.cmd` functions.
@@ -220,7 +170,6 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
 
 [ts-error-translator.nvim]: https://github.com/dmmulroy/ts-error-translator.nvim
 [credo]: https://github.com/rrrene/credo
-[tiny-devicons-auto-colors]: https://github.com/rachartier/tiny-devicons-auto-colors.nvim
 
 - Add `deno fmt` as the default Markdown formatter. This will be enabled
   automatically if you have autoformatting enabled, but can be disabled manually
@@ -279,19 +228,9 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
   configuration for [dashboard.nvim](https://github.com/nvimdev/dashboard-nvim)
 
 - Update `lualine.nvim` input and add missing themes:
-
   - Adds `ayu`, `gruvbox_dark`, `iceberg`, `moonfly`, `onedark`,
     `powerline_dark` and `solarized_light` themes.
 
-- Add [](#opt-vim.spellcheck.extraSpellWords) to allow adding arbitrary
-  spellfiles to Neovim's runtime with ease.
-
-- Add combined nvf configuration (`config.vim`) into the final package's
-  passthru as `passthru.neovimConfiguration` for easier debugging.
-
-- Add support for [tiny-devicons-auto-colors] under
-  `vim.visuals.tiny-devicons-auto-colors`
-
 [ppenguin](https://github.com/ppenguin):
 
 - Telescope:
@@ -301,40 +240,12 @@ To migrate to `nixfmt`, simply change `vim.languages.nix.format.type` to
 [Soliprem](https://github.com/Soliprem):
 
 - Add LSP and Treesitter support for R under `vim.languages.R`.
-  - Add formatter suppoort for R, with styler and formatR as options
 - Add Otter support under `vim.lsp.otter` and an assert to prevent conflict with
   ccc
-- Fixed typo in Otter's setupOpts
+  
-- Add Neorg support under `vim.notes.neorg`
-- Add LSP, diagnostics, formatter and Treesitter support for Kotlin under
-  `vim.languages.kotlin`
-- changed default keybinds for leap.nvim to avoid altering expected behavior
-- Add LSP, formatter and Treesitter support for Vala under `vim.languages.vala`
-- Add [Tinymist](https://github.com/Myriad-Dreamin/tinymist] as a formatter for
-  the Typst language module.
-- Add LSP and Treesitter support for Assembly under `vim.languages.assembly`
-- Move [which-key](https://github.com/folke/which-key.nvim) to the new spec
-
 [Bloxx12](https://github.com/Bloxx12)
 
 - Add support for [base16 theming](https://github.com/RRethy/base16-nvim) under
   `vim.theme`
 - Fix internal breakage in `elixir-tools` setup.
 
-[ksonj](https://github.com/ksonj):
-
-- Add LSP support for Scala via
-  [nvim-metals](https://github.com/scalameta/nvim-metals)
-
-[nezia1](https://github.com/nezia1):
-
-- Add [biome](https://github.com/biomejs/biome) support for Typescript, CSS and
-  Svelte. Enable them via [](#opt-vim.languages.ts.format.type),
-  [](#opt-vim.languages.css.format.type) and
-  [](#opt-vim.languages.svelte.format.type) respectively.
-- Replace [nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt) with
-  [nixfmt](https://github.com/NixOS/nixfmt) (nixfmt-rfc-style).
-
-[Nowaaru](https://github.com/Nowaaru):
-
-- Add `precognition-nvim`.

flake.nix

@@ -113,22 +113,6 @@
     };
 
     ## Plugins
-    # Lazy loading
-    plugin-lz-n = {
-      url = "github:nvim-neorocks/lz.n";
-      flake = false;
-    };
-
-    plugin-lzn-auto-require = {
-      url = "github:horriblename/lzn-auto-require/require-rewrite";
-      flake = false;
-    };
-
-    plugin-rtp-nvim = {
-      url = "github:nvim-neorocks/rtp.nvim";
-      flake = false;
-    };
-
     # LSP plugins
     plugin-nvim-lspconfig = {
       url = "github:neovim/nvim-lspconfig";
@@ -222,21 +206,6 @@
       flake = false;
     };
 
-    plugin-nvim-metals = {
-      url = "github:scalameta/nvim-metals";
-      flake = false;
-    };
-
-    plugin-omnisharp-extended = {
-      url = "github:Hoffs/omnisharp-extended-lsp.nvim";
-      flake = false;
-    };
-
-    plugin-csharpls-extended = {
-      url = "github:Decodetalkers/csharpls-extended-lsp.nvim";
-      flake = false;
-    };
-
     # Copying/Registers
     plugin-registers = {
       url = "github:tversteeg/registers.nvim";
@@ -308,6 +277,11 @@
       flake = false;
     };
 
+    plugin-cmp-vsnip = {
+      url = "github:hrsh7th/cmp-vsnip";
+      flake = false;
+    };
+
     plugin-cmp-path = {
       url = "github:hrsh7th/cmp-path";
       flake = false;
@@ -318,19 +292,9 @@
       flake = false;
     };
 
-    plugin-cmp-luasnip = {
-      url = "github:saadparwaiz1/cmp_luasnip";
-      flake = false;
-    };
-
     # snippets
-    plugin-luasnip = {
+    plugin-vim-vsnip = {
-      url = "github:L3MON4D3/LuaSnip";
+      url = "github:hrsh7th/vim-vsnip";
-      flake = false;
-    };
-
-    plugin-friendly-snippets = {
-      url = "github:rafamadriz/friendly-snippets";
       flake = false;
     };
 
@@ -443,7 +407,7 @@
       flake = false;
     };
 
-    plugin-nvim-scrollbar = {
+    plugin-scrollbar-nvim = {
       url = "github:petertriho/nvim-scrollbar";
       flake = false;
     };
@@ -468,11 +432,6 @@
       flake = false;
     };
 
-    plugin-tiny-devicons-auto-colors = {
-      url = "github:rachartier/tiny-devicons-auto-colors.nvim";
-      flake = false;
-    };
-
     plugin-gitsigns-nvim = {
       url = "github:lewis6991/gitsigns.nvim";
       flake = false;
@@ -571,11 +530,6 @@
       flake = false;
     };
 
-    plugin-precognition-nvim = {
-      url = "github:tris203/precognition.nvim";
-      flake = false;
-    };
-
     # Note-taking
     plugin-obsidian-nvim = {
       url = "github:epwalsh/obsidian.nvim";
@@ -682,26 +636,6 @@
       flake = false;
     };
 
-    plugin-lua-utils-nvim = {
-      url = "github:nvim-neorg/lua-utils.nvim";
-      flake = false;
-    };
-
-    plugin-pathlib-nvim = {
-      url = "github:pysan3/pathlib.nvim";
-      flake = false;
-    };
-
-    plugin-neorg = {
-      url = "github:nvim-neorg/neorg";
-      flake = false;
-    };
-
-    plugin-neorg-telescope = {
-      url = "github:nvim-neorg/neorg-telescope";
-      flake = false;
-    };
-
     plugin-nui-nvim = {
       # (required by noice.nvim)
       url = "github:MunifTanjim/nui.nvim";

flake/packages.nix

@@ -19,7 +19,7 @@
       docs-html-wrapped = pkgs.writeScriptBin "docs-html-wrapped" ''
         #!${pkgs.stdenv.shell}
         # use xdg-open to open the docs in the browser
-        ${pkgs.xdg-utils}/bin/xdg-open ${docs.manual.html}
+        ${pkgs.xdg_utils}/bin/xdg-open ${docs.manual.html}
       '';
 
       # Exposed neovim configurations
@@ -29,10 +29,10 @@
 
       # Published docker images
       docker-nix = let
-        inherit (pkgs) bash gitFull buildEnv;
+        inherit (pkgs) bash gitFull buildEnv dockerTools;
         inherit (config.legacyPackages) neovim-nix;
       in
-        pkgs.dockerTools.buildImage {
+        dockerTools.buildImage {
           name = "nvf";
           tag = "latest";
 

lib/attrsets.nix

@@ -1,5 +0,0 @@
-{lib}: let
-  inherit (builtins) listToAttrs;
-in {
-  mapListToAttrs = f: list: listToAttrs (map f list);
-}

lib/binds.nix

@@ -67,30 +67,6 @@
       mkLuaBinding binding.value action binding.description;
 
     pushDownDefault = attr: mapAttrs (_: mkDefault) attr;
-
-    mkLznBinding = mode: key: action: desc: {
-      inherit mode desc key action;
-    };
-
-    mkLznExprBinding = mode: key: action: desc: {
-      inherit mode desc key action;
-      lua = true;
-      silent = true;
-      expr = true;
-    };
-
-    mkSetLznBinding = binding: action: {
-      inherit action;
-      key = binding.value;
-      desc = binding.description;
-    };
-
-    mkSetLuaLznBinding = binding: action: {
-      inherit action;
-      key = binding.value;
-      lua = true;
-      desc = binding.description;
-    };
   };
 in
   binds

lib/default.nix

@@ -10,7 +10,6 @@
   dag = import ./dag.nix {inherit lib;};
   languages = import ./languages.nix {inherit lib;};
   lists = import ./lists.nix {inherit lib;};
-  attrsets = import ./attrsets.nix {inherit lib;};
   lua = import ./lua.nix {inherit lib;};
   neovimConfiguration = import ../modules {inherit inputs lib;};
 }

lib/languages.nix

@@ -2,8 +2,8 @@
 {lib}: let
   inherit (builtins) isString getAttr;
   inherit (lib.options) mkOption;
+  inherit (lib.attrsets) listToAttrs;
   inherit (lib.types) bool;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 in {
   # Converts a boolean to a yes/no string. This is used in lots of
   # configuration formats.
@@ -12,21 +12,21 @@ in {
     config,
     diagnosticsProviders,
   }:
-    mapListToAttrs
+    listToAttrs
-    (v: let
+    (map (v: let
-      type =
+        type =
-        if isString v
+          if isString v
-        then v
+          then v
-        else getAttr v.type;
+          else getAttr v.type;
-      package =
+        package =
-        if isString v
+          if isString v
-        then diagnosticsProviders.${type}.package
+          then diagnosticsProviders.${type}.package
-        else v.package;
+          else v.package;
-    in {
+      in {
-      name = "${lang}-diagnostics-${type}";
+        name = "${lang}-diagnostics-${type}";
-      value = diagnosticsProviders.${type}.nullConfig package;
+        value = diagnosticsProviders.${type}.nullConfig package;
-    })
+      })
-    config;
+      config);
 
   mkEnable = desc:
     mkOption {

lib/types/default.nix

@@ -6,10 +6,10 @@
   typesDag = import ./dag.nix {inherit lib;};
   typesPlugin = import ./plugins.nix {inherit inputs lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
-  customTypes = import ./custom.nix {inherit lib;};
+  typesTypes = import ./types.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (customTypes) anythingConcatLists char hexColor mergelessListOf;
+  inherit (typesTypes) anythingConcatLists char hexColor;
 }

lib/types/types.nix

@@ -1,7 +1,7 @@
 {lib}: let
-  inherit (lib.options) showOption showFiles getFiles mergeOneOption mergeEqualOption;
+  inherit (lib) isStringLike showOption showFiles getFiles mergeOneOption mergeEqualOption mkOptionType;
-  inherit (lib.strings) isString isStringLike;
+  inherit (lib.strings) isString;
-  inherit (lib.types) anything attrsOf listOf mkOptionType;
+  inherit (lib.types) anything attrsOf;
   inherit (lib.nvim.types) anythingConcatLists;
   inherit (builtins) typeOf isAttrs any head concatLists stringLength match;
 in {
@@ -52,16 +52,6 @@ in {
         (mergeFunctions.${commonType} or mergeEqualOption) loc defs;
     };
 
-  mergelessListOf = elemType: let
-    super = listOf elemType;
-  in
-    super
-    // {
-      name = "mergelessListOf";
-      description = "mergeless ${super.description}";
-      merge = mergeEqualOption;
-    };
-
   char = mkOptionType {
     name = "char";
     description = "character";

modules/default.nix

@@ -84,7 +84,10 @@
 
   # built (or "normalized") plugins that are modified
   builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
-  builtOptPlugins = map (package: package // {optional = true;}) (buildConfigPlugins vimOptions.optPlugins);
+  builtOptPlugins = map (package: {
+    plugin = package;
+    optional = true;
+  }) (buildConfigPlugins vimOptions.optPlugins);
 
   # additional Lua and Python3 packages, mapped to their respective functions
   # to conform to the format mnw expects. end user should
@@ -123,15 +126,9 @@ in {
     paths = [neovim-wrapped printConfig printConfigPath];
     postBuild = "echo Helpers added";
 
-    # Allow evaluating vimOptions, i.e., config.vim from the packages' passthru
+    meta = {
-    # attribute. For example, packages.x86_64-linux.neovim.passthru.neovimConfig
+      description = "Wrapped version of Neovim with additional helper scripts";
-    # will return the configuration in full.
+      mainProgram = "nvim";
-    passthru.neovimConfig = vimOptions;
+    };
-
-    meta =
-      neovim-wrapped.meta
-      // {
-        description = "Wrapped Neovim package with helper scripts to print the config (path)";
-      };
   };
 }

modules/extra/deprecations.nix

@@ -1,5 +1,5 @@
 {lib, ...}: let
-  inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule;
+  inherit (lib.modules) mkRemovedOptionModule;
 in {
   imports = [
     # 2024-06-06
@@ -14,45 +14,5 @@ in {
       available under `vim.ui.fastaction` as a replacement. Simply remove everything under
       `vim.lsp.nvimCodeActionMenu`, and set `vim.ui.fastaction.enable` to `true`.
     '')
-
-    (mkRemovedOptionModule ["vim" "autopairs" "enable"] ''
-      vim.autopairs.enable has been removed in favor of per-plugin modules.
-      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autopairs" "type"] ''
-      vim.autopairs.type has been removed in favor of per-plugin modules.
-      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autocomplete" "enable"] ''
-      vim.autocomplete.enable has been removed in favor of per-plugin modules.
-      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autocomplete" "type"] ''
-      vim.autocomplete.type has been removed in favor of per-plugin modules.
-      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autocomplete" "sources"] ''
-      vim.autocomplete.sources has been removed in favor of per-plugin modules.
-      You can add nvim-cmp sources with vim.autocomplete.nvim-cmp.sources
-      instead.
-    '')
-    (mkRemovedOptionModule ["vim" "snippets" "vsnip" "enable"] ''
-      vim.snippets.vsnip.enable has been removed in favor of the more modern luasnip.
-    '')
-    (mkRenamedOptionModule ["vim" "lsp" "lspkind" "mode"] ["vim" "lsp" "lspkind" "setupOpts" "mode"])
-
-    # 2024-10-14
-    (mkRemovedOptionModule ["vim" "configRC"] ''
-      Please migrate your configRC sections to Neovim's Lua format, and
-      add them to `vim.luaConfigRC`.
-
-      See the v0.7 release notes for more information on why and how to
-      migrate your existing configurations to the new format.
-    '')
-
-    (mkRemovedOptionModule ["vim" "disableDefaultRuntimePaths"] ''
-      Nvf now uses $NVIM_APP_NAME so there is no longer the problem of
-      (accidental) leaking of user configuration.
-    '')
   ];
 }

modules/modules.nix

@@ -50,7 +50,6 @@
       "build"
       "rc"
       "warnings"
-      "lazy"
     ];
 
     # Extra modules, such as deprecation warnings

modules/neovim/init/spellcheck.nix

@@ -1,14 +1,11 @@
 {
   config,
-  pkgs,
   lib,
   ...
 }: let
   inherit (lib.modules) mkIf mkRenamedOptionModule;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.strings) concatLines;
+  inherit (lib.types) listOf str;
-  inherit (lib.attrsets) mapAttrsToList;
-  inherit (lib.types) listOf str attrsOf;
   inherit (lib.nvim.lua) listToLuaTable;
   inherit (lib.nvim.dag) entryAfter;
 
@@ -27,48 +24,10 @@ in {
       description = ''
         A list of languages that should be used for spellchecking.
 
-        To add your own language files, you may place your `spell` directory in either
+        To add your own language files, you may place your `spell`
-        {file}`$XDG_CONFIG_HOME/nvf` or in a path that is included in the
+        directory in either `~/.config/nvim` or the
-        [additionalRuntimePaths](#opt-vim.additionalRuntimePaths) list provided by nvf.
+        [additionalRuntimePaths](#opt-vim.additionalRuntimePaths)
-      '';
+        directory provided by **nvf**.
-    };
-
-    extraSpellWords = mkOption {
-      type = attrsOf (listOf str);
-      default = {};
-      example = literalExpression ''{"en.utf-8" = ["nvf" "word_you_want_to_add"];}'';
-      description = ''
-        Additional words to be used for spellchecking. The names of each key will be
-        used as the language code for the spell file. For example
-
-        ```nix
-        "en.utf-8" = [ ... ];
-        ```
-
-        will result in `en.utf-8.add.spl` being added to Neovim's runtime in the
-        {file}`spell` directory.
-
-        ::: {.warning}
-        The attribute keys must be in `"<name>.<encoding>"` format for Neovim to
-        compile your spellfiles without mangling the resulting file names. Please
-        make sure that you enter the correct value, as nvf does not do any kind of
-        internal checking. Please see {command}`:help mkspell` for more details.
-
-        Example:
-
-        ```nix
-        # "en" is the name, and "utf-8" is the encoding. For most use cases, utf-8
-        # will be enough, however, you may change it to any encoding format Neovim
-        # accepts, e.g., utf-16.
-        "en.utf-8" = ["nvf" "word_you_want_to_add"];
-        => $out/spell/en-utf-8.add.spl
-        ```
-        :::
-
-        Note that while adding a new language, you will still need to add the name of
-        the language (e.g. "en") to the {option}`vim.spellcheck.languages` list by name
-        in order to enable spellchecking for the language. By default only `"en"` is in
-        the list.
       '';
     };
 
@@ -79,75 +38,38 @@ in {
       description = ''
         A list of filetypes for which spellchecking will be disabled.
 
-        ::: {.tip}
+        You may use `echo &filetype` in Neovim to find out the
-        You may use {command}`:echo &filetype` in Neovim to find out the
         filetype for a specific buffer.
-        :::
       '';
     };
 
+    /*
+    # FIXME: This needs to be revisited. It tries to install
+    # the spellfile to an user directory, but it cannot do so
+    # as we sanitize runtime paths.
     programmingWordlist.enable = mkEnableOption ''
       vim-dirtytalk, a wordlist for programmers containing
       common programming terms.
 
-      ::: {.note}
+      Setting this value as `true` has the same effect
-      Enabling this option will unconditionally set
+      as setting {option}`vim.spellCheck.enable`
-      {option}`vim.spellcheck.enable` to true as vim-dirtytalk
-      depends on spellchecking having been set up.
-      :::
     '';
+    */
   };
 
   config = mkIf cfg.enable {
-    vim = {
+    vim.luaConfigRC.spellcheck = entryAfter ["basic"] ''
-      additionalRuntimePaths = let
+      vim.opt.spell = true
-        compileJoinedSpellfiles =
+      vim.opt.spelllang = ${listToLuaTable cfg.languages}
-          pkgs.runCommandLocal "nvf-compile-spellfiles" {
-            # Use the same version of Neovim as the user's configuration
-            nativeBuildInputs = [config.vim.package];
 
-            spellfilesJoined = pkgs.symlinkJoin {
+      -- Disable spellchecking for certain filetypes
-              name = "nvf-spellfiles-joined";
+      -- as configured by `vim.spellcheck.ignoredFiletypes`
-              paths = mapAttrsToList (name: value: pkgs.writeTextDir "spell/${name}.add" (concatLines value)) cfg.extraSpellWords;
+      vim.api.nvim_create_autocmd({ "FileType" }, {
-              postBuild = "echo Spellfiles joined";
+        pattern = ${listToLuaTable cfg.ignoredFiletypes},
-            };
+        callback = function()
-          } ''
+          vim.opt_local.spell = false
-            # Fail on unset variables and non-zero exit codes
+        end,
-            # this might be the only way to trace when `nvim --headless`
+      })
-            # fails in batch mode
+    '';
-            set -eu
-
-            mkdir -p "$out/spell"
-            for spellfile in "$spellfilesJoined"/spell/*.add; do
-              name="$(basename "$spellfile" ".add")"
-              echo "Compiling spellfile: $spellfile"
-              nvim --headless --clean \
-                --cmd "mkspell $out/spell/$name.add.spl $spellfile" -Es -n
-            done
-
-          '';
-      in
-        mkIf (cfg.extraSpellWords != {}) [
-          # If .outPath is missing, additionalRuntimePaths receives the *function*
-          # instead of a path, causing errors.
-          compileJoinedSpellfiles.outPath
-        ];
-
-      luaConfigRC.spellcheck = entryAfter ["basic"] ''
-        vim.opt.spell = true
-        vim.opt.spelllang = ${listToLuaTable cfg.languages}
-
-        -- Disable spellchecking for certain filetypes
-        -- as configured by `vim.spellcheck.ignoredFiletypes`
-        vim.api.nvim_create_augroup("nvf_autocmds", {clear = false})
-        vim.api.nvim_create_autocmd({ "FileType" }, {
-          group = "nvf_autocmds",
-          pattern = ${listToLuaTable cfg.ignoredFiletypes},
-          callback = function()
-            vim.opt_local.spell = false
-          end,
-        })
-      '';
-    };
   };
 }

modules/plugins/assistant/copilot/config.nix

@@ -4,8 +4,11 @@
   ...
 }: let
   inherit (builtins) toJSON;
-  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.lists) optionals;
+  inherit (lib.nvim.binds) mkLuaBinding;
 
   cfg = config.vim.assistant.copilot;
 
@@ -20,68 +23,63 @@
       end
     end
   '';
-
-  mkLuaKeymap = mode: key: action: desc: opts:
-    opts
-    // {
-      inherit mode key action desc;
-      lua = true;
-    };
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins =
-      lazy.plugins = {
+      [
-        copilot-lua = {
+        "copilot-lua"
-          package = "copilot-lua";
+        # cfg.copilotNodePackage
-          setupModule = "copilot";
+      ]
-          inherit (cfg) setupOpts;
+      ++ optionals cfg.cmp.enable [
-          after = mkIf cfg.cmp.enable "require('copilot_cmp').setup()";
+        "copilot-cmp"
+      ];
 
-          cmd = ["Copilot" "CopilotAuth" "CopilotDetach" "CopilotPanel" "CopilotStop"];
+    vim.pluginRC.copilot = entryAnywhere ''
-          keys = [
+      require("copilot").setup(${toLuaObject cfg.setupOpts})
-            (mkLuaKeymap ["n"] cfg.mappings.panel.accept (wrapPanelBinding ''require("copilot.panel").accept'' cfg.mappings.panel.accept) "[copilot] Accept suggestion" {})
-            (mkLuaKeymap ["n"] cfg.mappings.panel.jumpNext (wrapPanelBinding "require(\"copilot.panel\").jump_next" cfg.mappings.panel.jumpNext) "[copilot] Accept suggestion" {})
-            (mkLuaKeymap ["n"] cfg.mappings.panel.jumpPrev (wrapPanelBinding "require(\"copilot.panel\").jump_prev" cfg.mappings.panel.jumpPrev) "[copilot] Accept suggestion" {})
-            (mkLuaKeymap ["n"] cfg.mappings.panel.refresh (wrapPanelBinding "require(\"copilot.panel\").refresh" cfg.mappings.panel.refresh) "[copilot] Accept suggestion" {})
-            (mkLuaKeymap ["n"] 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" {})
 
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.accept "function() require('copilot.suggestion').accept() end" "[copilot] Accept suggestion" {})
+      ${lib.optionalString cfg.cmp.enable ''
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.acceptLine "function() require('copilot.suggestion').accept_line() end" "[copilot] Accept suggestion (line)" {})
+        require("copilot_cmp").setup()
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.acceptWord "function() require('copilot.suggestion').accept_word() end" "[copilot] Accept suggestion (word)" {})
+      ''}
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.dismiss "function() require('copilot.suggestion').dismiss() end" "[copilot] dismiss suggestion" {})
+    '';
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.next "function() require('copilot.suggestion').next() end" "[copilot] next suggestion" {})
+
-            (mkLuaKeymap ["i"] cfg.mappings.suggestion.prev "function() require('copilot.suggestion').prev() end" "[copilot] previous suggestion" {})
+    # 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 = {
-      autocomplete.nvim-cmp = {
+        accept = lib.mkDefault false;
-        sources = {copilot = "[Copilot]";};
+        accept_word = lib.mkDefault false;
-        sourcePlugins = ["copilot-cmp"];
+        accept_line = lib.mkDefault false;
-      };
+        next = lib.mkDefault false;
-
+        prev = lib.mkDefault false;
-      # Disable plugin handled keymaps.
+        dismiss = lib.mkDefault false;
-      # Setting it here so that it doesn't show up in user docs
-      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/autopairs/nvim-autopairs/config.nix

@@ -4,17 +4,16 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.trivial) boolToString;
   inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
-  cfg = config.vim.autopairs.nvim-autopairs;
+  cfg = config.vim.autopairs;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = ["nvim-autopairs"];
-      startPlugins = ["nvim-autopairs"];
+
-      pluginRC.autopairs = entryAnywhere ''
+    vim.pluginRC.autopairs = entryAnywhere ''
-        require('nvim-autopairs').setup(${toLuaObject cfg.setupOpts})
+      require("nvim-autopairs").setup({ map_cr = ${boolToString (!config.vim.autocomplete.enable)} })
-      '';
+    '';
-    };
   };
 }

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

@@ -1,14 +1,21 @@
 {lib, ...}: let
   inherit (lib) mkRemovedOptionModule;
-  inherit (lib.options) mkEnableOption;
+  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.types) enum;
 in {
   imports = [
     (mkRemovedOptionModule ["vim" "autopairs" "nvim-compe"] "nvim-compe is deprecated and no longer suported.")
   ];
 
-  options.vim.autopairs.nvim-autopairs = {
+  options.vim = {
-    enable = mkEnableOption "autopairs";
+    autopairs = {
-    setupOpts = mkPluginSetupOption "nvim-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

@@ -1,7 +1,6 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.comments.comment-nvim = {
     enable = mkEnableOption "smart and powerful comment plugin for neovim comment-nvim";
@@ -16,12 +15,5 @@ in {
       toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
       toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
     };
-
-    setupOpts = mkPluginSetupOption "Comment-nvim" {
-      mappings = {
-        basic = mkEnableOption "basic mappings";
-        extra = mkEnableOption "extra mappings";
-      };
-    };
   };
 }

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

@@ -3,38 +3,48 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkLznExprBinding mkLznBinding;
+  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.lazy.plugins.comment-nvim = {
+    vim.startPlugins = [
-      package = "comment-nvim";
+      "comment-nvim"
-      setupModule = "Comment";
+    ];
-      inherit (cfg) setupOpts;
+
-      keys = [
+    vim.maps.normal = mkMerge [
-        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
+      (mkBinding cfg.mappings.toggleOpLeaderLine "<Plug>(comment_toggle_linewise)" mappings.toggleOpLeaderLine.description)
-        (mkLznBinding ["n"] cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
+      (mkBinding cfg.mappings.toggleOpLeaderBlock "<Plug>(comment_toggle_blockwise)" mappings.toggleOpLeaderBlock.description)
-        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentLine ''
+
-            function()
+      (mkExprBinding cfg.mappings.toggleCurrentLine ''
-              return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
+          function()
-                      or '<Plug>(comment_toggle_linewise_count)'
+            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_linewise_current)'
-            end
+                    or '<Plug>(comment_toggle_linewise_count)'
-          ''
+          end
-          mappings.toggleCurrentLine.description)
+        ''
-        (mkLznExprBinding ["n"] cfg.mappings.toggleCurrentBlock ''
+        mappings.toggleCurrentLine.description)
-            function()
+      (mkExprBinding cfg.mappings.toggleCurrentBlock ''
-              return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
+          function()
-                      or '<Plug>(comment_toggle_blockwise_count)'
+            return vim.api.nvim_get_vvar('count') == 0 and '<Plug>(comment_toggle_blockwise_current)'
-            end
+                    or '<Plug>(comment_toggle_blockwise_count)'
-          ''
+          end
-          mappings.toggleCurrentBlock.description)
+        ''
-        (mkLznBinding ["x"] cfg.mappings.toggleSelectedLine "<Plug>(comment_toggle_linewise_visual)" mappings.toggleSelectedLine.description)
+        mappings.toggleCurrentBlock.description)
-        (mkLznBinding ["x"] cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.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.pluginRC.comment-nvim = entryAnywhere ''
+      require('Comment').setup({
+        mappings = { basic = false, extra = false, },
+      })
+    '';
   };
 }

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

@@ -3,137 +3,246 @@
   config,
   ...
 }: let
+  inherit (builtins) toJSON;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.strings) optionalString;
+  inherit (lib.attrsets) attrNames mapAttrsToList;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.strings) concatMapStringsSep concatStringsSep optionalString;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
-  inherit (builtins) attrNames typeOf tryEval concatStringsSep;
 
-  cfg = config.vim.autocomplete.nvim-cmp;
+  cfg = config.vim.autocomplete;
-  luasnipEnable = config.vim.snippets.luasnip.enable;
+  lspkindEnabled = config.vim.lsp.enable && config.vim.lsp.lspkind.enable;
-  getPluginName = plugin:
+
-    if typeOf plugin == "string"
+  self = import ./nvim-cmp.nix {inherit lib;};
-    then plugin
+  mappingDefinitions = self.options.vim.autocomplete.mappings;
-    else if (plugin ? pname && (tryEval plugin.pname).success)
+
-    then plugin.pname
+  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
-    else plugin.name;
+
-  inherit (cfg) mappings;
+  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 = {
+    vim.startPlugins = [
-      startPlugins = ["rtp-nvim"];
+      "nvim-cmp"
-      lazy.plugins = mkMerge [
+      "cmp-buffer"
-        (mapListToAttrs (package: {
+      "cmp-vsnip"
-            name = getPluginName package;
+      "cmp-path"
-            value = {
+      "vim-vsnip"
-              inherit package;
+    ];
-              lazy = true;
-              after = ''
-                local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/${getPluginName package}')
-                require("rtp_nvim").source_after_plugin_dir(path)
-              '';
-            };
-          })
-          cfg.sourcePlugins)
-        {
-          nvim-cmp = {
-            package = "nvim-cmp";
-            after = ''
-              ${optionalString luasnipEnable "local luasnip = require('luasnip')"}
-              local cmp = require("cmp")
 
-              local kinds = require("cmp.types").lsp.CompletionItemKind
+    vim.autocomplete.sources = {
-              local deprio = function(kind)
+      "nvim-cmp" = null;
-                return function(e1, e2)
+      "vsnip" = "[VSnip]";
-                  if e1:get_kind() == kind then
+      "buffer" = "[Buffer]";
-                    return false
+      "crates" = "[Crates]";
-                  end
+      "path" = "[Path]";
-                  if e2:get_kind() == kind then
+      "copilot" = "[Copilot]";
-                    return true
-                  end
-                  return nil
-                end
-              end
-
-              cmp.setup(${toLuaObject cfg.setupOpts})
-
-              ${optionalString config.vim.lazy.enable
-                (concatStringsSep "\n" (map
-                  (package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
-                  cfg.sourcePlugins))}
-            '';
-
-            event = ["InsertEnter" "CmdlineEnter"];
-          };
-        }
-      ];
-
-      autocomplete.nvim-cmp = {
-        sources = {
-          nvim-cmp = null;
-          buffer = "[Buffer]";
-          path = "[Path]";
-        };
-
-        sourcePlugins = ["cmp-buffer" "cmp-path"];
-
-        setupOpts = {
-          sources = map (s: {name = s;}) (attrNames cfg.sources);
-
-          # TODO: try to get nvim-cmp to follow global border style
-          window = mkIf config.vim.ui.borders.enable {
-            completion = mkLuaInline "cmp.config.window.bordered()";
-            documentation = mkLuaInline "cmp.config.window.bordered()";
-          };
-
-          formatting.format = cfg.format;
-
-          # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
-          mapping = {
-            ${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
-            ${mappings.close} = mkLuaInline "cmp.mapping.abort()";
-            ${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
-            ${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
-            ${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
-
-            ${mappings.next} = mkLuaInline ''
-              cmp.mapping(function(fallback)
-                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
-
-                if cmp.visible() then
-                  cmp.select_next_item()
-                  ${optionalString luasnipEnable ''
-                elseif luasnip.locally_jumpable(1) then
-                  luasnip.jump(1)
-              ''}
-                elseif has_words_before() then
-                  cmp.complete()
-                else
-                  fallback()
-                end
-              end)
-            '';
-
-            ${mappings.previous} = mkLuaInline ''
-              cmp.mapping(function(fallback)
-                if cmp.visible() then
-                  cmp.select_prev_item()
-                  ${optionalString luasnipEnable ''
-                elseif luasnip.locally_jumpable(-1) then
-                  luasnip.jump(-1)
-              ''}
-                else
-                  fallback()
-                end
-              end)
-            '';
-          };
-        };
-      };
     };
+
+    vim.maps.insert = mkMerge [
+      (mkSetLuaBinding mappings.complete ''
+        require('cmp').complete
+      '')
+      (let
+        defaultKeys =
+          if config.vim.autopairs.enable
+          then "require('nvim-autopairs').autopairs_cr()"
+          else "vim.api.nvim_replace_termcodes(${toJSON mappings.confirm.value}, true, false, true)";
+      in
+        mkSetLuaBinding mappings.confirm ''
+          function()
+            if not require('cmp').confirm({ select = true }) then
+              vim.fn.feedkeys(${defaultKeys}, '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.pluginRC.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]
+        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',
+          ${optionalString (!cfg.alwaysComplete) "autocomplete = false"}
+        },
+
+        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

@@ -1,4 +1,4 @@
-{
+_: {
   imports = [
     ./config.nix
     ./nvim-cmp.nix

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

@@ -1,117 +1,72 @@
-{
+{lib, ...}: let
-  lib,
+  inherit (lib.options) mkEnableOption mkOption literalMD;
-  config,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
-  inherit (lib.types) str attrsOf nullOr either listOf;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf pluginType;
+  inherit (lib.types) enum attrsOf nullOr str bool;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (builtins) isString;
-
-  cfg = config.vim.autocomplete.nvim-cmp;
 in {
-  options.vim.autocomplete.nvim-cmp = {
+  options.vim = {
-    enable = mkEnableOption "nvim-cmp";
+    autocomplete = {
-    setupOpts = mkPluginSetupOption "the autocomplete plugin" {
+      enable = mkEnableOption "autocomplete" // {default = false;};
-      completion.completeopt = mkOption {
-        type = str;
-        default = "menu,menuone,noinsert";
-        description = ''
-          A comma-separated list of options for completion.
 
-          See `:help completeopt` for the complete list.
+      alwaysComplete = mkOption {
+        type = bool;
+        description = "Automatically show completion.";
+        default = true;
+      };
+
+      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]";}
         '';
       };
 
-      sorting.comparators = mkOption {
+      formatting = {
-        type = mergelessListOf (either str luaInline);
+        format = mkOption {
-        default = [
+          description = ''
-          (mkLuaInline "deprio(kinds.Text)")
+            The function used to customize the appearance of the completion menu.
-          (mkLuaInline "deprio(kinds.Snippet)")
-          "offset"
-          "exact"
-          "score"
-          "kind"
-          "length"
-          "sort_text"
-        ];
-        description = ''
-          The comparator functions used for sorting completions.
 
-          You can either pass a valid inline lua function
+            If [](#opt-vim.lsp.lspkind.enable) is true, then the function
-          (see `:help cmp-config.sorting.comparators`),
+            will be called before modifications from lspkind.
-          or a string, in which case the builtin comparator with that name will
-          be used.
 
-          A `deprio` function and a `kinds`
+            Default is to call the menu mapping function.
-          (`require("cmp.types").lsp.CompletionItemKind`) variable is provided
+          '';
-          above `setupOpts`. By passing a type to the funcion, the returned
+          type = str;
-          function will be a comparator that always ranks the specified kind the
+          default = "nvim_cmp_menu_map";
-          lowest.
+          example = literalMD ''
-        '';
+            ```lua
-        apply = map (
+            function(entry, vim_item)
-          c:
+              return vim_item
-            if isString c
+            end
-            then mkLuaInline ("cmp.config.compare." + c)
+            ```
-            else c
+          '';
-        );
+        };
       };
     };
-
-    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>";
-    };
-
-    format = mkOption {
-      type = luaInline;
-      default = mkLuaInline ''
-        function(entry, vim_item)
-          vim_item.menu = (${toLuaObject cfg.sources})[entry.source.name]
-          return vim_item
-        end
-      '';
-      defaultText = literalMD ''
-        ```lua
-        function(entry, vim_item)
-          vim_item.menu = (''${toLuaObject config.vim.autocomplete.nvim-cmp.sources})[entry.source.name]
-          return vim_item
-        end
-        ```
-      '';
-      description = ''
-        The function used to customize the completion menu entires. This is
-        outside of `setupOpts` to allow for an easier integration with
-        lspkind.nvim.
-
-        See `:help cmp-config.formatting.format`.
-      '';
-    };
-
-    sources = mkOption {
-      type = attrsOf (nullOr str);
-      default = {};
-      description = "The list of sources used by nvim-cmp";
-      example = literalExpression ''
-        {
-          nvim-cmp = null;
-          buffer = "[Buffer]";
-        }
-      '';
-    };
-
-    sourcePlugins = mkOption {
-      type = listOf pluginType;
-      default = [];
-      description = "List of source plugins used by nvim-cmp.";
-    };
   };
 }

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

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

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

@@ -2,16 +2,12 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool attrsOf str;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.debugger.nvim-dap = {
     enable = mkEnableOption "debugging via nvim-dap";
 
     ui = {
       enable = mkEnableOption "UI extension for nvim-dap";
-
-      setupOpts = mkPluginSetupOption "nvim-dap-ui" {};
-
       autoStart = mkOption {
         type = bool;
         default = true;

modules/plugins/filetree/neo-tree/config.nix

@@ -4,6 +4,8 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.filetree.neo-tree;
 in {
@@ -14,17 +16,15 @@ in {
         "plenary-nvim" # commons library
         "image-nvim" # optional for image previews
         "nui-nvim" # ui library
+        # neotree
+        "neo-tree-nvim"
       ];
 
-      lazy.plugins.neo-tree-nvim = {
+      visuals.nvimWebDevicons.enable = true;
-        package = "neo-tree-nvim";
-        setupModule = "neo-tree";
-        inherit (cfg) setupOpts;
 
-        cmd = ["Neotree"];
+      pluginRC.neo-tree = entryAnywhere ''
-      };
+        require("neo-tree").setup(${toLuaObject cfg.setupOpts})
-
+      '';
-      visuals.nvim-web-devicons.enable = true;
     };
   };
 }

modules/plugins/filetree/nvimtree/config.nix

@@ -5,9 +5,10 @@
   ...
 }: let
   inherit (lib.strings) optionalString;
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.nvim.binds) mkBinding;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.binds) pushDownDefault;
 
   cfg = config.vim.filetree.nvimTree;
@@ -15,74 +16,69 @@
   inherit (self.options.vim.filetree.nvimTree) mappings;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = ["nvim-tree-lua"];
-      binds.whichKey.register = pushDownDefault {
-        "<leader>t" = "+NvimTree";
-      };
 
-      lazy.plugins.nvim-tree-lua = {
+    vim.maps.normal = mkMerge [
-        package = "nvim-tree-lua";
+      (mkBinding cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
-        setupModule = "nvim-tree";
+      (mkBinding cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
-        inherit (cfg) setupOpts;
+      (mkBinding cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
-        cmd = ["NvimTreeClipboard" "NvimTreeClose" "NvimTreeCollapse" "NvimTreeCollapseKeepBuffers" "NvimTreeFindFile" "NvimTreeFindFileToggle" "NvimTreeFocus" "NvimTreeHiTest" "NvimTreeOpen" "NvimTreeRefresh" "NvimTreeResize" "NvimTreeToggle"];
+      (mkBinding cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
-        keys = [
+    ];
-          (mkLznBinding ["n"] cfg.mappings.toggle ":NvimTreeToggle<cr>" mappings.toggle.description)
-          (mkLznBinding ["n"] cfg.mappings.refresh ":NvimTreeRefresh<cr>" mappings.refresh.description)
-          (mkLznBinding ["n"] cfg.mappings.findFile ":NvimTreeFindFile<cr>" mappings.findFile.description)
-          (mkLznBinding ["n"] cfg.mappings.focus ":NvimTreeFocus<cr>" mappings.focus.description)
-        ];
-      };
 
-      pluginRC.nvimtreelua = entryAnywhere ''
+    vim.binds.whichKey.register = pushDownDefault {
-        ${
+      "<leader>t" = "+NvimTree";
-          optionalString cfg.setupOpts.disable_netrw ''
+    };
-            -- disable netrew completely
-            vim.g.loaded_netrw = 1
-            vim.g.loaded_netrwPlugin = 1
-          ''
-        }
 
-        ${
+    vim.pluginRC.nvimtreelua = entryAnywhere ''
-          optionalString cfg.openOnSetup ''
+      ${
-            ${optionalString config.vim.lazy.enable ''require('lz.n').trigger_load("nvim-tree-lua")''}
+        optionalString cfg.setupOpts.disable_netrw ''
-            -- autostart behaviour
+          -- disable netrew completely
-            -- Open on startup has been deprecated
+          vim.g.loaded_netrw = 1
-            -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup
+          vim.g.loaded_netrwPlugin = 1
+        ''
+      }
 
-            -- use a nix eval to dynamically insert the open on startup function
+      require'nvim-tree'.setup(${toLuaObject cfg.setupOpts})
-            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
+        optionalString cfg.openOnSetup ''
+          -- autostart behaviour
+          -- Open on startup has been deprecated
+          -- see https://github.com/nvim-tree/nvim-tree.lua/wiki/Open-At-Startup
 
-              -- buffer is a [No Name]
+          -- use a nix eval to dynamically insert the open on startup function
-                local no_name = data.file == "" and vim.bo[data.buf].buftype == ""
+          local function open_nvim_tree(data)
+            local IGNORED_FT = {
+              "markdown",
+            }
 
-              -- &ft
+            -- buffer is a real file on the disk
-              local filetype = vim.bo[data.buf].ft
+            local real_file = vim.fn.filereadable(data.file) == 1
 
-              -- only files please
+            -- buffer is a [No Name]
-              if not real_file and not no_name then
+              local no_name = data.file == "" and vim.bo[data.buf].buftype == ""
-                return
-              end
 
-              -- skip ignored filetypes
+            -- &ft
-              if vim.tbl_contains(IGNORED_FT, filetype) then
+            local filetype = vim.bo[data.buf].ft
-                return
-              end
 
-              -- open the tree but don't focus it
+            -- only files please
-              require("nvim-tree.api").tree.toggle({ focus = false })
+            if not real_file and not no_name then
+              return
             end
 
-            -- function to automatically open the tree on VimEnter
+            -- skip ignored filetypes
-            vim.api.nvim_create_autocmd({ "VimEnter" }, { callback = open_nvim_tree })
+            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/languages/asm.nix

@@ -1,49 +0,0 @@
-{
-  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.assembly;
-in {
-  options.vim.languages.assembly = {
-    enable = mkEnableOption "Assembly support";
-
-    treesitter = {
-      enable = mkEnableOption "Assembly treesitter" // {default = config.vim.languages.enableTreesitter;};
-      package = mkGrammarOption pkgs "asm";
-    };
-
-    lsp = {
-      enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.languages.enableLSP;};
-
-      package = mkOption {
-        type = package;
-        default = pkgs.asm-lsp;
-        description = "asm-lsp 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.asm-lsp = ''
-        lspconfig.asm_lsp.setup {
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = {"${cfg.lsp.package}/bin/asm-lsp"},
-        }
-      '';
-    })
-  ]);
-}

modules/plugins/languages/csharp.nix

@@ -1,122 +0,0 @@
-{
-  lib,
-  pkgs,
-  config,
-  options,
-  ...
-}: let
-  inherit (builtins) attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) either listOf package str enum;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
-  inherit (lib.strings) optionalString;
-  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
-
-  lspKeyConfig = config.vim.lsp.mappings;
-  lspKeyOptions = options.vim.lsp.mappings;
-  mkLspBinding = optionName: action: let
-    key = lspKeyConfig.${optionName};
-    desc = lspKeyOptions.${optionName}.description;
-  in
-    optionalString (key != null) "vim.keymap.set('n', '${key}', ${action}, {buffer=bufnr, noremap=true, silent=true, desc='${desc}'})";
-
-  # Omnisharp doesn't have colors in popup docs for some reason, and I've also
-  # seen mentions of it being way slower, so until someone finds missing
-  # functionality, this will be the default.
-  defaultServer = "csharp_ls";
-  servers = {
-    omnisharp = {
-      package = pkgs.omnisharp-roslyn;
-      internalFormatter = true;
-      lspConfig = ''
-        lspconfig.omnisharp.setup {
-          capabilities = capabilities,
-          on_attach = function(client, bufnr)
-            default_on_attach(client, bufnr)
-
-            local oe = require("omnisharp_extended")
-            ${mkLspBinding "goToDefinition" "oe.lsp_definition"}
-            ${mkLspBinding "goToType" "oe.lsp_type_definition"}
-            ${mkLspBinding "listReferences" "oe.lsp_references"}
-            ${mkLspBinding "listImplementations" "oe.lsp_implementation"}
-          end,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/OmniSharp'}"
-        }
-        }
-      '';
-    };
-
-    csharp_ls = {
-      package = pkgs.csharp-ls;
-      internalFormatter = true;
-      lspConfig = ''
-        local extended_handler = require("csharpls_extended").handler
-
-        lspconfig.csharp_ls.setup {
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          handlers = {
-            ["textDocument/definition"] = extended_handler,
-            ["textDocument/typeDefinition"] = extended_handler
-          },
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/csharp-ls'}"
-        }
-        }
-      '';
-    };
-  };
-
-  extraServerPlugins = {
-    omnisharp = ["omnisharp-extended"];
-    csharp_ls = ["csharpls-extended"];
-  };
-
-  cfg = config.vim.languages.csharp;
-in {
-  options = {
-    vim.languages.csharp = {
-      enable = mkEnableOption "C# language support";
-
-      treesitter = {
-        enable = mkEnableOption "C# treesitter" // {default = config.vim.languages.enableTreesitter;};
-        package = mkGrammarOption pkgs "c-sharp";
-      };
-
-      lsp = {
-        enable = mkEnableOption "C# LSP support" // {default = config.vim.languages.enableLSP;};
-        server = mkOption {
-          description = "C# LSP server to use";
-          type = enum (attrNames servers);
-          default = defaultServer;
-        };
-
-        package = mkOption {
-          description = "C# LSP server package, or the command to run as a list of strings";
-          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.startPlugins = extraServerPlugins.${cfg.lsp.server} or [];
-      vim.lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.csharp-lsp = servers.${cfg.lsp.server}.lspConfig;
-    })
-  ]);
-}

modules/plugins/languages/css.nix

@@ -63,18 +63,6 @@
         )
       '';
     };
-
-    biome = {
-      package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
-    };
   };
 in {
   options.vim.languages.css = {

modules/plugins/languages/default.nix

@@ -2,27 +2,23 @@
   inherit (lib.nvim.languages) mkEnable;
 in {
   imports = [
-    ./asm.nix
     ./bash.nix
     ./dart.nix
     ./clang.nix
     ./css.nix
     ./elixir.nix
     ./go.nix
-    ./kotlin.nix
     ./html.nix
     ./java.nix
     ./lua.nix
     ./markdown.nix
     ./nim.nix
-    ./vala.nix
     ./nix.nix
     ./ocaml.nix
     ./php.nix
     ./python.nix
     ./r.nix
     ./rust.nix
-    ./scala.nix
     ./sql.nix
     ./svelte.nix
     ./tailwind.nix
@@ -30,8 +26,6 @@ in {
     ./ts.nix
     ./typst.nix
     ./zig.nix
-    ./csharp.nix
-    ./julia.nix
   ];
 
   options.vim.languages = {

modules/plugins/languages/julia.nix

@@ -1,126 +0,0 @@
-{
-  lib,
-  pkgs,
-  config,
-  ...
-}: let
-  inherit (builtins) attrNames isList;
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) either listOf package str enum bool nullOr;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.strings) optionalString;
-  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
-
-  defaultServer = "julials";
-  servers = {
-    julials = {
-      package = pkgs.julia.withPackages ["LanguageServer"];
-      internalFormatter = true;
-      lspConfig = ''
-        lspconfig.julials.setup {
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''
-            {
-              "${optionalString (cfg.lsp.package != null) "${cfg.lsp.package}/bin/"}julia",
-              "--startup-file=no",
-              "--history-file=no",
-              "--eval",
-              [[
-                using LanguageServer
-
-                depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
-                project_path = let
-                    dirname(something(
-                        ## 1. Finds an explicitly set project (JULIA_PROJECT)
-                        Base.load_path_expand((
-                            p = get(ENV, "JULIA_PROJECT", nothing);
-                            p === nothing ? nothing : isempty(p) ? nothing : p
-                        )),
-                        ## 2. Look for a Project.toml file in the current working directory,
-                        ##    or parent directories, with $HOME as an upper boundary
-                        Base.current_project(),
-                        ## 3. First entry in the load path
-                        get(Base.load_path(), 1, nothing),
-                        ## 4. Fallback to default global environment,
-                        ##    this is more or less unreachable
-                        Base.load_path_expand("@v#.#"),
-                    ))
-                end
-                @info "Running language server" VERSION pwd() project_path depot_path
-                server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
-                server.runlinter = true
-                run(server)
-              ]]
-            }
-          ''
-        }
-        }
-      '';
-    };
-  };
-
-  cfg = config.vim.languages.julia;
-in {
-  options = {
-    vim.languages.julia = {
-      enable = mkEnableOption "Julia language support";
-
-      treesitter = {
-        enable = mkEnableOption "Julia treesitter" // {default = config.vim.languages.enableTreesitter;};
-        package = mkGrammarOption pkgs "julia";
-      };
-
-      lsp = {
-        enable = mkOption {
-          type = bool;
-          default = config.vim.languages.enableLSP;
-          description = ''
-            Whether to enable Julia LSP support.
-
-            ::: {.note}
-            The entirety of Julia is bundled with nvf, if you enable this
-            option, since there is no way to provide only the LSP server.
-
-            If you want to avoid that, you have to change
-            [](#opt-vim.languages.julia.lsp.package) to use the Julia binary
-            in {env}`PATH` (set it to `null`), and add the `LanguageServer` package to
-            Julia in your devshells.
-            :::
-          '';
-        };
-
-        server = mkOption {
-          type = enum (attrNames servers);
-          default = defaultServer;
-          description = "Julia LSP server to use";
-        };
-
-        package = mkOption {
-          description = ''
-            Julia LSP server package, `null` to use the Julia binary in {env}`PATH`, or
-            the command to run as a list of strings.
-          '';
-          type = nullOr (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.julia-lsp = servers.${cfg.lsp.server}.lspConfig;
-    })
-  ]);
-}

modules/plugins/languages/kotlin.nix

@@ -1,107 +0,0 @@
-{
-  config,
-  pkgs,
-  lib,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
-  inherit (lib.nvim.languages) diagnosticsToLua;
-  inherit (lib.types) either package listOf str;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.lists) isList;
-  inherit (lib.nvim.lua) expToLua;
-
-  cfg = config.vim.languages.kotlin;
-
-  defaultDiagnosticsProvider = ["ktlint"];
-  diagnosticsProviders = {
-    ktlint = {
-      package = pkgs.ktlint;
-      nullConfig = pkg: ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.diagnostics.ktlint.with({
-            command = "${getExe pkg}",
-          })
-        )
-      '';
-    };
-  };
-in {
-  options.vim.languages.kotlin = {
-    enable = mkEnableOption "Kotlin/HCL support";
-
-    treesitter = {
-      enable = mkEnableOption "Kotlin treesitter" // {default = config.vim.languages.enableTreesitter;};
-      package = mkGrammarOption pkgs "kotlin";
-    };
-
-    lsp = {
-      enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.languages.enableLSP;};
-
-      package = mkOption {
-        description = "kotlin_language_server package with Kotlin runtime";
-        type = either package (listOf str);
-        example = literalExpression ''
-          pkgs.symlinkJoin {
-            name = "kotlin-language-server-wrapped";
-            paths = [pkgs.kotlin-language-server];
-            nativeBuildInputs = [pkgs.makeBinaryWrapper];
-            postBuild = '''
-              wrapProgram $out/bin/kotlin-language-server \
-                --prefix PATH : ''${pkgs.kotlin}/bin
-            ''';
-          };
-        '';
-        default = pkgs.kotlin-language-server;
-      };
-    };
-
-    extraDiagnostics = {
-      enable = mkEnableOption "extra Kotlin diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
-
-      types = diagnostics {
-        langDesc = "Kotlin";
-        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.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
-      vim.lsp.null-ls.sources = diagnosticsToLua {
-        lang = "kotlin";
-        config = cfg.extraDiagnostics.types;
-        inherit diagnosticsProviders;
-      };
-    })
-
-    (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.kotlin_language_server = ''
-        lspconfig.kotlin_language_server.setup {
-          capabilities = capabilities,
-          root_dir = lspconfig.util.root_pattern("main.kt", ".git"),
-          on_attach=default_on_attach,
-          init_options = {
-          -- speeds up the startup time for the LSP
-            storagePath = vim.fn.stdpath('state') .. '/kotlin',
-          },
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/kotlin-language-server"}''
-        },
-        }
-      '';
-    })
-  ]);
-}

modules/plugins/languages/nix.nix

@@ -5,7 +5,6 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib) concatStringsSep;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
@@ -63,10 +62,10 @@
                 command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
               },
             ''}
-          ${optionalString (cfg.format.type == "nixfmt")
+          ${optionalString (cfg.format.type == "nixpkgs-fmt")
             ''
               formatting = {
-                command = {"${cfg.format.package}/bin/nixfmt"},
+                command = {"${cfg.format.package}/bin/nixpkgs-fmt"},
               },
             ''}
             },
@@ -91,19 +90,10 @@
       '';
     };
 
-    nixfmt = {
+    nixpkgs-fmt = {
-      package = pkgs.nixfmt-rfc-style;
+      package = pkgs.nixpkgs-fmt;
-      nullConfig = ''
+      # Never need to use null-ls for nixpkgs-fmt
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.nixfmt.with({
-            command = "${cfg.format.package}/bin/nixfmt"
-          })
-        )
-      '';
     };
-
-    nixpkgs-fmt = null; # removed
   };
 
   defaultDiagnosticsProvider = ["statix" "deadnix"];
@@ -145,7 +135,7 @@ in {
       enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
         description = "Nix LSP server to use";
-        type = enum (attrNames servers);
+        type = str;
         default = defaultServer;
       };
 
@@ -185,12 +175,6 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     {
-      assertions = [
-        {
-          assertion = cfg.format.type != "nixpkgs-fmt";
-          message = "nixpkgs-fmt has been archived upstream. Please use one of the following instead: ${concatStringsSep ", " (attrNames formats)}";
-        }
-      ];
       vim.pluginRC.nix = ''
         vim.api.nvim_create_autocmd("FileType", {
           pattern = "nix",

modules/plugins/languages/r.nix

@@ -15,38 +15,7 @@
   cfg = config.vim.languages.r;
 
   r-with-languageserver = pkgs.rWrapper.override {
-    packages = [pkgs.rPackages.languageserver];
+    packages = with pkgs.rPackages; [languageserver];
-  };
-
-  defaultFormat = "format_r";
-  formats = {
-    styler = {
-      package = pkgs.rWrapper.override {
-        packages = [pkgs.rPackages.styler];
-      };
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.styler.with({
-            command = "${cfg.format.package}/bin/R",
-          })
-        )
-      '';
-    };
-
-    format_r = {
-      package = pkgs.rWrapper.override {
-        packages = [pkgs.rPackages.formatR];
-      };
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.format_r.with({
-            command = "${cfg.format.package}/bin/R",
-          })
-        )
-      '';
-    };
   };
 
   defaultServer = "r_language_server";
@@ -93,22 +62,6 @@ in {
         default = servers.${cfg.lsp.server}.package;
       };
     };
-
-    format = {
-      enable = mkEnableOption "R formatting" // {default = config.vim.languages.enableFormat;};
-
-      type = mkOption {
-        type = enum (attrNames formats);
-        default = defaultFormat;
-        description = "R formatter to use";
-      };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "R formatter package";
-      };
-    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -117,11 +70,6 @@ in {
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
 
-    (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
-      vim.lsp.null-ls.sources.r-format = formats.${cfg.format.type}.nullConfig;
-    })
-
     (mkIf cfg.lsp.enable {
       vim.lsp.lspconfig.enable = true;
       vim.lsp.lspconfig.sources.r-lsp = servers.${cfg.lsp.server}.lspConfig;

modules/plugins/languages/rust.nix

@@ -9,7 +9,7 @@
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString;
-  inherit (lib.lists) isList;
+  inherit (lib.lists) isList optionals;
   inherit (lib.types) bool package str listOf either enum;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
@@ -101,7 +101,7 @@ in {
       vim = {
         startPlugins = ["crates-nvim"];
         lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
-        autocomplete.nvim-cmp.sources = {crates = "[Crates]";};
+        autocomplete.sources = {"crates" = "[Crates]";};
         pluginRC.rust-crates = entryAnywhere ''
           require('crates').setup {
             null_ls = {

modules/plugins/languages/scala.nix

@@ -1,149 +0,0 @@
-{
-  config,
-  pkgs,
-  lib,
-  ...
-}: let
-  inherit (lib.generators) mkLuaInline;
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption luaInline;
-  inherit (lib.options) mkOption mkEnableOption mkPackageOption;
-  inherit (lib.strings) optionalString;
-  inherit (lib.types) attrsOf anything bool;
-
-  listCommandsAction =
-    if config.vim.telescope.enable
-    then ''require("telescope").extensions.metals.commands()''
-    else ''require("metals").commands()'';
-
-  cfg = config.vim.languages.scala;
-
-  usingDap = config.vim.debugger.nvim-dap.enable && cfg.dap.enable;
-  usingLualine = config.vim.statusline.lualine.enable;
-in {
-  options.vim.languages.scala = {
-    enable = mkEnableOption "Scala language support";
-
-    treesitter = {
-      enable = mkEnableOption "Scala treesitter" // {default = config.vim.languages.enableTreesitter;};
-      package = mkGrammarOption pkgs "scala";
-    };
-
-    lsp = {
-      enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.languages.enableLSP;};
-      package = mkPackageOption pkgs "metals" {
-        default = ["metals"];
-      };
-
-      extraMappings = {
-        listCommands = mkMappingOption "List Metals commands" "<leader>lc";
-      };
-
-      extraSettings = mkOption {
-        type = attrsOf anything;
-        description = "Extra settings passed to the metals config. Check nvim-metals docs for available options";
-        default = {
-          showImplicitArguments = true;
-          showImplicitConversionsAndClasses = true;
-          showInferredType = true;
-          excludedPackages = [
-            "akka.actor.typed.javadsl"
-            "com.github.swagger.akka.javadsl"
-          ];
-        };
-      };
-    };
-
-    dap = {
-      enable = mkEnableOption "Scala Debug Adapter support (metals)" // {default = config.vim.languages.enableDAP;};
-      config = mkOption {
-        description = "Lua configuration for dap";
-        type = luaInline;
-        default = mkLuaInline ''
-          dap.configurations.scala = {
-            {
-              type = "scala",
-              request = "launch",
-              name = "RunOrTest",
-              metals = {
-                runType = "runOrTestFile",
-                --args = { "firstArg", "secondArg", "thirdArg" }, -- here just as an example
-              },
-            },
-            {
-              type = "scala",
-              request = "launch",
-              name = "Test Target",
-              metals = {
-                runType = "testTarget",
-              },
-            },
-          }
-        '';
-      };
-    };
-
-    fixShortmess = mkOption {
-      type = bool;
-      description = "Remove the 'F' flag from shortmess to allow messages to be shown. Without doing this, autocommands that deal with filetypes prohibit messages from being shown";
-      default = true;
-    };
-  };
-
-  config = mkIf cfg.enable (
-    mkMerge [
-      (mkIf cfg.treesitter.enable {
-        vim.treesitter.enable = true;
-        vim.treesitter.grammars = [cfg.treesitter.package];
-      })
-      (mkIf (cfg.lsp.enable || cfg.dap.enable) {
-        vim = {
-          startPlugins = ["nvim-metals"];
-          pluginRC.nvim-metals = entryAfter ["lsp-setup"] ''
-            local metals_caps = capabilities  -- from lsp-setup
-
-            local attach_metals_keymaps = function(client, bufnr)
-              attach_keymaps(client, bufnr)  -- from lsp-setup
-              vim.api.nvim_buf_set_keymap(bufnr, 'n', '${cfg.lsp.extraMappings.listCommands}', '<cmd>lua ${listCommandsAction}<CR>', {noremap=true, silent=true, desc='Show all Metals commands'})
-            end
-
-            metals_config = require('metals').bare_config()
-            ${optionalString usingLualine "metals_config.init_options.statusBarProvider = 'on'"}
-
-            metals_config.capabilities = metals_caps
-            metals_config.on_attach = function(client, bufnr)
-              ${optionalString usingDap "require('metals').setup_dap()"}
-              attach_metals_keymaps(client, bufnr)
-            end
-
-            metals_config.settings = ${toLuaObject cfg.lsp.extraSettings}
-            metals_config.settings.metalsBinaryPath = "${cfg.lsp.package}/bin/metals"
-
-            metals_config.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
-              vim.lsp.diagnostic.on_publish_diagnostics, {
-                virtual_text = {
-                  prefix = '⚠',
-                }
-              }
-            )
-
-            ${optionalString cfg.fixShortmess ''vim.opt_global.shortmess:remove("F")''}
-
-            local lsp_group = vim.api.nvim_create_augroup('lsp', { clear = true })
-
-            vim.api.nvim_create_autocmd('FileType', {
-                group = lsp_group,
-                pattern = {'java', 'scala', 'sbt'},
-                callback = function()
-                    require('metals').initialize_or_attach(metals_config)
-                end,
-            })
-          '';
-        };
-      })
-    ]
-  );
-}

modules/plugins/languages/svelte.nix

@@ -48,18 +48,6 @@
         )
       '';
     };
-
-    biome = {
-      package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
-    };
   };
 
   # TODO: specify packages

modules/plugins/languages/ts.nix

@@ -95,18 +95,6 @@
         )
       '';
     };
-
-    biome = {
-      package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
-    };
   };
 
   # TODO: specify packages

modules/plugins/languages/typst.nix

@@ -14,38 +14,6 @@
 
   cfg = config.vim.languages.typst;
 
-  defaultServer = "tinymist";
-  servers = {
-    typst-lsp = {
-      package = pkgs.typst-lsp;
-      lspConfig = ''
-        lspconfig.typst_lsp.setup {
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/typst-lsp"}''
-        },
-        }
-      '';
-    };
-    tinymist = {
-      package = pkgs.tinymist;
-      lspConfig = ''
-        lspconfig.tinymist.setup {
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/tinymist"}''
-        },
-        }
-      '';
-    };
-  };
-
   defaultFormat = "typstfmt";
   formats = {
     typstfmt = {
@@ -84,17 +52,11 @@ in {
     lsp = {
       enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.languages.enableLSP;};
 
-      server = mkOption {
-        description = "Typst LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
       package = mkOption {
         description = "typst-lsp package, or the command to run as a list of strings";
         example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
+        default = pkgs.typst-lsp;
       };
     };
 
@@ -120,14 +82,19 @@ in {
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
 
-    (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
-      vim.lsp.null-ls.sources.typst-format = formats.${cfg.format.type}.nullConfig;
-    })
-
     (mkIf cfg.lsp.enable {
       vim.lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.typst-lsp = servers.${cfg.lsp.server}.lspConfig;
+      vim.lsp.lspconfig.sources.typst-lsp = ''
+        lspconfig.typst_lsp.setup {
+          capabilities = capabilities,
+          on_attach=default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${cfg.lsp.package}/bin/typst-lsp"}''
+        },
+        }
+      '';
     })
   ]);
 }

modules/plugins/languages/vala.nix

@@ -1,79 +0,0 @@
-{
-  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.vala;
-
-  defaultServer = "vala_ls";
-  servers = {
-    vala_ls = {
-      package = pkgs.symlinkJoin {
-        name = "vala-language-server-wrapper";
-        paths = [pkgs.vala-language-server];
-        buildInputs = [pkgs.makeBinaryWrapper];
-        postBuild = ''
-          wrapProgram $out/bin/vala-language-server \
-            --prefix PATH : ${pkgs.uncrustify}/bin
-        '';
-      };
-      internalFormatter = true;
-      lspConfig = ''
-        lspconfig.vala_ls.setup {
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/vala-language-server"}''
-        },
-        }
-      '';
-    };
-  };
-in {
-  options.vim.languages.vala = {
-    enable = mkEnableOption "Vala language support";
-
-    treesitter = {
-      enable = mkEnableOption "Vala treesitter" // {default = config.vim.languages.enableTreesitter;};
-      package = mkGrammarOption pkgs "vala";
-    };
-
-    lsp = {
-      enable = mkEnableOption "Vala LSP support" // {default = config.vim.languages.enableLSP;};
-      server = mkOption {
-        description = "Vala LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Vala LSP server package, or the command to run as a list of strings";
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-      };
-    };
-  };
-
-  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.vala_ls = servers.${cfg.lsp.server}.lspConfig;
-    })
-  ]);
-}

modules/plugins/languages/zig.nix

@@ -4,33 +4,13 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
-  inherit (lib.types) either listOf package str enum;
+  inherit (lib.types) either listOf package str;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
 
-  defaultServer = "zls";
-  servers = {
-    zls = {
-      package = pkgs.zls;
-      internalFormatter = true;
-      lspConfig = ''
-        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'}"
-        }
-        }
-      '';
-    };
-  };
-
   cfg = config.vim.languages.zig;
 in {
   options.vim.languages.zig = {
@@ -42,19 +22,20 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Zig LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Zig LSP support (zls)" // {default = config.vim.languages.enableLSP;};
-
-      server = mkOption {
-        type = enum (attrNames servers);
-        default = defaultServer;
-        description = "Zig LSP server to use";
-      };
 
       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 [
@@ -65,7 +46,23 @@ in {
 
     (mkIf cfg.lsp.enable {
       vim.lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.zig-lsp = servers.${cfg.lsp.server}.lspConfig;
+      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

@@ -5,52 +5,52 @@
   ...
 }: 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.nvim-cmp.enable;
+  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:
     if binding.value != null
-    then "vim.keymap.set('n', '${binding.value}', ${action}, {buffer=bufnr, noremap=true, silent=true, desc='${binding.description}'})"
+    then "vim.api.nvim_buf_set_keymap(bufnr, 'n', '${binding.value}', '<cmd>lua ${action}<CR>', {noremap=true, silent=true, desc='${binding.description}'})"
     else "";
 in {
   config = mkIf cfg.enable {
     vim = {
-      autocomplete.nvim-cmp = {
+      startPlugins = optional usingNvimCmp "cmp-nvim-lsp";
-        sources = {nvim_lsp = "[LSP]";};
+
-        sourcePlugins = ["cmp-nvim-lsp"];
+      autocomplete.sources = {"nvim_lsp" = "[LSP]";};
-      };
 
       pluginRC.lsp-setup = ''
         vim.g.formatsave = ${boolToString cfg.formatOnSave};
 
         local attach_keymaps = function(client, bufnr)
-          ${mkBinding mappings.goToDeclaration "vim.lsp.buf.declaration"}
+          ${mkBinding mappings.goToDeclaration "vim.lsp.buf.declaration()"}
-          ${mkBinding mappings.goToDefinition "vim.lsp.buf.definition"}
+          ${mkBinding mappings.goToDefinition "vim.lsp.buf.definition()"}
-          ${mkBinding mappings.goToType "vim.lsp.buf.type_definition"}
+          ${mkBinding mappings.goToType "vim.lsp.buf.type_definition()"}
-          ${mkBinding mappings.listImplementations "vim.lsp.buf.implementation"}
+          ${mkBinding mappings.listImplementations "vim.lsp.buf.implementation()"}
-          ${mkBinding mappings.listReferences "vim.lsp.buf.references"}
+          ${mkBinding mappings.listReferences "vim.lsp.buf.references()"}
-          ${mkBinding mappings.nextDiagnostic "vim.diagnostic.goto_next"}
+          ${mkBinding mappings.nextDiagnostic "vim.diagnostic.goto_next()"}
-          ${mkBinding mappings.previousDiagnostic "vim.diagnostic.goto_prev"}
+          ${mkBinding mappings.previousDiagnostic "vim.diagnostic.goto_prev()"}
-          ${mkBinding mappings.openDiagnosticFloat "vim.diagnostic.open_float"}
+          ${mkBinding mappings.openDiagnosticFloat "vim.diagnostic.open_float()"}
-          ${mkBinding mappings.documentHighlight "vim.lsp.buf.document_highlight"}
+          ${mkBinding mappings.documentHighlight "vim.lsp.buf.document_highlight()"}
-          ${mkBinding mappings.listDocumentSymbols "vim.lsp.buf.document_symbol"}
+          ${mkBinding mappings.listDocumentSymbols "vim.lsp.buf.document_symbol()"}
-          ${mkBinding mappings.addWorkspaceFolder "vim.lsp.buf.add_workspace_folder"}
+          ${mkBinding mappings.addWorkspaceFolder "vim.lsp.buf.add_workspace_folder()"}
-          ${mkBinding mappings.removeWorkspaceFolder "vim.lsp.buf.remove_workspace_folder"}
+          ${mkBinding mappings.removeWorkspaceFolder "vim.lsp.buf.remove_workspace_folder()"}
-          ${mkBinding mappings.listWorkspaceFolders "function() vim.notify(vim.inspect(vim.lsp.buf.list_workspace_folders())) end"}
+          ${mkBinding mappings.listWorkspaceFolders "print(vim.inspect(vim.lsp.buf.list_workspace_folders()))"}
-          ${mkBinding mappings.listWorkspaceSymbols "vim.lsp.buf.workspace_symbol"}
+          ${mkBinding mappings.listWorkspaceSymbols "vim.lsp.buf.workspace_symbol()"}
-          ${mkBinding mappings.hover "vim.lsp.buf.hover"}
+          ${mkBinding mappings.hover "vim.lsp.buf.hover()"}
-          ${mkBinding mappings.signatureHelp "vim.lsp.buf.signature_help"}
+          ${mkBinding mappings.signatureHelp "vim.lsp.buf.signature_help()"}
-          ${mkBinding mappings.renameSymbol "vim.lsp.buf.rename"}
+          ${mkBinding mappings.renameSymbol "vim.lsp.buf.rename()"}
-          ${mkBinding mappings.codeAction "vim.lsp.buf.code_action"}
+          ${mkBinding mappings.codeAction "vim.lsp.buf.code_action()"}
-          ${mkBinding mappings.format "vim.lsp.buf.format"}
+          ${mkBinding mappings.format "vim.lsp.buf.format()"}
-          ${mkBinding mappings.toggleFormatOnSave "function() vim.b.disableFormatSave = not vim.b.disableFormatSave end"}
+          ${mkBinding mappings.toggleFormatOnSave "vim.b.disableFormatSave = not vim.b.disableFormatSave"}
         end
 
         -- Enable formatting
@@ -116,60 +116,7 @@ in {
         end
 
         local capabilities = vim.lsp.protocol.make_client_capabilities()
-        ${optionalString usingNvimCmp ''
+        ${optionalString usingNvimCmp "capabilities = require('cmp_nvim_lsp').default_capabilities()"}
-          -- HACK: copied from cmp-nvim-lsp. If we ever lazy load lspconfig we
-          -- should re-evaluate whether we can just use `default_capabilities`
-          capabilities = {
-            textDocument = {
-              completion = {
-                dynamicRegistration = false,
-                completionItem = {
-                  snippetSupport = true,
-                  commitCharactersSupport = true,
-                  deprecatedSupport = true,
-                  preselectSupport = true,
-                  tagSupport = {
-                    valueSet = {
-                      1, -- Deprecated
-                    }
-                  },
-                  insertReplaceSupport = true,
-                  resolveSupport = {
-                    properties = {
-                      "documentation",
-                      "detail",
-                      "additionalTextEdits",
-                      "sortText",
-                      "filterText",
-                      "insertText",
-                      "textEdit",
-                      "insertTextFormat",
-                      "insertTextMode",
-                    },
-                  },
-                  insertTextModeSupport = {
-                    valueSet = {
-                      1, -- asIs
-                      2, -- adjustIndentation
-                    }
-                  },
-                  labelDetailsSupport = true,
-                },
-                contextSupport = true,
-                insertTextMode = 1,
-                completionList = {
-                  itemDefaults = {
-                    'commitCharacters',
-                    'editRange',
-                    'insertTextFormat',
-                    'insertTextMode',
-                    'data',
-                  }
-                }
-              },
-            },
-          }
-        ''}
       '';
     };
   };

modules/plugins/lsp/lspkind/config.nix

@@ -3,32 +3,18 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkForce;
+  inherit (lib.modules) mkIf;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
-  cfg = config.vim.lsp.lspkind;
+  cfg = config.vim.lsp;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable && cfg.lspkind.enable) {
-    assertions = [
+    vim.startPlugins = ["lspkind"];
-      {
+    vim.pluginRC.lspkind = entryAnywhere ''
-        assertion = config.vim.autocomplete.nvim-cmp.enable;
+      local lspkind = require'lspkind'
-        message = ''
+      local lspkind_opts = {
-          While lspkind supports Neovim's native lsp upstream, using that over
+        mode = '${cfg.lspkind.mode}'
-          nvim-cmp isn't recommended, nor supported by nvf.
-
-          Please migrate to nvim-cmp if you want to use lspkind.
-        '';
       }
-    ];
+    '';
-
-    vim = {
-      startPlugins = ["lspkind"];
-
-      lsp.lspkind.setupOpts.before = config.vim.autocomplete.nvim-cmp.format;
-      autocomplete.nvim-cmp.setupOpts.formatting.format = mkForce (mkLuaInline ''
-        require("lspkind").cmp_format(${toLuaObject cfg.setupOpts})
-      '');
-    };
   };
 }

modules/plugins/lsp/lspkind/lspkind.nix

@@ -1,22 +1,16 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) enum nullOr;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkPluginSetupOption luaInline;
 in {
-  options.vim.lsp.lspkind = {
+  options.vim.lsp = {
-    enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
+    lspkind = {
-    setupOpts = mkPluginSetupOption "lspkind.nvim" {
+      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";
       };
-
-      before = mkOption {
-        description = "The function that will be called before lspkind's modifications are applied";
-        type = nullOr luaInline;
-        default = null;
-      };
     };
   };
 }

modules/plugins/lsp/otter/config.nix

@@ -32,7 +32,7 @@ in {
 
       pluginRC.otter-nvim = entryAnywhere ''
         -- Enable otter diagnostics viewer
-        require("otter").setup(${toLuaObject cfg.otter-nvim.setupOpts})
+        require("otter").setup({${toLuaObject cfg.otter-nvim.setupOpts}})
       '';
     };
   };

modules/plugins/lsp/trouble/config.nix

@@ -1,40 +1,41 @@
 {
   config,
   lib,
-  options,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLznBinding pushDownDefault;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding pushDownDefault;
 
   cfg = config.vim.lsp;
 
-  mappingDefinitions = options.vim.lsp.trouble.mappings;
+  self = import ./trouble.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.lsp.trouble.mappings;
   mappings = addDescriptionsToMappings cfg.trouble.mappings mappingDefinitions;
 in {
   config = mkIf (cfg.enable && cfg.trouble.enable) {
     vim = {
-      lazy.plugins.trouble = {
+      startPlugins = ["trouble"];
-        package = "trouble";
-        setupModule = "trouble";
-        inherit (cfg.trouble) setupOpts;
 
-        cmd = "Trouble";
+      maps.normal = mkMerge [
-        keys = [
+        (mkSetBinding mappings.toggle "<cmd>TroubleToggle<CR>")
-          (mkSetLznBinding mappings.toggle "<cmd>TroubleToggle<CR>")
+        (mkSetBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
-          (mkSetLznBinding mappings.workspaceDiagnostics "<cmd>TroubleToggle workspace_diagnostics<CR>")
+        (mkSetBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
-          (mkSetLznBinding mappings.documentDiagnostics "<cmd>TroubleToggle document_diagnostics<CR>")
+        (mkSetBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
-          (mkSetLznBinding mappings.lspReferences "<cmd>TroubleToggle lsp_references<CR>")
+        (mkSetBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
-          (mkSetLznBinding mappings.quickfix "<cmd>TroubleToggle quickfix<CR>")
+        (mkSetBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
-          (mkSetLznBinding mappings.locList "<cmd>TroubleToggle loclist<CR>")
+      ];
-        ];
-      };
 
       binds.whichKey.register = pushDownDefault {
         "<leader>l" = "Trouble";
         "<leader>x" = "+Trouble";
         "<leader>lw" = "Workspace";
       };
+
+      pluginRC.trouble = entryAnywhere ''
+        -- Enable trouble diagnostics viewer
+        require("trouble").setup {}
+      '';
     };
   };
 }

modules/plugins/lsp/trouble/trouble.nix

@@ -1,14 +1,11 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.lsp = {
     trouble = {
       enable = mkEnableOption "trouble diagnostics viewer";
 
-      setupOpts = mkPluginSetupOption "Trouble" {};
-
       mappings = {
         toggle = mkMappingOption "Toggle trouble [trouble]" "<leader>xx";
         workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";

modules/plugins/notes/default.nix

@@ -2,7 +2,6 @@
   imports = [
     ./obsidian
     ./orgmode
-    ./neorg
     ./mind-nvim
     ./todo-comments
   ];

modules/plugins/notes/neorg/config.nix

@@ -1,41 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.binds) pushDownDefault;
-  inherit (lib.nvim.lua) toLuaObject;
-
-  cfg = config.vim.notes.neorg;
-in {
-  config = mkIf cfg.enable (mkMerge [
-    {
-      vim = {
-        startPlugins = [
-          "lua-utils-nvim"
-          "nui-nvim"
-          "nvim-nio"
-          "pathlib-nvim"
-          "plenary-nvim"
-          "neorg"
-          "neorg-telescope"
-        ];
-
-        binds.whichKey.register = pushDownDefault {
-          "<leader>o" = "+Notes";
-        };
-
-        pluginRC.neorg = entryAnywhere ''
-          require('neorg').setup(${toLuaObject cfg.setupOpts})
-        '';
-      };
-    }
-
-    (mkIf cfg.treesitter.enable {
-      vim.treesitter.enable = true;
-      vim.treesitter.grammars = [cfg.treesitter.norgPackage];
-    })
-  ]);
-}

modules/plugins/notes/neorg/default.nix

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

modules/plugins/notes/neorg/neorg.nix

@@ -1,50 +0,0 @@
-{
-  config,
-  lib,
-  pkgs,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) submodule listOf str;
-  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
-in {
-  options.vim.notes.neorg = {
-    enable = mkEnableOption ''
-      Neorg: An intuitive note-taking and organization tool with a structured nested syntax.
-    '';
-
-    setupOpts = mkPluginSetupOption "Neorg" {
-      load = {
-        "core.defaults" = mkOption {
-          default = {};
-          description = ''
-            all of the most important modules that any user would want to have a "just works" experience
-          '';
-
-          type = submodule {
-            options = {
-              enable = mkEnableOption ''
-                all of the most important modules that any user would want to have a "just works" experience
-              '';
-              config = {
-                disable = mkOption {
-                  description = ''
-                    list of modules from to be disabled from core.defaults
-                  '';
-                  type = listOf str;
-                  default = [];
-                  example = ["core.autocommands" "core.itero"];
-                };
-              };
-            };
-          };
-        };
-      };
-    };
-
-    treesitter = {
-      enable = mkEnableOption "Neorg treesitter" // {default = config.vim.languages.enableTreesitter;};
-      norgPackage = mkGrammarOption pkgs "norg";
-    };
-  };
-}

modules/plugins/notes/obsidian/obsidian.nix

@@ -45,10 +45,10 @@ in {
 
         completion = {
           nvim_cmp = mkOption {
-            # If using nvim-cmp, otherwise set to false
+            # if using nvim-cmp, otherwise set to false
             type = bool;
             description = "If using nvim-cmp, otherwise set to false";
-            default = config.vim.autocomplete.nvim-cmp.enable;
+            default = config.vim.autocomplete.type == "nvim-cmp";
           };
         };
       };

modules/plugins/snippets/default.nix

@@ -1,5 +1,5 @@
 {
   imports = [
-    ./luasnip
+    ./vsnip
   ];
 }

modules/plugins/snippets/luasnip/config.nix

@@ -1,26 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-
-  cfg = config.vim.snippets.luasnip;
-in {
-  config = mkIf cfg.enable {
-    vim = {
-      lazy.plugins = {
-        luasnip = {
-          package = "luasnip";
-          lazy = true;
-          after = cfg.loaders;
-        };
-      };
-      startPlugins = cfg.providers;
-      autocomplete.nvim-cmp = {
-        sources = {luasnip = "[LuaSnip]";};
-        sourcePlugins = ["cmp-luasnip"];
-      };
-    };
-  };
-}

modules/plugins/snippets/luasnip/default.nix

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

modules/plugins/snippets/luasnip/luasnip.nix

@@ -1,36 +0,0 @@
-{lib, ...}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
-  inherit (lib.types) listOf lines;
-  inherit (lib.nvim.types) pluginType;
-in {
-  options.vim.snippets.luasnip = {
-    enable = mkEnableOption "luasnip";
-    providers = mkOption {
-      type = listOf pluginType;
-      default = ["friendly-snippets"];
-      description = ''
-        The snippet provider packages.
-
-        ::: {.note}
-        These are simply appended to {option} `vim.startPlugins`.
-        :::
-      '';
-      example = literalExpression "[\"vimPlugins.vim-snippets\"]";
-    };
-    loaders = mkOption {
-      type = lines;
-      default = "require('luasnip.loaders.from_vscode').lazy_load()";
-      defaultText = literalMD ''
-        ```lua
-        require('luasnip.loaders.from_vscode').lazy_load()
-        ```
-      '';
-      description = "Lua code used to load snippet providers.";
-      example = literalMD ''
-        ```lua
-        require("luasnip.loaders.from_snipmate").lazy_load()
-        ```
-      '';
-    };
-  };
-}

modules/plugins/snippets/vsnip/config.nix

@@ -0,0 +1,13 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.snippets.vsnip;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = ["vim-vsnip"];
+  };
+}

modules/plugins/snippets/vsnip/default.nix

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

modules/plugins/snippets/vsnip/vsnip.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.snippets.vsnip = {
+    enable = mkEnableOption "vim-vsnip: snippet LSP/VSCode's format";
+  };
+}

modules/plugins/spellcheck/vim-dirtytalk/config.nix

@@ -7,26 +7,16 @@
   inherit (lib.nvim.dag) entryAfter;
   cfg = config.vim.spellcheck;
 in {
-  config = mkIf cfg.programmingWordlist.enable {
+  config = mkIf (cfg.enable && cfg.programmingWordlist.enable) {
     vim = {
       startPlugins = ["vim-dirtytalk"];
 
-      spellcheck.enable = true;
+      # vim-dirtytalk doesn't have any setup
-
+      # but we would like to append programming to spelllang
-      # vim-dirtytalk doesn't have any setup but we would
+      # as soon as possible while the plugin is enabled
-      # like to append programming to spelllangs as soon as
+      pluginRC.vim-dirtytalk = entryAfter ["basic"] ''
-      # possible while the plugin is enabled and the state
+        -- append programming to spelllang
-      # directory can be found.
+        vim.opt.spelllang:append("programming")
-      pluginRC.vim-dirtytalk = entryAfter ["spellcheck"] ''
-        -- If Neovim can find (or access) the state directory
-        -- then append "programming" wordlist from vim-dirtytalk
-        -- to spelllang table. If path cannot be found, display
-        -- an error and avoid appending the programming words
-        if vim.fn.isdirectory(vim.fn.stdpath('state')) == 1 then
-          vim.opt.spelllang:append("programming")
-        else
-          vim.notify("State path does not exist: " .. state_path, vim.log.levels.ERROR)
-        end
       '';
     };
   };

modules/plugins/tabline/nvim-bufferline/config.nix

@@ -15,14 +15,10 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = [
-        "nvim-bufferline-lua"
+        (assert config.vim.visuals.nvimWebDevicons.enable; "nvim-bufferline-lua")
         "bufdelete-nvim"
       ];
 
-      # Soft-dependency for bufferline.
-      # Recommended by upstream, so enabled here.
-      visuals.nvim-web-devicons.enable = true;
-
       maps.normal = mkMerge [
         (mkLuaBinding cfg.mappings.closeCurrent "require(\"bufdelete\").bufdelete" mappings.closeCurrent.description)
         (mkBinding cfg.mappings.cycleNext ":BufferLineCycleNext<CR>" mappings.cycleNext.description)

modules/plugins/terminal/toggleterm/config.nix

@@ -3,31 +3,39 @@
   lib,
   ...
 }: let
-  inherit (lib.strings) optionalString;
+  inherit (builtins) toJSON;
-  inherit (lib.lists) optional;
+  inherit (lib.lists) optionals;
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.terminal.toggleterm;
-  lazygitMapDesc = "Open lazygit [toggleterm]";
 in {
-  config = mkIf cfg.enable {
+  config = mkMerge [
-    vim = {
+    (
-      lazy.plugins.toggleterm-nvim = {
+      mkIf cfg.enable {
-        package = "toggleterm-nvim";
+        vim = {
-        cmd = ["ToggleTerm" "ToggleTermSendCurrentLine" "ToggleTermSendVisualLines" "ToggleTermSendVisualSelection" "ToggleTermSetName" "ToggleTermToggleAll"];
+          startPlugins = [
-        keys =
+            "toggleterm-nvim"
-          [(mkLznBinding ["n"] cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal")]
+          ];
-          ++ optional cfg.lazygit.enable {
-            key = cfg.lazygit.mappings.open;
-            desc = lazygitMapDesc;
-          };
 
-        setupModule = "toggleterm";
+          maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
-        inherit (cfg) setupOpts;
+
-        after = optionalString cfg.lazygit.enable ''
+          pluginRC.toggleterm = entryAnywhere ''
+            require("toggleterm").setup(${toLuaObject cfg.setupOpts})
+          '';
+        };
+      }
+    )
+    (
+      mkIf (cfg.enable && cfg.lazygit.enable)
+      {
+        vim.startPlugins = optionals (cfg.lazygit.package != null) [
+          cfg.lazygit.package
+        ];
+        vim.pluginRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
           local terminal = require 'toggleterm.terminal'
           local lazygit = terminal.Terminal:new({
             cmd = '${
@@ -42,9 +50,9 @@ in {
             end
           })
 
-          vim.keymap.set('n', ${toLuaObject cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = '${lazygitMapDesc}'})
+          vim.keymap.set('n', ${toJSON cfg.lazygit.mappings.open}, function() lazygit:toggle() end, {silent = true, noremap = true, desc = 'Open lazygit [toggleterm]'})
         '';
-      };
+      }
-    };
+    )
-  };
+  ];
 }

modules/plugins/theme/config.nix

@@ -5,7 +5,7 @@ in {
     vim.theme = {
       enable = mkDefault false;
       name = mkDefault "onedark";
-      style = mkDefault "darker";
+      # style = mkDefault "darker";
       transparent = mkDefault false;
       extraConfig = mkDefault "";
     };

modules/plugins/theme/supported-themes.nix

@@ -2,105 +2,139 @@
   config,
   lib,
 }: let
-  inherit (lib.strings) optionalString;
+  inherit (lib.strings) hasPrefix optionalString;
-  inherit (lib.trivial) boolToString warnIf;
+  inherit (lib.attrsets) genAttrs listToAttrs mergeAttrsList;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) bool str;
+  inherit (lib.nvim.types) hexColor mkPluginSetupOption;
+  cfg = config.vim.theme;
+
+  mkEnableOption' = name: mkEnableOption name // {default = true;};
+  numbers = ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"];
+  base16Options = listToAttrs (map (n: {
+      name = "base0${n}";
+      value = mkOption {
+        description = "The base0${n} color to use";
+        type = hexColor;
+        apply = v:
+          if hasPrefix "#" v
+          then v
+          else "#${v}";
+      };
+    })
+    numbers);
 in {
   base16 = {
-    setup = {base16-colors, ...}: ''
+    setupOpts = mkPluginSetupOption "base16" base16Options;
-      -- Base16 theme
+    setup = "";
-      require('base16-colorscheme').setup(${toLuaObject base16-colors})
-    '';
   };
+
   onedark = {
-    setup = {style ? "dark", ...}: ''
+    setupOpts = mkPluginSetupOption "onedark" {
+      style = mkOption {
+        type = str;
+        default = cfg.style;
+        internal = true;
+      };
+    };
+    setup = ''
       -- OneDark theme
-      require('onedark').setup {
-        style = "${style}"
-      }
       require('onedark').load()
     '';
     styles = ["dark" "darker" "cool" "deep" "warm" "warmer"];
   };
 
   tokyonight = {
-    setup = {
+    setupOpts = mkPluginSetupOption "tokyonight" {
-      style ? "night",
+      transparent = mkOption {
-      transparent,
+        type = bool;
-      ...
+        default = cfg.transparent;
-    }: ''
+        internal = true;
-      require('tokyonight').setup {
+      };
-        transparent = ${boolToString transparent};
+    };
-      }
+    setup = ''
-      vim.cmd[[colorscheme tokyonight-${style}]]
+      vim.cmd[[colorscheme tokyonight-${cfg.style}]]
     '';
-    styles = ["day" "night" "storm" "moon"];
+    styles = ["night" "day" "storm" "moon"];
   };
 
   dracula = {
-    setup = {transparent, ...}: ''
+    setupOpts = mkPluginSetupOption "dracula" {
-      require('dracula').setup({
+      transparent_bg = mkOption {
-        transparent_bg = ${boolToString transparent},
+        type = bool;
-      });
+        default = cfg.transparent;
+        internal = true;
+      };
+    };
+    setup = ''
       require('dracula').load();
     '';
   };
 
   catppuccin = {
-    setup = {
+    setupOpts = mkPluginSetupOption "catppuccin" {
-      style ? "mocha",
+      flavour = mkOption {
-      transparent ? false,
+        type = str;
-      ...
+        default = cfg.style;
-    }: ''
+        # internal = true;
-      -- Catppuccin theme
+      };
-      require('catppuccin').setup {
+      transparent_background = mkOption {
-        flavour = "${style}",
+        type = bool;
-        transparent_background = ${boolToString transparent},
+        default = cfg.transparent;
-        term_colors = true,
+        internal = true;
-        integrations = {
+      };
-      	  nvimtree = {
+      term_colors = mkEnableOption' "term_colors";
-      		  enabled = true,
+      integrations =
-      		  transparent_panel = ${boolToString transparent},
+        {
-      		  show_root = true,
+          nvimtree = {
-      	  },
+            enabled = mkEnableOption' "enabled";
+            transparent_panel = mkOption {
+              type = bool;
+              default = cfg.transparent;
+            };
+            show_root = mkEnableOption' "show_root";
+          };
 
-          hop = true,
-      	  gitsigns = true,
-      	  telescope = true,
-      	  treesitter = true,
-          treesitter_context = true,
-      	  ts_rainbow = true,
-          fidget = true,
-          alpha = true,
-          leap = true,
-          markdown = true,
-          noice = true,
-          notify = true, -- nvim-notify
-          which_key = true,
           navic = {
-            enabled = true,
+            enabled = mkEnableOption' "enabled";
-            custom_bg = "NONE", -- "lualine" will set background to mantle
+            # lualine will set backgound to mantle
-          },
+            custom_bg = mkOption {
-        },
+              type = str;
-      }
+              default = "NONE";
+            };
+          };
+        }
+        // genAttrs [
+          "hop"
+          "gitsigns"
+          "telescope"
+          "treesitter"
+          "treesitter_context"
+          "ts_rainbow"
+          "fidget"
+          "alpha"
+          "leap"
+          "markdown"
+          "noice"
+          "notify"
+          "which_key"
+        ] (name: mkEnableOption' name);
+    };
+    setup = ''
+      -- Catppuccin theme
       -- setup must be called before loading
       vim.cmd.colorscheme "catppuccin"
     '';
-    styles = ["latte" "frappe" "macchiato" "mocha"];
+    styles = ["mocha" "latte" "frappe" "macchiato"];
   };
 
   oxocarbon = {
-    setup = {
+    setupOpts = {};
-      style ? "dark",
+    setup = ''
-      transparent ? false,
-    }: let
-      style' =
-        warnIf (style == "light") "oxocarbon: light theme is not well-supported" style;
-    in ''
        require('oxocarbon')
-       vim.opt.background = "${style'}"
+       vim.opt.background = "${cfg.style}"
        vim.cmd.colorscheme = "oxocarbon"
-      ${optionalString transparent ''
+      ${optionalString cfg.transparent ''
         vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
         vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
         vim.api.nvim_set_hl(0, "LineNr", { bg = "none" })
@@ -114,62 +148,84 @@ in {
   };
 
   gruvbox = {
-    setup = {
+    setupOpts =
-      style ? "dark",
+      mkPluginSetupOption "gruvbox" {
-      transparent ? false,
+        transparent_mode = mkOption {
-    }: ''
+          type = bool;
+          default = cfg.transparent;
+          internal = true;
+        };
+        italic =
+          {
+            operators = mkEnableOption "operators";
+          }
+          // genAttrs [
+            "strings"
+            "emphasis"
+            "comments"
+            "folds"
+          ] (name: mkEnableOption' name);
+
+        contrast = mkOption {
+          type = str;
+          default = "";
+        };
+        # TODO: fix these
+        # palette_overrides = mkLuaInline "{}";
+        # overrides = mkLuaInline "{}";
+      }
+      // mergeAttrsList [
+        (genAttrs [
+          "terminal_colors"
+          "undercurls"
+          "underline"
+          "bold"
+          "strikethrough"
+          "inverse"
+        ] (name: mkEnableOption' name))
+        (genAttrs [
+          "invert_selection"
+          "invert_signs"
+          "invert_tabline"
+          "invert_intend_guides"
+          "dim_inactive"
+        ] (name: mkEnableOption name))
+      ];
+    setup = ''
       -- Gruvbox theme
-      require("gruvbox").setup({
+      vim.o.background = "${cfg.style}"
-        terminal_colors = true, -- add neovim terminal colors
-        undercurl = true,
-        underline = true,
-        bold = true,
-        italic = {
-        strings = true,
-        emphasis = true,
-        comments = true,
-        operators = false,
-        folds = true,
-        },
-        strikethrough = true,
-        invert_selection = false,
-        invert_signs = false,
-        invert_tabline = false,
-        invert_intend_guides = false,
-        inverse = true,
-        contrast = "",
-        palette_overrides = {},
-        overrides = {},
-        dim_inactive = false,
-        transparent_mode = ${boolToString transparent},
-      })
-      vim.o.background = "${style}"
       vim.cmd("colorscheme gruvbox")
     '';
     styles = ["dark" "light"];
   };
   rose-pine = {
-    setup = {
+    setupOpts = mkPluginSetupOption "rose-pine" {
-      style ? "main",
+      dark_variant = mkOption {
-      transparent ? false,
+        type = str;
-    }: ''
+        default = cfg.style;
-      require("rose-pine").setup({
+        internal = true;
-        dark_variant = "${style}", -- main, moon, or dawn
+      };
-        dim_inactive_windows = false,
+      dim_inactive_windows = mkEnableOption "dim_inactive_windows";
-        extend_background_behind_borders = true,
+      extend_background_behind_borders = mkEnableOption' "extend_background_behind_borders";
 
-        enable = {
+      enable = {
-          terminal = true,
+        terminal = mkEnableOption' "terminal";
-          migrations = true,
+        migrations = mkEnableOption' "migrations";
-        },
+      };
 
-        styles = {
+      styles = {
-          bold = false,
+        bold = mkEnableOption "bold";
-          italic = false, -- I would like to add more options for this
+        # I would like to add more options for this
-          transparency = ${boolToString transparent},
+        italic = mkEnableOption "italic";
-        },
+        transparency = mkOption {
-      })
+          type = bool;
+          default = cfg.transparent;
+          internal = true;
+        };
+      };
+    };
 
+    setup = ''
       vim.cmd("colorscheme rose-pine")
     '';
     styles = ["main" "moon" "dawn"];

modules/plugins/theme/supported-themes/base16.nix

@@ -0,0 +1,43 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  cfg = config.vim.theme;
+  inherit (lib.strings) hasPrefix;
+  inherit (lib.attrsets) listToAttrs;
+  inherit (lib.options) mkOption;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) hexColor mkPluginSetupOption;
+  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  numbers = ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"];
+  base16Options = listToAttrs (map (n: {
+      name = "base0${n}";
+      value = mkOption {
+        description = "The base0${n} color to use";
+        type = hexColor;
+        apply = v:
+          if hasPrefix "#" v
+          then v
+          else "#${v}";
+      };
+    })
+    numbers);
+in {
+  base16 = {
+    setupOpts = mkPluginSetupOption "base16" base16Options;
+    setup = "";
+  };
+  config =
+    mkIf cfg.name
+    == "base16" {
+      vim = {
+        startPlugins = ["base16"];
+        luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
+          require('base16-colorscheme').setup(${toLuaObject cfg.setupOpts})
+        '';
+      };
+    };
+}

modules/plugins/theme/supported-themes/catppuccin.nix

@@ -0,0 +1,78 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  cfg = config.vim.theme;
+  inherit (lib.strings) hasPrefix optionalString;
+  inherit (lib.attrsets) genAttrs listToAttrs mergeAttrsList;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) bool str;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) hexColor mkPluginSetupOption;
+  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.lua) toLuaObject;
+  mkEnableOption' = name: mkEnableOption name // {default = true;};
+in {
+  catppuccin = {
+    setupOpts = mkPluginSetupOption "catppuccin" {
+      flavour = mkOption {
+        type = str;
+        default = cfg.style;
+        # internal = true;
+      };
+      transparent_background = mkOption {
+        type = bool;
+        default = cfg.transparent;
+        internal = true;
+      };
+      term_colors = mkEnableOption' "term_colors";
+      integrations =
+        {
+          nvimtree = {
+            enabled = mkEnableOption' "enabled";
+            transparent_panel = mkOption {
+              type = bool;
+              default = cfg.transparent;
+            };
+            show_root = mkEnableOption' "show_root";
+          };
+
+          navic = {
+            enabled = mkEnableOption' "enabled";
+            # lualine will set backgound to mantle
+            custom_bg = mkOption {
+              type = str;
+              default = "NONE";
+            };
+          };
+        }
+        // genAttrs [
+          "hop"
+          "gitsigns"
+          "telescope"
+          "treesitter"
+          "treesitter_context"
+          "ts_rainbow"
+          "fidget"
+          "alpha"
+          "leap"
+          "markdown"
+          "noice"
+          "notify"
+          "which_key"
+        ] (name: mkEnableOption' name);
+    };
+  };
+  config =
+    mkIf cfg.name
+    == "catppuccin" {
+      vim = {
+        startPlugins = ["catppuccin"];
+        luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
+            then "require('catppuccin').setup(${toLuaObject cfg.setupOpts})"
+          }
+        '';
+      };
+    };
+}

modules/plugins/theme/theme.nix

@@ -5,34 +5,20 @@
 }: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames;
-  inherit (lib.strings) hasPrefix;
+  inherit (lib.strings) elemAt;
   inherit (lib.types) bool lines enum;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.dag) entryBefore;
-  inherit (lib.nvim.types) hexColor;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.theme;
   supportedThemes = import ./supported-themes.nix {
     inherit lib config;
   };
-
-  numbers = ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"];
-  base16Options =
-    mapListToAttrs (n: {
-      name = "base0${n}";
-      value = mkOption {
-        description = "The base0${n} color to use";
-        type = hexColor;
-        apply = v:
-          if hasPrefix "#" v
-          then v
-          else "#${v}";
-      };
-    })
-    numbers;
 in {
   options.vim.theme = {
+    inherit (supportedThemes.${cfg.name}) setupOpts;
+
     enable = mkOption {
       type = bool;
       description = "Enable theming";
@@ -45,10 +31,9 @@ in {
         requires all of the colors in {option}`vim.theme.base16-colors` to be set.
       '';
     };
-    base16-colors = base16Options;
-
     style = mkOption {
       type = enum supportedThemes.${cfg.name}.styles;
+      default = elemAt supportedThemes.${cfg.name}.styles 0;
       description = "Specific style for theme if it supports it";
     };
     transparent = mkOption {
@@ -64,11 +49,23 @@ in {
   };
 
   config = mkIf cfg.enable {
-    vim = {
+    vim = let
+      name' =
+        if cfg.name == "base16"
+        then "base16-colorscheme"
+        else cfg.name;
+    in {
       startPlugins = [cfg.name];
-      luaConfigRC.theme = entryBefore ["pluginConfigs" "lazyConfigs"] ''
+      luaConfigRC.theme = entryBefore ["pluginConfigs"] ''
-        ${cfg.extraConfig}
+         ${cfg.extraConfig}
-        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent base16-colors;}}
+
+        ${
+          if name' != "oxocarbon"
+          then "require('${name'}').setup(${toLuaObject cfg.setupOpts})"
+          else ""
+        }
+
+        ${supportedThemes.${cfg.name}.setup}
       '';
     };
   };

modules/plugins/treesitter/config.nix

@@ -5,12 +5,13 @@
   ...
 }: let
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) optionals;
+  inherit (lib.lists) optional optionals;
   inherit (lib.nvim.binds) mkSetBinding addDescriptionsToMappings;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.dag) entryBefore entryAfter;
 
   cfg = config.vim.treesitter;
+  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
 
   self = import ./treesitter.nix {inherit pkgs lib;};
   mappingDefinitions = self.options.vim.treesitter.mappings;
@@ -18,13 +19,9 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["nvim-treesitter"];
+      startPlugins = ["nvim-treesitter"] ++ optional usingNvimCmp "cmp-treesitter";
-
-      autocomplete.nvim-cmp = {
-        sources = {treesitter = "[Treesitter]";};
-        sourcePlugins = ["cmp-treesitter"];
-      };
 
+      autocomplete.sources = {"treesitter" = "[Treesitter]";};
       treesitter.grammars = optionals cfg.addDefaultGrammars cfg.defaultGrammars;
 
       maps = {

modules/plugins/ui/noice/noice.nix

@@ -21,7 +21,7 @@ in {
             mkBool true "override the lsp markdown formatter with Noice";
 
           "cmp.entry.get_documentation" =
-            mkBool config.vim.autocomplete.nvim-cmp.enable "override cmp documentation with Noice";
+            mkBool (config.vim.autocomplete.type == "nvim-cmp") "override cmp documentation with Noice";
         };
 
         signature = {

modules/plugins/utility/binds/cheatsheet/config.nix

@@ -4,18 +4,15 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.binds.cheatsheet;
 in {
   config = mkIf cfg.enable {
-    vim.lazy.plugins.cheatsheet-nvim = {
+    vim.startPlugins = ["cheatsheet-nvim"];
-      package = "cheatsheet-nvim";
-      setupModule = "cheatsheet";
-      setupOpts = {};
-      cmd = ["Cheatsheet" "CheatsheetEdit"];
 
-      before = optionalString config.vim.lazy.enable "require('lz.n').trigger_load('telescope')";
+    vim.pluginRC.cheaetsheet-nvim = entryAnywhere ''
-    };
+      require('cheatsheet').setup({})
+    '';
   };
 }

modules/plugins/utility/binds/which-key/config.nix

@@ -4,23 +4,33 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.attrsets) mapAttrsToList;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.binds.whichKey;
-  register = mapAttrsToList (n: v: mkLuaInline "{ '${n}', desc = '${v}' }") cfg.register;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = ["which-key"];
-      startPlugins = ["which-key"];
 
-      pluginRC.whichkey = entryAnywhere ''
+    vim.pluginRC.whichkey = entryAnywhere ''
-        local wk = require("which-key")
+      local wk = require("which-key")
-        wk.setup (${toLuaObject cfg.setupOpts})
+      wk.setup ({
-        wk.add(${toLuaObject register})
+        key_labels = {
-      '';
+          ["<space>"] = "SPACE",
-    };
+          ["<leader>"] = "SPACE",
+          ["<cr>"] = "RETURN",
+          ["<tab>"] = "TAB",
+        },
+
+        ${optionalString config.vim.ui.borders.plugins.which-key.enable ''
+        window = {
+          border = ${toLuaObject config.vim.ui.borders.plugins.which-key.style},
+        },
+      ''}
+      })
+
+      wk.register(${toLuaObject cfg.register})
+    '';
   };
 }

modules/plugins/utility/binds/which-key/default.nix

@@ -1,4 +1,4 @@
-{
+_: {
   imports = [
     ./which-key.nix
     ./config.nix

modules/plugins/utility/binds/which-key/which-key.nix

@@ -1,51 +1,14 @@
-{
+{lib, ...}: let
-  config,
+  inherit (lib.options) mkEnableOption mkOption;
-  lib,
+  inherit (lib.types) attrsOf nullOr str;
-  ...
-}: let
-  inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.types) attrsOf nullOr str attrs enum bool;
-  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.binds.whichKey = {
     enable = mkEnableOption "which-key keybind helper menu";
+
     register = mkOption {
+      description = "Register label for which-key keybind helper menu";
       type = attrsOf (nullOr str);
       default = {};
-      description = "Register label for which-key keybind helper menu";
-    };
-
-    setupOpts = mkPluginSetupOption "which-key" {
-      preset = mkOption {
-        type = enum ["classic" "modern" "helix"];
-        default = "modern";
-        description = "The default preset for the which-key window";
-      };
-
-      notify = mkOption {
-        type = bool;
-        default = true;
-        description = "Show a warning when issues were detected with mappings";
-      };
-
-      replace = mkOption {
-        type = attrs;
-        default = {
-          "<space>" = "SPACE";
-          "<leader>" = "SPACE";
-          "<cr>" = "RETURN";
-          "<tab>" = "TAB";
-        };
-        description = "Functions/Lua Patterns for formatting the labels";
-      };
-
-      win = {
-        border = mkOption {
-          type = str;
-          default = config.vim.ui.borders.plugins.which-key.style;
-          description = "Which-key window border style";
-        };
-      };
     };
   };
 }

modules/plugins/utility/diffview/config.nix

@@ -8,14 +8,9 @@
   cfg = config.vim.utility.diffview-nvim;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = [
-      startPlugins = ["plenary-nvim"];
+      "diffview-nvim"
-      lazy.plugins.diffview-nvim = {
+      "plenary-nvim"
-        package = "diffview-nvim";
+    ];
-        cmd = ["DiffviewClose" "DiffviewFileHistory" "DiffviewFocusFiles" "DiffviewLog" "DiffviewOpen" "DiffviewRefresh" "DiffviewToggleFiles"];
-        setupModule = "diffview";
-        inherit (cfg) setupOpts;
-      };
-    };
   };
 }

modules/plugins/utility/diffview/diffview.nix

@@ -1,9 +1,7 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.utility.diffview-nvim = {
     enable = mkEnableOption "diffview-nvim: cycle through diffs for all modified files for any git rev";
-    setupOpts = mkPluginSetupOption "Fidget" {};
   };
 }

modules/plugins/utility/icon-picker/config.nix

@@ -4,20 +4,20 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.icon-picker;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = ["dressing-nvim"];
+    vim.startPlugins = [
+      "icon-picker-nvim"
+      "dressing-nvim"
+    ];
 
-    vim.lazy.plugins.icon-picker-nvim = {
+    vim.pluginRC.icon-picker = entryAnywhere ''
-      package = "icon-picker-nvim";
+      require("icon-picker").setup({
-      setupModule = "icon-picker";
+        disable_legacy_commands = true
-      setupOpts = {
+      })
-        disable_legacy_commands = true;
+    '';
-      };
-
-      cmd = ["IconPickerInsert" "IconPickerNormal" "IconPickerYank"];
-    };
   };
 }

modules/plugins/utility/motion/default.nix

@@ -2,6 +2,5 @@ _: {
   imports = [
     ./hop
     ./leap
-    ./precognition
   ];
 }

modules/plugins/utility/motion/leap/config.nix

@@ -3,59 +3,71 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkDefault;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) mkLznBinding;
+  inherit (lib.nvim.binds) mkBinding;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.motion.leap;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = [
-      startPlugins = ["vim-repeat"];
+      "leap-nvim"
-      lazy.plugins.leap-nvim = {
+      "vim-repeat"
-        package = "leap-nvim";
+    ];
-        keys = [
-          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
-          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
-          (mkLznBinding ["n" "o" "x"] cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-        ];
 
-        after = ''
+    vim.maps.normal = mkMerge [
-          require('leap').opts = {
+      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
-            max_phase_one_targets = nil,
+      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
-            highlight_unlabeled_phase_one_targets = false,
+      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
-            max_highlighted_traversal_targets = 10,
+    ];
-            case_sensitive = false,
-            equivalence_classes = { ' \t\r\n', },
-            substitute_chars = {},
-            safe_labels = {
-              "s", "f", "n", "u", "t", "/",
-              "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
-            },
-            labels = {
-              "s", "f", "n",
-              "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
-              "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
-              "S", "F", "N",
-              "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
-              "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
-            },
-            special_keys = {
-              repeat_search = '<enter>',
-              next_phase_one_target = '<enter>',
-              next_target = {'<enter>', ';'},
-              prev_target = {'<tab>', ','},
-              next_group = '<space>',
-              prev_group = '<tab>',
-              multi_accept = '<enter>',
-              multi_revert = '<backspace>',
-            },
-          }
-        '';
-      };
 
-      binds.whichKey.register."<leader>s" = mkDefault "+Leap";
+    vim.maps.operator = mkMerge [
-    };
+      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
+    ];
+
+    vim.maps.visualOnly = mkMerge [
+      (mkBinding cfg.mappings.leapForwardTo "<Plug>(leap-forward-to)" "Leap forward to")
+      (mkBinding cfg.mappings.leapBackwardTo "<Plug>(leap-backward-to)" "Leap backward to")
+      (mkBinding cfg.mappings.leapForwardTill "<Plug>(leap-forward-till)" "Leap forward till")
+      (mkBinding cfg.mappings.leapBackwardTill "<Plug>(leap-backward-till)" "Leap backward till")
+      (mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
+    ];
+
+    vim.pluginRC.leap-nvim = entryAnywhere ''
+      require('leap').opts = {
+        max_phase_one_targets = nil,
+        highlight_unlabeled_phase_one_targets = false,
+        max_highlighted_traversal_targets = 10,
+        case_sensitive = false,
+        equivalence_classes = { ' \t\r\n', },
+        substitute_chars = {},
+        safe_labels = {
+          "s", "f", "n", "u", "t", "/",
+          "S", "F", "N", "L", "H", "M", "U", "G", "T", "?", "Z"
+        },
+        labels = {
+          "s", "f", "n",
+          "j", "k", "l", "h", "o", "d", "w", "e", "m", "b",
+          "u", "y", "v", "r", "g", "t", "c", "x", "/", "z",
+          "S", "F", "N",
+          "J", "K", "L", "H", "O", "D", "W", "E", "M", "B",
+          "U", "Y", "V", "R", "G", "T", "C", "X", "?", "Z"
+        },
+        special_keys = {
+          repeat_search = '<enter>',
+          next_phase_one_target = '<enter>',
+          next_target = {'<enter>', ';'},
+          prev_target = {'<tab>', ','},
+          next_group = '<space>',
+          prev_group = '<tab>',
+          multi_accept = '<enter>',
+          multi_revert = '<backspace>',
+        },
+      }
+    '';
   };
 }

modules/plugins/utility/motion/leap/leap.nix

@@ -9,22 +9,22 @@ in {
       leapForwardTo = mkOption {
         type = nullOr str;
         description = "Leap forward to";
-        default = "<leader>ss";
+        default = "s";
       };
       leapBackwardTo = mkOption {
         type = nullOr str;
         description = "Leap backward to";
-        default = "<leader>sS";
+        default = "S";
       };
       leapForwardTill = mkOption {
         type = nullOr str;
         description = "Leap forward till";
-        default = "<leader>sx";
+        default = "x";
       };
       leapBackwardTill = mkOption {
         type = nullOr str;
         description = "Leap backward till";
-        default = "<leader>sX";
+        default = "X";
       };
       leapFromWindow = mkOption {
         type = nullOr str;

modules/plugins/utility/motion/precognition/config.nix

@@ -1,18 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-
-  cfg = config.vim.utility.motion.precognition;
-in {
-  config = mkIf cfg.enable {
-    vim = {
-      startPlugins = ["precognition-nvim"];
-      luaConfigRC.precognition = lib.nvim.dag.entryAnywhere ''
-        require('precognition').setup(${lib.nvim.lua.toLuaObject cfg.setupOpts})
-      '';
-    };
-  };
-}

modules/plugins/utility/motion/precognition/default.nix

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

modules/plugins/utility/motion/precognition/precognition.nix

@@ -1,66 +0,0 @@
-{lib, ...}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.types) attrsOf listOf str bool int submodule;
-  inherit (lib.nvim.types) mkPluginSetupOption;
-
-  mkHintType = description:
-    mkOption {
-      inherit description;
-      default = {};
-      type = attrsOf (submodule {
-        options = {
-          text = mkOption {
-            type = str;
-            description = "The easier-to-read depiction of the motion";
-          };
-
-          prio = mkOption {
-            type = int;
-            default = 1;
-            description = "The priority of the hint";
-            example = 10;
-          };
-        };
-      });
-    };
-in {
-  options.vim.utility.motion.precognition = {
-    enable = mkEnableOption "assisted motion discovery[precognition.nvim]";
-    setupOpts = mkPluginSetupOption "precognition.nvim" {
-      startVisible = mkOption {
-        type = bool;
-        default = true;
-        description = "Whether to start 'precognition' automatically";
-      };
-
-      showBlankVirtLine = mkOption {
-        type = bool;
-        default = true;
-        description = "Whether to show a blank virtual line when no movements are shown";
-      };
-
-      highlightColor = mkOption {
-        type = attrsOf str;
-        default = {link = "Comment";};
-        example = literalExpression ''
-          { link = "Comment"; }
-          # or
-          { foreground = "#0000FF"; background = "#000000"; };
-        '';
-        description = "The highlight for the virtual text";
-      };
-
-      disabled_fts = mkOption {
-        type = listOf str;
-        default = ["startify"];
-        example = literalExpression ''["startify"]'';
-        description = "Filetypes that automatically disable 'precognition'";
-      };
-
-      hints = mkHintType "What motions display, and at what priority";
-      gutterHints = mkHintType ''
-        What motions display and at what priority. Only appears in gutters
-      '';
-    };
-  };
-}

modules/plugins/utility/preview/markdown-preview/config.nix

@@ -4,8 +4,9 @@
   lib,
   ...
 }: let
-  inherit (lib.strings) concatMapStringsSep;
+  inherit (lib.strings) stringLength concatMapStringsSep;
   inherit (lib.modules) mkIf;
+
   cfg = config.vim.utility.preview.markdownPreview;
 in {
   config = mkIf cfg.enable {
@@ -18,8 +19,8 @@ in {
       mkdp_filetypes = [(concatMapStringsSep ", " (x: "'" + x + "'") cfg.filetypes)];
       mkdp_command_for_global = cfg.alwaysAllowPreview;
       mkdp_open_to_the_world = cfg.broadcastServer;
-      mkdp_open_ip = cfg.customIP;
+      mkdp_open_ip = mkIf (stringLength cfg.customIP > 0) cfg.customIP;
-      mkdp_port = cfg.customPort;
+      mkdp_port = mkIf (stringLength cfg.customPort > 0) cfg.customPort;
     };
   };
 }

modules/plugins/utility/surround/config.nix

@@ -8,47 +8,24 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.utility.surround;
-  mkLznKey = mode: key: {
-    inherit key mode;
-  };
 in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["nvim-surround"];
       pluginRC.surround = entryAnywhere "require('nvim-surround').setup(${toLuaObject cfg.setupOpts})";
 
-      lazy.plugins.nvim-surround = {
+      utility.surround.setupOpts.keymaps = mkIf cfg.useVendoredKeybindings {
-        package = "nvim-surround";
+        insert = "<C-g>z";
-        setupModule = "nvim-surround";
+        insert_line = "<C-g>Z";
-        inherit (cfg) setupOpts;
+        normal = "gz";
-
+        normal_cur = "gZ";
-        keys =
+        normal_line = "gzz";
-          [
+        normal_cur_line = "gZZ";
-            (mkLznKey ["i"] cfg.setupOpts.keymaps.insert)
+        visual = "gz";
-            (mkLznKey ["i"] cfg.setupOpts.keymaps.insert_line)
+        visual_line = "gZ";
-            (mkLznKey ["x"] cfg.setupOpts.keymaps.visual)
+        delete = "gzd";
-            (mkLznKey ["x"] cfg.setupOpts.keymaps.visual_line)
+        change = "gzr";
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal)
+        change_line = "gZR";
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_cur)
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_line)
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.normal_cur_line)
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.delete)
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.change)
-            (mkLznKey ["n"] cfg.setupOpts.keymaps.change_line)
-          ]
-          ++ map (mkLznKey ["n" "i" "v"]) [
-            "<Plug>(nvim-surround-insert)"
-            "<Plug>(nvim-surround-insert-line)"
-            "<Plug>(nvim-surround-normal)"
-            "<Plug>(nvim-surround-normal-cur)"
-            "<Plug>(nvim-surround-normal-line)"
-            "<Plug>(nvim-surround-normal-cur-line)"
-            "<Plug>(nvim-surround-visual)"
-            "<Plug>(nvim-surround-visual-line)"
-            "<Plug>(nvim-surround-delete)"
-            "<Plug>(nvim-surround-change)"
-            "<Plug>(nvim-surround-change-line)"
-          ];
       };
     };
   };

modules/plugins/utility/surround/surround.nix

@@ -1,36 +1,7 @@
-{
+{lib, ...}: let
-  lib,
-  config,
-  ...
-}: let
   inherit (lib.options) mkOption;
-  inherit (lib.types) bool str;
+  inherit (lib.types) bool;
   inherit (lib.nvim.types) mkPluginSetupOption;
-
-  cfg = config.vim.utility.surround;
-  vendoredKeybinds = {
-    insert = "<C-g>z";
-    insert_line = "<C-g>Z";
-    normal = "gz";
-    normal_cur = "gZ";
-    normal_line = "gzz";
-    normal_cur_line = "gZZ";
-    visual = "gz";
-    visual_line = "gZ";
-    delete = "gzd";
-    change = "gzr";
-    change_line = "gZR";
-  };
-
-  mkKeymapOption = name: default:
-    mkOption {
-      description = "keymap for ${name}";
-      type = str;
-      default =
-        if cfg.useVendoredKeybindings
-        then vendoredKeybinds.${name}
-        else default;
-    };
 in {
   options.vim.utility.surround = {
     enable = mkOption {
@@ -42,21 +13,7 @@ in {
         with nvim-leap.
       '';
     };
-    setupOpts = mkPluginSetupOption "nvim-surround" {
+    setupOpts = mkPluginSetupOption "nvim-surround" {};
-      keymaps = {
-        insert = mkKeymapOption "insert" "<C-g>s";
-        insert_line = mkKeymapOption "insert_line" "<C-g>S";
-        normal = mkKeymapOption "normal" "ys";
-        normal_cur = mkKeymapOption "normal_cur" "yss";
-        normal_line = mkKeymapOption "normal_line" "yS";
-        normal_cur_line = mkKeymapOption "normal_cur_line" "ySS";
-        visual = mkKeymapOption "visual" "S";
-        visual_line = mkKeymapOption "visual_line" "gS";
-        delete = mkKeymapOption "delete" "ds";
-        change = mkKeymapOption "change" "cs";
-        change_line = mkKeymapOption "change_line" "cS";
-      };
-    };
 
     useVendoredKeybindings = mkOption {
       type = bool;

modules/plugins/utility/telescope/config.nix

@@ -1,72 +1,63 @@
 {
-  options,
   config,
+  pkgs,
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.binds) addDescriptionsToMappings;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetBinding;
-  inherit (lib.strings) optionalString;
+  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.lists) optionals;
+  inherit (lib.nvim.binds) pushDownDefault;
-  inherit (lib.nvim.binds) pushDownDefault mkSetLznBinding;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.telescope;
-  mappingDefinitions = options.vim.telescope.mappings;
+  self = import ./telescope.nix {inherit pkgs lib;};
+  mappingDefinitions = self.options.vim.telescope.mappings;
 
   mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["plenary-nvim"];
+      startPlugins = [
+        "telescope"
+        "plenary-nvim"
+      ];
 
-      lazy.plugins.telescope = {
+      maps.normal = mkMerge [
-        package = "telescope";
+        (mkSetBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
-        setupModule = "telescope";
+        (mkSetBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
-        inherit (cfg) setupOpts;
+        (mkSetBinding mappings.buffers "<cmd> Telescope buffers<CR>")
-        after = ''
+        (mkSetBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
-          local telescope = require("telescope")
+        (mkSetBinding mappings.open "<cmd> Telescope<CR>")
-          ${optionalString config.vim.ui.noice.enable "telescope.load_extension('noice')"}
+        (mkSetBinding mappings.resume "<cmd> Telescope resume<CR>")
-          ${optionalString config.vim.notify.nvim-notify.enable "telescope.load_extension('notify')"}
-          ${optionalString config.vim.projects.project-nvim.enable "telescope.load_extension('projects')"}
-        '';
 
-        cmd = ["Telescope"];
+        (mkSetBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+        (mkSetBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+        (mkSetBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+        (mkSetBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+        (mkSetBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
 
-        keys =
+        (mkIf config.vim.lsp.enable (mkMerge [
-          [
+          (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
-            (mkSetLznBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
+          (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
-            (mkSetLznBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
-            (mkSetLznBinding mappings.buffers "<cmd> Telescope buffers<CR>")
-            (mkSetLznBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
-            (mkSetLznBinding mappings.open "<cmd> Telescope<CR>")
 
-            (mkSetLznBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
+          (mkSetBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
-            (mkSetLznBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
+          (mkSetBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
-            (mkSetLznBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
+          (mkSetBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
-            (mkSetLznBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
+          (mkSetBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
-            (mkSetLznBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")
+          (mkSetBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
-          ]
+        ]))
-          ++ (optionals config.vim.lsp.enable [
-            (mkSetLznBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
-            (mkSetLznBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")
 
-            (mkSetLznBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
+        (
-            (mkSetLznBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
+          mkIf config.vim.treesitter.enable
-            (mkSetLznBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
+          (mkSetBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
-            (mkSetLznBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
+        )
-            (mkSetLznBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
+
-          ])
+        (
-          ++ (
+          mkIf config.vim.projects.project-nvim.enable
-            optionals config.vim.treesitter.enable [
+          (mkSetBinding mappings.findProjects "<cmd> Telescope projects<CR>")
-              (mkSetLznBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
+        )
-            ]
+      ];
-          )
-          ++ (
-            optionals config.vim.projects.project-nvim.enable [
-              (mkSetLznBinding mappings.findProjects "<cmd Telescope projects<CR>")
-            ]
-          );
-      };
 
       binds.whichKey.register = pushDownDefault {
         "<leader>f" = "+Telescope";
@@ -75,6 +66,29 @@ in {
         "<leader>fv" = "Telescope Git";
         "<leader>fvc" = "Commits";
       };
+
+      pluginRC.telescope = entryAnywhere ''
+        local telescope = require('telescope')
+        telescope.setup(${toLuaObject cfg.setupOpts})
+
+        ${
+          if config.vim.ui.noice.enable
+          then "telescope.load_extension('noice')"
+          else ""
+        }
+
+        ${
+          if config.vim.notify.nvim-notify.enable
+          then "telescope.load_extension('notify')"
+          else ""
+        }
+
+        ${
+          if config.vim.projects.project-nvim.enable
+          then "telescope.load_extension('projects')"
+          else ""
+        }
+      '';
     };
   };
 }