Merge branch 'main' into telescope-ext

.github/README.md

@@ -200,8 +200,9 @@ fix.
 **Q**: What platforms are supported?
 
 **A**: nvf actively supports **Linux and Darwin** platforms using standalone
-Nix, NixOS or Home-Manager. Please take a look at the [nvf manual] for available
+Nix, NixOS or Home-Manager. It has been reported that **Android** is also
-installation instructions.
+supported through the Home-Manager module, or using standalone package. Please
+take a look at the [nvf manual] for available installation instructions.
 
 **Q**: Can you add _X_?
 

.github/workflows/check.yml

@@ -37,7 +37,7 @@ jobs:
         uses: DeterminateSystems/nix-installer-action@main
 
       - name: Check formatting via Alejandra
-        run: nix run nixpkgs#alejandra -- -c .
+        run: nix run nixpkgs#alejandra -- --check . --exclude npins
 
   check-typos:
     name: "Check source tree for typos"
@@ -114,33 +114,35 @@ jobs:
     runs-on: ubuntu-latest
     if: "!contains(github.event.pull_request.title, '[skip ci]')"
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2 # slows down checkout, but we need to compare against the previous commit on push events
+
       - name: Get list of changed files from PR
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
         run: |
-          gh api \
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
-            repos/${{ github.repository }}/pulls/${{github.event.number}}/files --paginate \
+            gh api repos/${{ github.repository }}/pulls/${{ github.event.number }}/files --paginate \
-            | jq '.[] | select(.status != "removed") | .filename' \
+              | jq -r '.[] | select(.status != "removed") | .filename' \
-            > "$HOME/changed_files"
+              > "$HOME/changed_files"
+          else
+            git diff --name-only HEAD^ > "$HOME/changed_files"
+          fi
 
       - name: Print list of changed files
         run: |
           cat "$HOME/changed_files"
 
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: refs/pull/${{ github.event.pull_request.number }}/merge
-
       - name: Install Nix
         uses: DeterminateSystems/nix-installer-action@main
 
-      - name: Checking EditorConfig
+      - name: Checking Editorconfig conformance
         shell: bash
         run: |
-          cat "$HOME/changed_files" | nix-shell -p editorconfig-checker.out \
+          < "$HOME/changed_files" nix-shell -p editorconfig-checker --run 'xargs -r editorconfig-checker -disable-indent-size'
-            --run 'xargs -r editorconfig-checker -disable-indentation -exclude flake.lock --verbose'
-          echo -n "Check status: $?"
 
       - if: ${{ failure() }}
         shell: bash

configuration.nix

@@ -25,7 +25,6 @@ isMaximal: {
       trouble.enable = true;
       lspSignature.enable = true;
       otter-nvim.enable = isMaximal;
-      lsplines.enable = isMaximal;
       nvim-docs-view.enable = isMaximal;
     };
 
@@ -82,6 +81,7 @@ isMaximal: {
       elixir.enable = false;
       haskell.enable = false;
       ruby.enable = false;
+      fsharp.enable = false;
 
       tailwind.enable = false;
       svelte.enable = false;

docs/manual/configuring/custom-plugins.md

@@ -15,7 +15,7 @@ plugin to the runtime, you need to add it to the [](#opt-vim.startPlugins) list
 in your configuration.
 
 Adding a plugin to `startPlugins` will not allow you to configure the plugin
-that you have added, but **nvf** provides multiple way of configuring any custom
+that you have added, but **nvf** provides multiple ways of configuring any custom
 plugins that you might have added to your configuration.
 
 ```{=include=} sections

docs/manual/configuring/languages.md

@@ -19,6 +19,7 @@ formatting to diagnostics. The following languages have sections under the
 - Go: [vim.languages.go.enable](#opt-vim.languages.go.enable)
 - Lua: [vim.languages.lua.enable](#opt-vim.languages.lua.enable)
 - PHP: [vim.languages.php.enable](#opt-vim.languages.php.enable)
+- F#: [vim.languages.fsharp.enable](#opt-vim.languages.fsharp.enable)
 
 Adding support for more languages, and improving support for existing ones are
 great places where you can contribute with a PR.

docs/manual/default-configs/maximal.md

@@ -1,7 +1,7 @@
 # Maximal {#sec-default-maximal}
 
 ```bash
-$ nix shell github:notashelf/nvf#maximal test.nix
+$ nix run github:notashelf/nvf#maximal -- test.nix
 ```
 
 It is the same fully configured Neovim as with the [Nix](#sec-default-nix)

docs/release-notes/rl-0.8.md

@@ -14,6 +14,11 @@
   the new API they provide. Please manually set your keybinds according to
   [Lspsaga documentation] following the new API.
 
+- none-ls has been updated to the latest version. If you have been using raw Lua
+  configuration to _manually_ configure it, some of the formats may become
+  unavailable as they have been refactored out of the main none-ls repository
+  upstream.
+
 [NotAShelf](https://github.com/notashelf):
 
 [typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
@@ -21,6 +26,7 @@
 [yanky.nvim]: https://github.com/gbprod/yanky.nvim
 [yazi.nvim]: https://github.com/mikavilpas/yazi.nvim
 [snacks.nvim]: https://github.com/folke/snacks.nvim
+[oil.nvim]: https://github.com/stevearc/oil.nvim
 
 - Add [typst-preview.nvim] under
   `languages.typst.extensions.typst-preview-nvim`.
@@ -78,6 +84,13 @@
 
 - Lazyload Lspsaga and remove default keybindings for it.
 
+- Add [oil.nvim] as an alternative file explorer. It will be available under
+  `vim.utility.oil-nvim`.
+
+- Add `vim.diagnostics` to interact with Neovim's diagnostics module. Available
+  options for `vim.diagnostic.config()` can now be customized through the
+  [](#opt-vim.diagnostics.config) in nvf.
+
 [amadaluzia](https://github.com/amadaluzia):
 
 [haskell-tools.nvim]: https://github.com/MrcJkb/haskell-tools.nvim
@@ -88,8 +101,14 @@
 
 [blink.cmp]: https://github.com/saghen/blink.cmp
 
+- Add [aerial.nvim].
+- Add [nvim-ufo].
 - Add [blink.cmp] support.
 - Add `LazyFile` user event.
+- Migrate language modules from none-ls to conform/nvim-lint
+- Add tsx support in conform and lint
+- Moved code setting `additionalRuntimePaths` and `enableLuaLoader` out of
+  `luaConfigPre`'s default to prevent being overridden
 
 [diniamo](https://github.com/diniamo):
 
@@ -98,14 +117,6 @@
 - Disable the built-in format-on-save feature of zls. Use `vim.lsp.formatOnSave`
   instead.
 
-[horriblename](https://github.com/horriblename):
-
-[aerial.nvim]: (https://github.com/stevearc/aerial.nvim)
-[nvim-ufo]: (https://github.com/kevinhwang91/nvim-ufo)
-
-- Add [aerial.nvim].
-- Add [nvim-ufo].
-
 [LilleAila](https://github.com/LilleAila):
 
 - Remove `vim.notes.obsidian.setupOpts.dir`, which was set by default. Fixes
@@ -190,6 +201,7 @@
   Inspiration from `vim.languages.clang.dap` implementation.
 - Add [leetcode.nvim] plugin under `vim.utility.leetcode-nvim`.
 - Add [codecompanion.nvim] plugin under `vim.assistant.codecompanion-nvim`.
+- Fix [codecompanion-nvim] plugin: nvim-cmp error and setupOpts defaults.
 
 [nezia1](https://github.com/nezia1):
 
@@ -235,8 +247,9 @@
 
 [alfarel](https://github.com/alfarelcynthesis):
 
-- Add missing `yazi.nvim` dependency (`snacks.nvim`).
+[conform.nvim]: https://github.com/stevearc/conform.nvim
 
+- Add missing `yazi.nvim` dependency (`snacks.nvim`).
 - Add [mkdir.nvim](https://github.com/jghauser/mkdir.nvim) plugin for automatic
   creation of parent directories when editing a nested file.
 - Add [nix-develop.nvim](https://github.com/figsoda/nix-develop.nvim) plugin for
@@ -248,6 +261,8 @@
   [friendly-snippets](https://github.com/rafamadriz/friendly-snippets) so
   blink.cmp can source snippets from it.
 - Fix [blink.cmp] breaking when built-in sources were modified.
+- Fix [conform.nvim] not allowing disabling formatting on and after save. Use
+  `null` value to disable them if conform is enabled.
 
 [TheColorman](https://github.com/TheColorman):
 
@@ -276,3 +291,64 @@
 [rice-cracker-dev](https://github.com/rice-cracker-dev):
 
 - `eslint_d` now checks for configuration files to load.
+- Fix an error where `eslint_d` fails to load.
+- Add required files support for linters under
+  `vim.diagnostics.nvim-lint.linters.*.required_files`.
+- Add global function `nvf_lint` under
+  `vim.diagnostics.nvim-lint.lint_function`.
+
+[Sc3l3t0n](https://github.com/Sc3l3t0n):
+
+- Add F# support under `vim.languages.fsharp`.
+
+[venkyr77](https://github.com/venkyr77):
+
+- Add lint (luacheck) and formatting (stylua) support for Lua.
+- Add lint (markdownlint-cli2) support for Markdown.
+- Add catppuccin integration for Bufferline, Lspsaga.
+- Add `neo-tree`, `snacks.explorer` integrations to `bufferline`.
+- Add more applicable filetypes to illuminate denylist.
+- Disable mini.indentscope for applicable filetypes.
+- Fix fzf-lua having a hard dependency on fzf.
+- Enable inlay hints support - `config.vim.lsp.inlayHints`.
+- Add `neo-tree`, `snacks.picker` extensions to `lualine`.
+
+[tebuevd](https://github.com/tebuevd):
+
+- Fix `pickers` configuration for `telescope` by nesting it under `setupOpts`
+- Fix `find_command` configuration for `telescope` by nesting it under
+  `setupOpts.pickers.find_files`
+- Update default `telescope.setupOpts.pickers.find_files.find_command` to only
+  include files (and therefore exclude directories from results)
+
+[ckoehler](https://github.com/ckoehler):
+
+[flash.nvim]: https://github.com/folke/flash.nvim
+[gitlinker.nvim]: https://github.com/linrongbin16/gitlinker.nvim
+
+- Fix oil config referencing snacks
+- Add [flash.nvim] plugin to `vim.utility.motion.flash-nvim`
+- Fix default telescope ignore list entry for '.git/' to properly match
+- Add [gitlinker.nvim] plugin to `vim.git.gitlinker-nvim`
+
+[rrvsh](https://github.com/rrvsh):
+
+- Fix namespace of python-lsp-server by changing it to python3Packages
+
+[Noah765](https://github.com/Noah765):
+
+[vim-sleuth]: https://github.com/tpope/vim-sleuth
+
+- Add missing `flutter-tools.nvim` dependency `plenary.nvim`.
+- Add necessary dependency of `flutter-tools.nvim` on lsp.
+- Add the `vim.languages.dart.flutter-tools.flutterPackage` option.
+- Fix the type of the `highlight` color options.
+- Add [vim-sleuth] plugin under `vim.utility.sleuth`.
+
+[howird](https://github.com/howird):
+
+- Change python dap adapter name from `python` to commonly expected `debugpy`.
+
+[aionoid](https://github.com/aionoid):
+
+- Fix [render-markdown.nvim] file_types option type to list, to accept merging.

flake.lock

@@ -5,11 +5,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1741352980,
+        "lastModified": 1743550720,
-        "narHash": "sha256-+u2UunDA4Cl5Fci3m7S643HzKmIDAe+fiXrLqYsR2fs=",
+        "narHash": "sha256-hIshGgKZCgWh6AYJpJmRgFdR3WUbkY04o82X05xqQiY=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "f4330d22f1c5d2ba72d3d22df5597d123fdb60a9",
+        "rev": "c621e8422220273271f52058f618c94e405bb0f5",
         "type": "github"
       },
       "original": {
@@ -38,11 +38,11 @@
     },
     "mnw": {
       "locked": {
-        "lastModified": 1742255973,
+        "lastModified": 1745705214,
-        "narHash": "sha256-XfEGVKatTgEMMOVb4SNp1LYLQOSzzrFTDMVDTZFyMVE=",
+        "narHash": "sha256-XGfaHbFI4vvDuaoVO3IFYZKezXIO8rhUaMCGcjY71Ac=",
         "owner": "Gerg-L",
         "repo": "mnw",
-        "rev": "b982dbd5e6d55d4438832b3567c09bc2a129649d",
+        "rev": "c1f4587db4c53dcefa432c46c7a899a116d8e924",
         "type": "github"
       },
       "original": {
@@ -77,11 +77,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1741865919,
+        "lastModified": 1745377448,
-        "narHash": "sha256-4thdbnP6dlbdq+qZWTsm4ffAwoS8Tiq1YResB+RP6WE=",
+        "narHash": "sha256-jhZDfXVKdD7TSEGgzFJQvEEZ2K65UMiqW5YJ2aIqxMA=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "573c650e8a14b2faa0041645ab18aed7e60f0c9a",
+        "rev": "507b63021ada5fee621b6ca371c4fca9ca46f52c",
         "type": "github"
       },
       "original": {
@@ -93,11 +93,11 @@
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1740877520,
+        "lastModified": 1743296961,
-        "narHash": "sha256-oiwv/ZK/2FhGxrCkQkB83i7GnWXPPLzoqFHpDD3uYpk=",
+        "narHash": "sha256-b1EdN3cULCqtorQ4QeWgLMrd5ZGOjLSLemfa00heasc=",
         "owner": "nix-community",
         "repo": "nixpkgs.lib",
-        "rev": "147dee35aab2193b174e4c0868bd80ead5ce755c",
+        "rev": "e4822aea2a6d1cdd36653c134cacfd64c97ff4fa",
         "type": "github"
       },
       "original": {

flake/legacyPackages/blink-cmp.nix

@@ -1,9 +1,8 @@
 {
   stdenv,
   rustPlatform,
-  hostPlatform,
   vimUtils,
-  git,
+  gitMinimal,
   src,
   version,
 }: let
@@ -15,9 +14,9 @@
     env.RUSTC_BOOTSTRAP = true;
 
     useFetchCargoVendor = true;
-    cargoHash = "sha256-F1wh/TjYoiIbDY3J/prVF367MKk3vwM7LqOpRobOs7I=";
+    cargoHash = "sha256-MWElqh7ENJ6CbLOnvz0DsP5YYu+e+y12GSUOfW1IKGU=";
 
-    nativeBuildInputs = [git];
+    nativeBuildInputs = [gitMinimal];
   };
 in
   vimUtils.buildVimPlugin {
@@ -34,5 +33,5 @@ in
     '';
 
     # Module for reproducing issues
-    nvimSkipModule = ["repro"];
+    nvimSkipModules = ["repro"];
   }

modules/extra/deprecations.nix

@@ -104,6 +104,13 @@ in {
         their behaviour was abstract, and confusing. Please use 'vim.options' or 'vim.luaConfigRC'
         to replicate previous behaviour.
       '')
+
+      # 2025-04-04
+      (mkRemovedOptionModule ["vim" "lsp" "lsplines"] ''
+        lsplines module has been removed from nvf, as its functionality is now built into Neovim
+        under the diagnostics module. Please consider using one of 'vim.diagnostics.config' or
+        'vim.luaConfigRC' to configure LSP lines for Neovim through its own diagnostics API.
+      '')
     ]
 
     # Migrated via batchRenameOptions. Further batch renames must be below this line.

modules/neovim/init/autocmds.nix

@@ -17,7 +17,7 @@
         mkEnableOption ""
         // {
           default = true;
-          description = "Whether to enable this autocommand";
+          description = "Whether to enable this autocommand.";
         };
 
       event = mkOption {
@@ -31,7 +31,7 @@
         type = nullOr (listOf str);
         default = null;
         example = ["*.lua" "*.vim"];
-        description = "The file pattern(s) that determine when the autocommand applies).";
+        description = "The file pattern(s) that determine when the autocommand applies.";
       };
 
       callback = mkOption {
@@ -44,13 +44,16 @@
             end
           ''''
         '';
-        description = "The file pattern(s) that determine when the autocommand applies.";
+        description = "Lua function to be called when the event(s) are triggered.";
       };
 
       command = mkOption {
         type = nullOr str;
         default = null;
-        description = "Vim command string instead of a Lua function.";
+        description = ''
+          Vim command to be executed when the event(s) are triggered.
+          Cannot be defined if the `callback` option is already defined.
+        '';
       };
 
       group = mkOption {
@@ -70,7 +73,7 @@
       once = mkOption {
         type = bool;
         default = false;
-        description = "Whether autocommand run only once.";
+        description = "Whether to run the autocommand only once.";
       };
 
       nested = mkOption {
@@ -87,7 +90,7 @@
         mkEnableOption ""
         // {
           default = true;
-          description = "Whether to enable this autogroup";
+          description = "Whether to enable this autocommand group.";
         };
 
       name = mkOption {
@@ -118,8 +121,8 @@ in {
         autocommands together. Groups allow multiple autocommands to be cleared
         or redefined collectively, preventing duplicate definitions.
 
-        Each autogroup consists of a name, a boolean indicating whether to clear
+        Each autogroup consists of a name and a boolean indicating whether to clear
-        existing autocommands, and a list of associated autocommands.
+        existing autocommands.
       '';
     };
 
@@ -129,8 +132,8 @@ in {
       description = ''
         A list of Neovim autocommands to be registered.
 
-        Each entry defines an autocommand, specifying events, patterns, optional
+        Each entry defines an autocommand, specifying events, patterns, a callback or Vim
-        callbacks, commands, groups, and execution settings.
+        command, an optional group, a description, and execution settings.
       '';
     };
   };

modules/neovim/init/default.nix

@@ -3,6 +3,7 @@
     ./autocmds.nix
     ./basic.nix
     ./debug.nix
+    ./diagnostics.nix
     ./highlight.nix
     ./spellcheck.nix
   ];

modules/neovim/init/diagnostics.nix

@@ -0,0 +1,109 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
+  inherit (lib.types) attrsOf anything oneOf bool submodule;
+  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.types) luaInline;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.diagnostics;
+
+  # Takes a boolean, a table, or a Lua list ({key = value}). We
+  # would like to allow all of those types, while clearly expressing
+  # them in the option's type. As such, this type is what it is.
+  diagnosticType = oneOf [(attrsOf anything) bool luaInline];
+  diagnosticsSubmodule = submodule {
+    # The table might need to be extended, so let's allow that case
+    # with a freeform type of what is supported by diagnostics opts.
+    freeformType = attrsOf diagnosticType;
+    options = {
+      underline = mkOption {
+        type = diagnosticType;
+        default = true;
+        description = "Use underline for diagnostics.";
+      };
+
+      virtual_text = mkOption {
+        type = diagnosticType;
+        default = false;
+        example = literalExpression ''
+          {
+            format = lib.generators.mkLuaInline '''
+              function(diagnostic)
+                return string.format("%s (%s)", diagnostic.message, diagnostic.source)
+              end
+            ''';
+          }
+        '';
+
+        description = ''
+          Use virtual text for diagnostics. If multiple diagnostics are set for a namespace,
+          one prefix per diagnostic + the last diagnostic message are shown.
+        '';
+      };
+
+      virtual_lines = mkOption {
+        type = diagnosticType;
+        default = false;
+        description = ''
+          Use virtual lines for diagnostics.
+        '';
+      };
+
+      signs = mkOption {
+        type = diagnosticType;
+        default = false;
+        example = {
+          signs.text = {
+            "vim.diagnostic.severity.ERROR" = "󰅚 ";
+            "vim.diagnostic.severity.WARN" = "󰀪 ";
+          };
+        };
+        description = ''
+          Use signs for diagnostics. See {command}`:help diagnostic-signs`.
+        '';
+      };
+
+      update_in_insert = mkOption {
+        type = bool;
+        default = false;
+        description = ''
+          Update diagnostics in Insert mode. If `false`, diagnostics will
+          be updated on InsertLeave ({command}`:help InsertLeave`).
+        '';
+      };
+    };
+  };
+in {
+  options.vim = {
+    diagnostics = {
+      enable = mkEnableOption "diagostics module for Neovim";
+      config = mkOption {
+        type = diagnosticsSubmodule;
+        default = {};
+        description = ''
+          Values that will be passed to `vim.diagnostic.config` after being converted
+          to a Lua table. Possible values for each key can be found in the help text
+          for `vim.diagnostics.Opts`. You may find more about the diagnostics API of
+          Neovim in {command}`:help diagnostic-api`.
+
+          :::{.note}
+          This option is freeform. You may set values that are not present in nvf
+          documentation, but those values will not be fully type checked. Please
+          refer to the help text for `vim.diagnostic.Opts` for appropriate values.
+          :::
+        '';
+      };
+    };
+  };
+
+  config.vim = mkIf cfg.enable {
+    luaConfigRC.diagnostics = entryAfter ["basic"] ''
+      vim.diagnostic.config(${toLuaObject cfg.config})
+    '';
+  };
+}

modules/neovim/init/highlight.nix

@@ -5,15 +5,14 @@
 }: let
   inherit (lib.options) mkOption;
   inherit (lib.types) nullOr attrsOf listOf submodule bool ints str enum;
-  inherit (lib.strings) hasPrefix concatLines;
+  inherit (lib.strings) concatLines;
   inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.nvim.dag) entryBetween;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) hexColor;
 
   mkColorOption = target:
     mkOption {
-      type = nullOr hexColor;
+      type = nullOr str;
       default = null;
       example = "#ebdbb2";
       description = ''

modules/plugins/assistant/chatgpt/config.nix

@@ -30,7 +30,16 @@
 in {
   config = mkIf cfg.enable {
     vim = {
-      startPlugins = ["chatgpt-nvim"];
+      startPlugins = [
+        "chatgpt-nvim"
+
+        # Dependencies
+        "nui-nvim"
+        "plenary-nvim"
+      ];
+
+      # ChatGPT.nvim explicitly depends on Telescope.
+      telescope.enable = true;
 
       pluginRC.chagpt = entryAnywhere ''
         require("chatgpt").setup(${toLuaObject cfg.setupOpts})

modules/plugins/assistant/codecompanion/codecompanion-nvim.nix

@@ -9,7 +9,14 @@ in {
 
       setupOpts = mkPluginSetupOption "codecompanion-nvim" {
         opts = {
-          send_code = mkEnableOption "code from being sent to the LLM.";
+          send_code =
+            mkEnableOption ""
+            // {
+              default = true;
+              description = ''
+                Whether to enable code being sent to the LLM.
+              '';
+            };
 
           log_level = mkOption {
             type = enum ["DEBUG" "INFO" "ERROR" "TRACE"];
@@ -30,7 +37,10 @@ in {
               mkEnableOption ""
               // {
                 default = true;
-                description = "a diff view to see the changes made by the LLM.";
+                description = ''
+                  Whether to enable a diff view
+                  to see the changes made by the LLM.
+                '';
               };
 
             close_chat_at = mkOption {
@@ -64,7 +74,12 @@ in {
           };
 
           chat = {
-            auto_scroll = mkEnableOption "automatic page scrolling.";
+            auto_scroll =
+              mkEnableOption ""
+              // {
+                default = true;
+                description = "Whether to enable automatic page scrolling.";
+              };
 
             show_settings = mkEnableOption ''
               LLM settings to appear at the top of the chat buffer.
@@ -85,14 +100,18 @@ in {
               mkEnableOption ""
               // {
                 default = true;
-                description = "references in the chat buffer.";
+                description = ''
+                  Whether to enable references in the chat buffer.
+                '';
               };
 
             show_token_count =
               mkEnableOption ""
               // {
                 default = true;
-                description = "the token count for each response.";
+                description = ''
+                  Whether to enable the token count for each response.
+                '';
               };
 
             intro_message = mkOption {
@@ -155,7 +174,10 @@ in {
                 mkEnableOption ""
                 // {
                   default = true;
-                  description = "showing default actions in the action palette.";
+                  description = ''
+                    Whether to enable showing default
+                    actions in the action palette.
+                  '';
                 };
 
               show_default_prompt_library =
@@ -163,7 +185,8 @@ in {
                 // {
                   default = true;
                   description = ''
-                    showing default prompt library in the action palette.
+                    Whether to enable showing default
+                    prompt library in the action palette.
                   '';
                 };
             };

modules/plugins/assistant/codecompanion/config.nix

@@ -22,6 +22,11 @@ in {
       };
 
       treesitter.enable = true;
+
+      autocomplete.nvim-cmp = {
+        sources = {codecompanion-nvim = "[codecompanion]";};
+        sourcePlugins = ["codecompanion-nvim"];
+      };
     };
   };
 }

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

@@ -43,19 +43,6 @@ in {
           default = {};
           description = "Settings for completion providers.";
         };
-
-        transform_items = mkOption {
-          type = nullOr luaInline;
-          default = mkLuaInline "function(_, items) return items end";
-          defaultText = ''
-            Our default does nothing. If you want blink.cmp's default, which
-            lowers the score for snippets, set this option to null.
-          '';
-          description = ''
-            Function to use when transforming the items before they're returned
-            for all providers.
-          '';
-        };
       };
 
       cmdline = {

modules/plugins/diagnostics/nvim-lint/config.nix

@@ -3,18 +3,50 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.diagnostics.nvim-lint;
 in {
-  config = mkIf cfg.enable {
+  config = mkMerge [
-    vim = {
+    (mkIf cfg.enable {
-      startPlugins = ["nvim-lint"];
+      vim = {
-      pluginRC.nvim-lint = entryAnywhere ''
+        startPlugins = ["nvim-lint"];
-        require("lint").linters_by_ft = ${toLuaObject cfg.linters_by_ft}
+        pluginRC.nvim-lint = entryAnywhere ''
-      '';
+          require("lint").linters_by_ft = ${toLuaObject cfg.linters_by_ft}
-    };
+
-  };
+          local linters = require("lint").linters
+          local nvf_linters = ${toLuaObject cfg.linters}
+          for linter, config in pairs(nvf_linters) do
+            if linters[linter] == nil then
+              linters[linter] = config
+            else
+              for key, val in pairs(config) do
+                linters[linter][key] = val
+              end
+            end
+          end
+
+          nvf_lint = ${toLuaObject cfg.lint_function}
+        '';
+      };
+    })
+    (mkIf (cfg.enable && cfg.lint_after_save) {
+      vim = {
+        augroups = [{name = "nvf_nvim_lint";}];
+        autocmds = [
+          {
+            event = ["BufWritePost"];
+            callback = mkLuaInline ''
+              function(args)
+                nvf_lint(args.buf)
+              end
+            '';
+          }
+        ];
+      };
+    })
+  ];
 }

modules/plugins/diagnostics/nvim-lint/nvim-lint.nix

@@ -1,6 +1,94 @@
 {lib, ...}: let
-  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.types) attrsOf listOf str;
+  inherit (lib.types) nullOr attrsOf listOf str either submodule bool enum;
+  inherit (lib.nvim.types) luaInline;
+  inherit (lib.generators) mkLuaInline;
+
+  linterType = submodule {
+    options = {
+      name = mkOption {
+        type = nullOr str;
+        default = null;
+        description = "Name of the linter";
+      };
+
+      cmd = mkOption {
+        type = nullOr str;
+        default = null;
+        description = "Command of the linter";
+      };
+
+      args = mkOption {
+        type = nullOr (listOf (either str luaInline));
+        default = null;
+        description = "Arguments to pass";
+      };
+
+      stdin = mkOption {
+        type = nullOr bool;
+        default = null;
+        description = "Send content via stdin.";
+      };
+
+      append_fname = mkOption {
+        type = nullOr bool;
+        default = null;
+        description = ''
+          Automatically add the current file name to the commands arguments. Only
+          has an effect if stdin is false
+        '';
+      };
+
+      stream = mkOption {
+        type = nullOr (enum ["stdout" "stderr" "both"]);
+        default = null;
+        description = "Result stream";
+      };
+
+      ignore_exitcode = mkOption {
+        type = nullOr bool;
+        default = null;
+        description = ''
+          Declares if exit code != 1 should be ignored or result in a warning.
+        '';
+      };
+
+      env = mkOption {
+        type = nullOr (attrsOf str);
+        default = null;
+        description = "Environment variables to use";
+      };
+
+      cwd = mkOption {
+        type = nullOr str;
+        default = null;
+        description = "Working directory of the linter";
+      };
+
+      parser = mkOption {
+        type = nullOr luaInline;
+        default = null;
+        description = "Parser function";
+      };
+
+      required_files = mkOption {
+        type = nullOr (listOf str);
+        default = null;
+        example = ["eslint.config.js"];
+        description = ''
+          Required files to lint. These files must exist relative to the cwd
+          of the linter or else this linter will be skipped
+
+          ::: {.note}
+          This option is an nvf extension that only takes effect if you
+          use the `nvf_lint()` lua function.
+
+          See {option}`vim.diagnostics.nvim-lint.lint_function`.
+          :::
+        '';
+      };
+    };
+  };
 in {
   options.vim.diagnostics.nvim-lint = {
     enable = mkEnableOption "asynchronous linter plugin for Neovim [nvim-lint]";
@@ -21,5 +109,79 @@ in {
         accept.
       '';
     };
+
+    linters = mkOption {
+      type = attrsOf linterType;
+      default = {};
+      example = ''
+        {
+          phpcs = {
+            args = ["-q" "--report-json" "-"];
+
+            # this will replace the builtin's env table if it exists
+            env = {
+              ENV_VAR = "something";
+            };
+          };
+        }
+      '';
+
+      description = ''
+        Linter configurations. Builtin linters will be updated and not
+        replaced, but note that this is not a deep extend operation, i.e. if
+        you define an `env` option, it will replace the entire `env` table
+        provided by the builtin (if it exists).
+      '';
+    };
+
+    lint_after_save = mkEnableOption "autocmd to lint after each save" // {default = true;};
+
+    lint_function = mkOption {
+      type = luaInline;
+      default = mkLuaInline ''
+        function(buf)
+          local ft = vim.api.nvim_get_option_value("filetype", { buf = buf })
+          local linters = require("lint").linters
+          local linters_from_ft = require("lint").linters_by_ft[ft]
+
+          -- if no linter is configured for this filetype, stops linting
+          if linters_from_ft == nil then return end
+
+          for _, name in ipairs(linters_from_ft) do
+            local linter = linters[name]
+            assert(linter, 'Linter with name `' .. name .. '` not available')
+
+            if type(linter) == "function" then
+              linter = linter()
+            end
+            -- for require("lint").lint() to work, linter.name must be set
+            linter.name = linter.name or name
+            local cwd = linter.required_files
+
+            -- if no configuration files are configured, lint
+            if cwd == nil then
+              require("lint").lint(linter)
+            else
+              -- if configuration files are configured and present in the project, lint
+              for _, fn in ipairs(cwd) do
+                local path = vim.fs.joinpath(linter.cwd or vim.fn.getcwd(), fn);
+                if vim.uv.fs_stat(path) then
+                  require("lint").lint(linter)
+                  break
+                end
+              end
+            end
+          end
+        end
+      '';
+      example = literalExpression ''
+        mkLuaInline '''
+          function(buf)
+            require("lint").try_lint()
+          end
+        '''
+      '';
+      description = "Define the global function nvf_lint which is used by nvf to lint.";
+    };
   };
 }

modules/plugins/formatter/conform-nvim/conform-nvim.nix

@@ -4,7 +4,7 @@
   ...
 }: let
   inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.types) attrs enum;
+  inherit (lib.types) attrs enum nullOr;
   inherit (lib.nvim.types) mkPluginSetupOption;
   inherit (lib.nvim.lua) mkLuaInline;
 in {
@@ -31,7 +31,7 @@ in {
       };
 
       format_on_save = mkOption {
-        type = attrs;
+        type = nullOr attrs;
         default = {
           lsp_format = "fallback";
           timeout_ms = 500;
@@ -43,7 +43,7 @@ in {
       };
 
       format_after_save = mkOption {
-        type = attrs;
+        type = nullOr attrs;
         default = {lsp_format = "fallback";};
         description = ''
           Table that will be passed to `conform.format()`. If this

modules/plugins/git/default.nix

@@ -5,6 +5,7 @@ in {
     ./gitsigns
     ./vim-fugitive
     ./git-conflict
+    ./gitlinker-nvim
   ];
 
   options.vim.git = {
@@ -15,6 +16,7 @@ in {
       * gitsigns
       * vim-fugitive
       * git-conflict
+      * gitlinker-nvim
     '';
   };
 }

modules/plugins/git/gitlinker-nvim/config.nix

@@ -0,0 +1,22 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.git.gitlinker-nvim;
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      lazy.plugins = {
+        "gitlinker-nvim" = {
+          package = "gitlinker-nvim";
+          setupModule = "gitlinker";
+          inherit (cfg) setupOpts;
+          cmd = ["GitLink"];
+        };
+      };
+    };
+  };
+}

modules/plugins/git/gitlinker-nvim/default.nix

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

modules/plugins/git/gitlinker-nvim/gitlinker-nvim.nix

@@ -0,0 +1,13 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+in {
+  options.vim.git.gitlinker-nvim = {
+    enable = mkEnableOption "gitlinker-nvim" // {default = config.vim.git.enable;};
+    setupOpts = mkPluginSetupOption "gitlinker-nvim" {};
+  };
+}

modules/plugins/git/gitsigns/config.nix

@@ -5,6 +5,7 @@
 }: let
   inherit (builtins) toJSON;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.binds) addDescriptionsToMappings mkSetExprBinding mkSetLuaBinding pushDownDefault;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
@@ -32,6 +33,7 @@ in {
                 return '<Ignore>'
               end
             '')
+
             (mkSetExprBinding gsMappings.previousHunk ''
               function()
                 if vim.wo.diff then return ${toJSON gsMappings.previousHunk.value} end
@@ -77,13 +79,12 @@ in {
     }
 
     (mkIf cfg.codeActions.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.lsp.null-ls = {
-      vim.lsp.null-ls.sources.gitsigns-ca = ''
+        enable = true;
-        table.insert(
+        setupOpts.sources.gitsigns-ca = mkLuaInline ''
-          ls_sources,
+          require("null-ls").builtins.code_actions.gitsigns
-          null_ls.builtins.code_actions.gitsigns
+        '';
-        )
+      };
-      '';
     })
   ]);
 }

modules/plugins/languages/astro.nix

@@ -10,8 +10,8 @@
   inherit (lib.lists) isList;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum either listOf package str;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.lua) expToLua;
-  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
 
   cfg = config.vim.languages.astro;
@@ -22,7 +22,7 @@
       package = pkgs.astro-language-server;
       lspConfig = ''
         lspconfig.astro.setup {
-          capabilities = capabilities;
+          capabilities = capabilities,
           on_attach = attach_keymaps,
           cmd = ${
           if isList cfg.lsp.package
@@ -39,52 +39,35 @@
   formats = {
     prettier = {
       package = pkgs.nodePackages.prettier;
-      nullConfig = ''
+    };
-        table.insert(
+
-          ls_sources,
+    prettierd = {
-          null_ls.builtins.formatting.prettier.with({
+      package = pkgs.prettierd;
-            command = "${cfg.format.package}/bin/prettier",
-          })
-        )
-      '';
     };
 
     biome = {
       package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
     };
   };
 
   # TODO: specify packages
   defaultDiagnosticsProvider = ["eslint_d"];
   diagnosticsProviders = {
-    eslint_d = {
+    eslint_d = let
-      package = pkgs.eslint_d;
+      pkg = pkgs.eslint_d;
-      nullConfig = pkg: ''
+    in {
-        table.insert(
+      package = pkg;
-          ls_sources,
+      config = {
-          null_ls.builtins.diagnostics.eslint_d.with({
+        cmd = getExe pkg;
-            command = "${getExe pkg}",
+        required_files = [
-            condition = function(utils)
+          "eslint.config.js"
-              return utils.root_has_file({
+          "eslint.config.mjs"
-                "eslint.config.js",
+          ".eslintrc"
-                "eslint.config.mjs",
+          ".eslintrc.json"
-                ".eslintrc",
+          ".eslintrc.js"
-                ".eslintrc.json",
+          ".eslintrc.yml"
-                ".eslintrc.js",
+        ];
-                ".eslintrc.yml",
+      };
-              })
-            end,
-          })
-        )
-      '';
     };
   };
 in {
@@ -101,16 +84,16 @@ in {
       enable = mkEnableOption "Astro LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
-        description = "Astro LSP server to use";
         type = enum (attrNames servers);
         default = defaultServer;
+        description = "Astro LSP server to use";
       };
 
       package = mkOption {
-        description = "Astro LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.astro-language-server "--minify" "--stdio"]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.astro-language-server "--minify" "--stdio"]'';
+        description = "Astro LSP server package, or the command to run as a list of strings";
       };
     };
 
@@ -153,16 +136,22 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.astro-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.astro = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "astro";
+        linters_by_ft.astro = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters =
-        inherit diagnosticsProviders;
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/bash.nix

@@ -6,10 +6,10 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either package listOf str bool;
-  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.nvim.types) diagnostics mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
@@ -37,14 +37,6 @@
   formats = {
     shfmt = {
       package = pkgs.shfmt;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.shfmt.with({
-            command = "${pkgs.shfmt}/bin/shfmt",
-          })
-        )
-      '';
     };
   };
 
@@ -52,15 +44,6 @@
   diagnosticsProviders = {
     shellcheck = {
       package = pkgs.shellcheck;
-      nullConfig = pkg: ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.diagnostics.shellcheck.with({
-            command = "${pkg}/bin/shellcheck",
-            diagnostics_format = "#{m} [#{c}]"
-          })
-        )
-      '';
     };
   };
 in {
@@ -130,16 +113,23 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.bash-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.sh = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "bash";
+        linters_by_ft.sh = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters = mkMerge (map (name: {
-        inherit diagnosticsProviders;
+            ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+          })
+          cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/css.nix

@@ -6,6 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either listOf package str;
@@ -42,14 +43,6 @@
   formats = {
     prettier = {
       package = pkgs.nodePackages.prettier;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.prettier.with({
-            command = "${cfg.format.package}/bin/prettier",
-          })
-        )
-      '';
     };
 
     prettierd = {
@@ -132,8 +125,13 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.css-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.css = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
   ]);
 }

modules/plugins/languages/dart.nix

@@ -13,7 +13,7 @@
   inherit (lib.strings) optionalString;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.dag) entryAfter;
 
   cfg = config.vim.languages.dart;
   ftcfg = cfg.flutter-tools;
@@ -81,16 +81,25 @@ in {
         description = "Enable flutter-tools for flutter support";
       };
 
+      flutterPackage = mkOption {
+        type = nullOr package;
+        default = pkgs.flutter;
+        description = "Flutter package, or null to detect the flutter path at runtime instead.";
+      };
+
       enableNoResolvePatch = mkOption {
         type = bool;
-        default = true;
+        default = false;
         description = ''
           Whether to patch flutter-tools so that it doesn't resolve
           symlinks when detecting flutter path.
 
-          This is required if you want to use a flutter package built with nix.
+          ::: {.note}
-          If you are using a flutter SDK installed from a different source
+          This is required if `flutterPackage` is set to null and the flutter
-          and encounter the error "`dart` missing from PATH", disable this option.
+          package in your `PATH` was built with Nix. If you are using a flutter
+          SDK installed from a different source and encounter the error "`dart`
+          missing from `PATH`", leave this option disabled.
+          :::
         '';
       };
 
@@ -122,25 +131,32 @@ in {
     };
   };
 
-  config = mkIf cfg.enable (mkMerge [
+  config.vim = mkIf cfg.enable (mkMerge [
     (mkIf cfg.treesitter.enable {
-      vim.treesitter.enable = true;
+      treesitter.enable = true;
-      vim.treesitter.grammars = [cfg.treesitter.package];
+      treesitter.grammars = [cfg.treesitter.package];
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
+      lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
     })
 
     (mkIf ftcfg.enable {
-      vim.startPlugins =
+      lsp.enable = true;
-        if ftcfg.enableNoResolvePatch
-        then ["flutter-tools-patched"]
-        else ["flutter-tools-nvim"];
 
-      vim.pluginRC.flutter-tools = entryAnywhere ''
+      startPlugins = [
+        (
+          if ftcfg.enableNoResolvePatch
+          then "flutter-tools-patched"
+          else "flutter-tools-nvim"
+        )
+        "plenary-nvim"
+      ];
+
+      pluginRC.flutter-tools = entryAfter ["lsp-setup"] ''
         require('flutter-tools').setup {
+          ${optionalString (ftcfg.flutterPackage != null) "flutter_path = \"${ftcfg.flutterPackage}/bin/flutter\","}
           lsp = {
             color = { -- show the derived colours for dart variables
               enabled = ${boolToString ftcfg.color.enable}, -- whether or not to highlight color variables at all, only supported on flutter >= 2.10
@@ -152,7 +168,6 @@ in {
 
             capabilities = capabilities,
             on_attach = default_on_attach;
-            flags = lsp_flags,
           },
           ${optionalString cfg.dap.enable ''
           debugger = {

modules/plugins/languages/default.nix

@@ -10,6 +10,7 @@ in {
     ./clang.nix
     ./css.nix
     ./elixir.nix
+    ./fsharp.nix
     ./gleam.nix
     ./go.nix
     ./hcl.nix

modules/plugins/languages/elixir.nix

@@ -38,14 +38,9 @@
   formats = {
     mix = {
       package = pkgs.elixir;
-      nullConfig = ''
+      config = {
-        table.insert(
+        command = "${cfg.format.package}/bin/mix";
-          ls_sources,
+      };
-          null_ls.builtins.formatting.mix.with({
-            command = "${cfg.format.package}/bin/mix",
-          })
-        )
-      '';
     };
   };
 in {
@@ -107,8 +102,12 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.elixir-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.elixir = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} =
+          formats.${cfg.format.type}.config;
+      };
     })
 
     (mkIf cfg.elixir-tools.enable {

modules/plugins/languages/fsharp.nix

@@ -0,0 +1,107 @@
+{
+  lib,
+  pkgs,
+  config,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) either listOf package str enum;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.lists) isList;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  defaultServer = "fsautocomplete";
+  servers = {
+    fsautocomplete = {
+      package = pkgs.fsautocomplete;
+      internalFormatter = false;
+      lspConfig = ''
+        lspconfig.fsautocomplete.setup {
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else "{'${cfg.lsp.package}/bin/fsautocomplete'}"
+        },
+        }
+      '';
+    };
+  };
+
+  defaultFormat = "fantomas";
+  formats = {
+    fantomas = {
+      package = pkgs.fantomas;
+    };
+  };
+
+  cfg = config.vim.languages.fsharp;
+in {
+  options = {
+    vim.languages.fsharp = {
+      enable = mkEnableOption "F# language support";
+
+      treesitter = {
+        enable = mkEnableOption "F# treesitter" // {default = config.vim.languages.enableTreesitter;};
+        package = mkGrammarOption pkgs "fsharp";
+      };
+
+      lsp = {
+        enable = mkEnableOption "F# LSP support" // {default = config.vim.languages.enableLSP;};
+        server = mkOption {
+          type = enum (attrNames servers);
+          default = defaultServer;
+          description = "F# LSP server to use";
+        };
+
+        package = mkOption {
+          type = either package (listOf str);
+          default = servers.${cfg.lsp.server}.package;
+          example = ''[lib.getExe pkgs.fsautocomplete "--state-directory" "~/.cache/fsautocomplete"]'';
+          description = "F# LSP server package, or the command to run as a list of strings";
+        };
+      };
+      format = {
+        enable = mkEnableOption "F# formatting" // {default = config.vim.languages.enableFormat;};
+
+        type = mkOption {
+          type = enum (attrNames formats);
+          default = defaultFormat;
+          description = "F# formatter to use";
+        };
+
+        package = mkOption {
+          type = package;
+          default = formats.${cfg.format.type}.package;
+          description = "F# formatter 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.fsharp-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts.formatters_by_ft.fsharp = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
+    })
+  ]);
+}

modules/plugins/languages/go.nix

@@ -5,7 +5,7 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.options) mkEnableOption mkOption literalMD;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.lists) isList;
@@ -38,36 +38,15 @@
   formats = {
     gofmt = {
       package = pkgs.go;
-      nullConfig = ''
+      config.command = "${cfg.format.package}/bin/gofmt";
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.gofmt.with({
-            command = "${cfg.format.package}/bin/gofmt",
-          })
-        )
-      '';
     };
     gofumpt = {
       package = pkgs.gofumpt;
-      nullConfig = ''
+      config.command = getExe cfg.format.package;
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.gofumpt.with({
-            command = "${cfg.format.package}/bin/gofumpt",
-          })
-        )
-      '';
     };
     golines = {
       package = pkgs.golines;
-      nullConfig = ''
+      config.command = "${cfg.format.package}/bin/golines";
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.golines.with({
-            command = "${cfg.format.package}/bin/golines",
-          })
-        )
-      '';
     };
   };
 
@@ -105,7 +84,14 @@ in {
     };
 
     format = {
-      enable = mkEnableOption "Go formatting" // {default = config.vim.languages.enableFormat;};
+      enable =
+        mkEnableOption "Go formatting"
+        // {
+          default = !cfg.lsp.enable && config.vim.languages.enableFormat;
+          defaultText = literalMD ''
+            disabled if Go LSP is enabled, otherwise follows {option}`vim.languages.enableFormat`
+          '';
+        };
 
       type = mkOption {
         description = "Go formatter to use";
@@ -153,8 +139,11 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.go-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.go = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+      };
     })
 
     (mkIf cfg.dap.enable {

modules/plugins/languages/hcl.nix

@@ -6,6 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) package bool enum;
   inherit (lib.nvim.types) mkGrammarOption;
@@ -30,14 +31,6 @@
   formats = {
     hclfmt = {
       package = pkgs.hclfmt;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.hclfmt.with({
-            command = "${lib.getExe cfg.format.package}",
-          })
-        )
-      '';
     };
   };
 in {
@@ -110,8 +103,13 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.hcl-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.hcl = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
   ]);
 }

modules/plugins/languages/kotlin.nix

@@ -7,7 +7,6 @@
   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;
@@ -19,14 +18,6 @@
   diagnosticsProviders = {
     ktlint = {
       package = pkgs.ktlint;
-      nullConfig = pkg: ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.diagnostics.ktlint.with({
-            command = "${getExe pkg}",
-          })
-        )
-      '';
     };
   };
 in {
@@ -76,11 +67,13 @@ in {
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "kotlin";
+        linters_by_ft.kotlin = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters = mkMerge (map (name: {
-        inherit diagnosticsProviders;
+            ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+          })
+          cfg.extraDiagnostics.types);
       };
     })
 

modules/plugins/languages/lua.nix

@@ -4,16 +4,30 @@
   lib,
   ...
 }: let
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.lists) isList;
-  inherit (lib.types) either listOf package str;
+  inherit (lib.types) bool either enum listOf package str;
-  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryBefore;
 
   cfg = config.vim.languages.lua;
+  defaultFormat = "stylua";
+  formats = {
+    stylua = {
+      package = pkgs.stylua;
+    };
+  };
+
+  defaultDiagnosticsProvider = ["luacheck"];
+  diagnosticsProviders = {
+    luacheck = {
+      package = pkgs.luajitPackages.luacheck;
+    };
+  };
 in {
   imports = [
     (lib.mkRemovedOptionModule ["vim" "languages" "lua" "lsp" "neodev"] ''
@@ -39,6 +53,34 @@ in {
 
       lazydev.enable = mkEnableOption "lazydev.nvim integration, useful for neovim plugin developers";
     };
+
+    format = {
+      enable = mkOption {
+        type = bool;
+        default = config.vim.languages.enableFormat;
+        description = "Enable Lua formatting";
+      };
+      type = mkOption {
+        type = enum (attrNames formats);
+        default = defaultFormat;
+        description = "Lua formatter to use";
+      };
+
+      package = mkOption {
+        type = package;
+        default = formats.${cfg.format.type}.package;
+        description = "Lua formatter package";
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Lua diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Lua";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
   };
 
   config = mkMerge [
@@ -74,6 +116,27 @@ in {
           })
         '';
       })
+
+      (mkIf cfg.format.enable {
+        vim.formatter.conform-nvim = {
+          enable = true;
+          setupOpts.formatters_by_ft.lua = [cfg.format.type];
+          setupOpts.formatters.${cfg.format.type} = {
+            command = getExe cfg.format.package;
+          };
+        };
+      })
+
+      (mkIf cfg.extraDiagnostics.enable {
+        vim.diagnostics.nvim-lint = {
+          enable = true;
+          linters_by_ft.lua = cfg.extraDiagnostics.types;
+          linters = mkMerge (map (name: {
+              ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+            })
+            cfg.extraDiagnostics.types);
+        };
+      })
     ]))
   ];
 }

modules/plugins/languages/markdown.nix

@@ -5,12 +5,13 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.lists) isList concatLists;
+  inherit (lib.lists) isList;
-  inherit (lib.types) bool enum either package listOf str;
+  inherit (lib.types) bool enum either package listOf str nullOr;
   inherit (lib.nvim.lua) expToLua toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.languages.markdown;
@@ -32,31 +33,23 @@
     };
   };
 
-  defaultFormat = "denofmt";
+  defaultFormat = "deno_fmt";
   formats = {
+    # for backwards compatibility
     denofmt = {
       package = pkgs.deno;
-      nullConfig = ''
+    };
-        table.insert(
+    deno_fmt = {
-          ls_sources,
+      package = pkgs.deno;
-          null_ls.builtins.formatting.deno_fmt.with({
-            filetypes = ${expToLua (concatLists [cfg.format.extraFiletypes ["markdown"]])},
-            command = "${cfg.format.package}/bin/deno",
-          })
-        )
-      '';
     };
     prettierd = {
       package = pkgs.prettierd;
-      nullConfig = ''
+    };
-        table.insert(
+  };
-          ls_sources,
+  defaultDiagnosticsProvider = ["markdownlint-cli2"];
-          null_ls.builtins.formatting.prettierd.with({
+  diagnosticsProviders = {
-            filetypes = ${expToLua (concatLists [cfg.format.extraFiletypes ["markdown"]])},
+    markdownlint-cli2 = {
-            command = "${cfg.format.package}/bin/prettierd",
+      package = pkgs.markdownlint-cli2;
-          })
-        )
-      '';
     };
   };
 in {
@@ -96,7 +89,7 @@ in {
       type = mkOption {
         type = enum (attrNames formats);
         default = defaultFormat;
-        description = "Markdown formatter to use";
+        description = "Markdown formatter to use. `denofmt` is deprecated and currently aliased to deno_fmt.";
       };
 
       package = mkOption {
@@ -121,19 +114,32 @@ in {
               [render-markdown.nvim]: https://github.com/MeanderingProgrammer/render-markdown.nvim
 
               Inline Markdown rendering with [render-markdown.nvim]
-
             '';
           };
 
         setupOpts = mkPluginSetupOption "render-markdown" {
-          auto_override_publish_diagnostics = mkOption {
+          file_types = lib.mkOption {
-            description = "Automatically override the publish_diagnostics handler";
+            type = nullOr (listOf str);
-            type = bool;
+            default = null;
-            default = true;
+            description = ''
+              List of buffer filetypes to enable this plugin in.
+
+              This will cause the plugin to attach to new buffers who
+              have any of these filetypes.
+            '';
           };
         };
       };
     };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Markdown diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Markdown";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -148,8 +154,17 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.markdown-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.markdown = [cfg.format.type];
+        setupOpts.formatters.${
+          if cfg.format.type == "denofmt"
+          then "deno_fmt"
+          else cfg.format.type
+        } = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     # Extensions
@@ -159,5 +174,16 @@ in {
         require("render-markdown").setup(${toLuaObject cfg.extensions.render-markdown-nvim.setupOpts})
       '';
     })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.markdown = cfg.extraDiagnostics.types;
+        linters = mkMerge (map (name: {
+            ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+          })
+          cfg.extraDiagnostics.types);
+      };
+    })
   ]);
 }

modules/plugins/languages/nim.nix

@@ -6,6 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either listOf package str;
@@ -38,14 +39,9 @@
   formats = {
     nimpretty = {
       package = pkgs.nim;
-      nullConfig = ''
+      config = {
-        table.insert(
+        command = "${cfg.format.package}/bin/nimpretty";
-          ls_sources,
+      };
-          null_ls.builtins.formatting.nimpretty.with({
-            command = "${pkgs.nim}/bin/nimpretty",
-          })
-        )
-      '';
     };
   };
 in {
@@ -110,8 +106,11 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.nim-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.nim = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+      };
     })
   ]);
 }

modules/plugins/languages/nix.nix

@@ -6,6 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib) concatStringsSep;
+  inherit (lib.meta) getExe;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
@@ -13,7 +14,6 @@
   inherit (lib.types) anything attrsOf enum either listOf nullOr package str;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
   inherit (lib.nvim.lua) expToLua toLuaObject;
-  inherit (lib.nvim.languages) diagnosticsToLua;
 
   cfg = config.vim.languages.nix;
 
@@ -100,26 +100,10 @@
   formats = {
     alejandra = {
       package = pkgs.alejandra;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.alejandra.with({
-            command = "${cfg.format.package}/bin/alejandra"
-          })
-        )
-      '';
     };
 
     nixfmt = {
       package = pkgs.nixfmt-rfc-style;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.nixfmt.with({
-            command = "${cfg.format.package}/bin/nixfmt"
-          })
-        )
-      '';
     };
   };
 
@@ -237,17 +221,24 @@ in {
       vim.lsp.lspconfig.sources.nix-lsp = servers.${cfg.lsp.server}.lspConfig;
     })
 
-    (mkIf (cfg.format.enable && !servers.${cfg.lsp.server}.internalFormatter) {
+    (mkIf (cfg.format.enable && (!cfg.lsp.enable || !servers.${cfg.lsp.server}.internalFormatter)) {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.nix-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.nix = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "nix";
+        linters_by_ft.nix = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters = mkMerge (map (name: {
-        inherit diagnosticsProviders;
+            ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+          })
+          cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/ocaml.nix

@@ -37,14 +37,6 @@
   formats = {
     ocamlformat = {
       package = pkgs.ocamlPackages.ocamlformat;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.ocamlformat.with({
-            command = "${cfg.format.package}/bin/ocamlformat",
-          })
-        )
-      '';
     };
   };
 in {
@@ -97,9 +89,13 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.ocamlformat = formats.${cfg.format.type}.nullConfig;
+        enable = true;
-      vim.extraPackages = [formats.${cfg.format.type}.package];
+        setupOpts.formatters_by_ft.ocaml = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
   ]);
 }

modules/plugins/languages/python.nix

@@ -47,7 +47,7 @@
     };
 
     python-lsp-server = {
-      package = pkgs.python-lsp-server;
+      package = pkgs.python3Packages.python-lsp-server;
       lspConfig = ''
         lspconfig.pylsp.setup{
           capabilities = capabilities;
@@ -66,26 +66,10 @@
   formats = {
     black = {
       package = pkgs.black;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.black.with({
-            command = "${cfg.format.package}/bin/black",
-          })
-        )
-      '';
     };
 
     isort = {
       package = pkgs.isort;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.isort.with({
-            command = "${cfg.format.package}/bin/isort",
-          })
-        )
-      '';
     };
 
     black-and-isort = {
@@ -96,15 +80,6 @@
           black --quiet - "$@" | isort --profile black -
         '';
       };
-
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.black.with({
-            command = "${cfg.format.package}/bin/black",
-          })
-        )
-      '';
     };
 
     ruff = {
@@ -115,14 +90,6 @@
           ruff format -
         '';
       };
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.ruff.with({
-            command = "${cfg.format.package}/bin/ruff",
-          })
-        )
-      '';
     };
   };
 
@@ -132,7 +99,7 @@
       # idk if this is the best way to install/run debugpy
       package = pkgs.python3.withPackages (ps: with ps; [debugpy]);
       dapConfig = ''
-        dap.adapters.python = function(cb, config)
+        dap.adapters.debugpy = function(cb, config)
           if config.request == 'attach' then
             ---@diagnostic disable-next-line: undefined-field
             local port = (config.connect or config).port
@@ -161,7 +128,7 @@
         dap.configurations.python = {
           {
             -- The first three options are required by nvim-dap
-            type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
+            type = 'debugpy'; -- the type here established the link to the adapter definition: `dap.adapters.debugpy`
             request = 'launch';
             name = "Launch file";
 
@@ -272,8 +239,22 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.python-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        # HACK: I'm planning to remove these soon so I just took the easiest way out
+        setupOpts.formatters_by_ft.python =
+          if cfg.format.type == "black-and-isort"
+          then ["black"]
+          else [cfg.format.type];
+        setupOpts.formatters =
+          if (cfg.format.type == "black-and-isort")
+          then {
+            black.command = "${cfg.format.package}/bin/black";
+          }
+          else {
+            ${cfg.format.type}.command = getExe cfg.format.package;
+          };
+      };
     })
 
     (mkIf cfg.dap.enable {

modules/plugins/languages/r.nix

@@ -24,28 +24,29 @@
       package = pkgs.rWrapper.override {
         packages = [pkgs.rPackages.styler];
       };
-      nullConfig = ''
+      config = {
-        table.insert(
+        command = "${cfg.format.package}/bin/R";
-          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 = ''
+      config = {
-        table.insert(
+        command = "${cfg.format.package}/bin/R";
-          ls_sources,
+        stdin = true;
-          null_ls.builtins.formatting.format_r.with({
+        args = [
-            command = "${cfg.format.package}/bin/R",
+          "--slave"
-          })
+          "--no-restore"
-        )
+          "--no-save"
-      '';
+          "-s"
+          "-e"
+          ''formatR::tidy_source(source="stdin")''
+        ];
+        # TODO: range_args seem to be possible
+        # https://github.com/nvimtools/none-ls.nvim/blob/main/lua/null-ls/builtins/formatting/format_r.lua
+      };
     };
   };
 
@@ -118,8 +119,11 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.r-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.r = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+      };
     })
 
     (mkIf cfg.lsp.enable {

modules/plugins/languages/ruby.nix

@@ -6,10 +6,10 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
   inherit (lib.types) either listOf package str enum;
-  inherit (lib.nvim.languages) diagnosticsToLua;
 
   cfg = config.vim.languages.ruby;
 
@@ -35,24 +35,8 @@
   defaultFormat = "rubocop";
   formats = {
     rubocop = {
+      # TODO: is this right?
       package = pkgs.rubyPackages.rubocop;
-      nullConfig = ''
-        local conditional = function(fn)
-          local utils = require("null-ls.utils").make_conditional_utils()
-          return fn(utils)
-        end
-
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.rubocop.with({
-            command="${pkgs.bundler}/bin/bundle",
-            args = vim.list_extend(
-              {"exec", "rubocop", "-a" },
-              null_ls.builtins.formatting.rubocop._opts.args
-            ),
-          })
-        )
-      '';
     };
   };
 
@@ -60,14 +44,7 @@
   diagnosticsProviders = {
     rubocop = {
       package = pkgs.rubyPackages.rubocop;
-      nullConfig = pkg: ''
+      config.command = getExe cfg.format.package;
-        table.insert(
-          ls_sources,
-          null_ls.builtins.diagnostics.rubocop.with({
-            command = "${lib.getExe pkg}",
-          })
-        )
-      '';
     };
   };
 in {
@@ -136,16 +113,23 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.ruby-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.ruby = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "ruby";
+        linters_by_ft.ruby = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters = mkMerge (map (name: {
-        inherit diagnosticsProviders;
+            ${name}.cmd = getExe diagnosticsProviders.${name}.package;
+          })
+          cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/rust.nix

@@ -5,6 +5,7 @@
   ...
 }: let
   inherit (builtins) attrNames;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.strings) optionalString;
@@ -21,14 +22,6 @@
   formats = {
     rustfmt = {
       package = pkgs.rustfmt;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.rustfmt.with({
-            command = "${cfg.format.package}/bin/rustfmt",
-          })
-        )
-      '';
     };
   };
 in {
@@ -128,8 +121,13 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.rust-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.rust = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf (cfg.lsp.enable || cfg.dap.enable) {

modules/plugins/languages/sql.nix

@@ -6,11 +6,11 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.lua) expToLua;
-  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.nvim.types) diagnostics;
 
   cfg = config.vim.languages.sql;
@@ -41,15 +41,10 @@
   formats = {
     sqlfluff = {
       package = sqlfluffDefault;
-      nullConfig = ''
+      config = {
-        table.insert(
+        command = getExe cfg.format.package;
-          ls_sources,
+        append_args = ["--dialect=${cfg.dialect}"];
-          null_ls.builtins.formatting.sqlfluff.with({
+      };
-            command = "${cfg.format.package}/bin/sqlfluff",
-            extra_args = {"--dialect", "${cfg.dialect}"}
-          })
-        )
-      '';
     };
   };
 
@@ -57,15 +52,10 @@
   diagnosticsProviders = {
     sqlfluff = {
       package = sqlfluffDefault;
-      nullConfig = pkg: ''
+      config = {
-        table.insert(
+        cmd = getExe sqlfluffDefault;
-          ls_sources,
+        args = ["lint" "--format=json" "--dialect=${cfg.dialect}"];
-          null_ls.builtins.diagnostics.sqlfluff.with({
+      };
-            command = "${pkg}/bin/sqlfluff",
-            extra_args = {"--dialect", "${cfg.dialect}"}
-          })
-        )
-      '';
     };
   };
 in {
@@ -150,16 +140,20 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources."sql-format" = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.sql = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "sql";
+        linters_by_ft.sql = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters =
-        inherit diagnosticsProviders;
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/svelte.nix

@@ -9,9 +9,9 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.meta) getExe;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.lua) expToLua;
-  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
 
   cfg = config.vim.languages.svelte;
@@ -39,52 +39,31 @@
   formats = {
     prettier = {
       package = pkgs.nodePackages.prettier;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.prettier.with({
-            command = "${cfg.format.package}/bin/prettier",
-          })
-        )
-      '';
     };
 
     biome = {
       package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
     };
   };
 
   # TODO: specify packages
   defaultDiagnosticsProvider = ["eslint_d"];
   diagnosticsProviders = {
-    eslint_d = {
+    eslint_d = let
-      package = pkgs.eslint_d;
+      pkg = pkgs.eslint_d;
-      nullConfig = pkg: ''
+    in {
-        table.insert(
+      package = pkg;
-          ls_sources,
+      config = {
-          null_ls.builtins.diagnostics.eslint_d.with({
+        cmd = getExe pkg;
-            command = "${getExe pkg}",
+        required_files = [
-            condition = function(utils)
+          "eslint.config.js"
-              return utils.root_has_file({
+          "eslint.config.mjs"
-                "eslint.config.js",
+          ".eslintrc"
-                "eslint.config.mjs",
+          ".eslintrc.json"
-                ".eslintrc",
+          ".eslintrc.js"
-                ".eslintrc.json",
+          ".eslintrc.yml"
-                ".eslintrc.js",
+        ];
-                ".eslintrc.yml",
+      };
-              })
-            end,
-          })
-        )
-      '';
     };
   };
 in {
@@ -153,16 +132,22 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.svelte-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.svelte = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "svelte";
+        linters_by_ft.svelte = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters =
-        inherit diagnosticsProviders;
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
       };
     })
   ]);

modules/plugins/languages/ts.nix

@@ -9,10 +9,10 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.meta) getExe;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.types) enum either listOf package str bool;
   inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption;
-  inherit (lib.nvim.languages) diagnosticsToLua;
   inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.languages.ts;
@@ -77,65 +77,35 @@
   formats = {
     prettier = {
       package = pkgs.nodePackages.prettier;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.prettier.with({
-            command = "${cfg.format.package}/bin/prettier",
-            filetypes = { "typescript", "javascript" },
-          })
-        )
-      '';
     };
 
     prettierd = {
       package = pkgs.prettierd;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.prettier.with({
-            command = "${cfg.format.package}/bin/prettierd",
-          })
-        )
-      '';
     };
 
     biome = {
       package = pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
     };
   };
 
   # TODO: specify packages
   defaultDiagnosticsProvider = ["eslint_d"];
   diagnosticsProviders = {
-    eslint_d = {
+    eslint_d = let
-      package = pkgs.eslint_d;
+      pkg = pkgs.eslint_d;
-      nullConfig = pkg: ''
+    in {
-        table.insert(
+      package = pkg;
-          ls_sources,
+      config = {
-          null_ls.builtins.diagnostics.eslint_d.with({
+        cmd = getExe pkg;
-            command = "${getExe pkg}",
+        required_files = [
-            condition = function(utils)
+          "eslint.config.js"
-              return utils.root_has_file({
+          "eslint.config.mjs"
-                "eslint.config.js",
+          ".eslintrc"
-                "eslint.config.mjs",
+          ".eslintrc.json"
-                ".eslintrc",
+          ".eslintrc.js"
-                ".eslintrc.json",
+          ".eslintrc.yml"
-                ".eslintrc.js",
+        ];
-                ".eslintrc.yml",
+      };
-              })
-            end,
-          })
-        )
-      '';
     };
   };
 in {
@@ -225,16 +195,28 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.ts-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts = {
+          formatters_by_ft.typescript = [cfg.format.type];
+          # .tsx files
+          formatters_by_ft.typescriptreact = [cfg.format.type];
+          formatters.${cfg.format.type} = {
+            command = getExe cfg.format.package;
+          };
+        };
+      };
     })
 
     (mkIf cfg.extraDiagnostics.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.diagnostics.nvim-lint = {
-      vim.lsp.null-ls.sources = diagnosticsToLua {
+        enable = true;
-        lang = "ts";
+        linters_by_ft.typescript = cfg.extraDiagnostics.types;
-        config = cfg.extraDiagnostics.types;
+        linters_by_ft.typescriptreact = cfg.extraDiagnostics.types;
-        inherit diagnosticsProviders;
+
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
       };
     })
 

modules/plugins/languages/typst.nix

@@ -9,7 +9,6 @@
   inherit (lib.lists) isList;
   inherit (lib.types) nullOr enum either attrsOf listOf package str;
   inherit (lib.attrsets) attrNames;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
@@ -61,26 +60,10 @@
   formats = {
     typstfmt = {
       package = pkgs.typstfmt;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.typstfmt.with({
-            command = "${cfg.format.package}/bin/typstfmt",
-          })
-        )
-      '';
     };
     # https://github.com/Enter-tainer/typstyle
     typstyle = {
       package = pkgs.typstyle;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.typstfmt.with({
-            command = "${cfg.format.package}/bin/typstyle",
-          })
-        )
-      '';
     };
   };
 in {
@@ -176,8 +159,13 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.lsp.null-ls.enable = true;
+      vim.formatter.conform-nvim = {
-      vim.lsp.null-ls.sources.typst-format = formats.${cfg.format.type}.nullConfig;
+        enable = true;
+        setupOpts.formatters_by_ft.typst = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
     })
 
     (mkIf cfg.lsp.enable {

modules/plugins/lsp/config.nix

@@ -4,6 +4,7 @@
   pkgs,
   ...
 }: let
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.modules) mkIf;
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString;
@@ -28,6 +29,25 @@ in {
         sourcePlugins = ["cmp-nvim-lsp"];
       };
 
+      autocmds =
+        if cfg.inlayHints.enable
+        then [
+          {
+            callback = mkLuaInline ''
+              function(event)
+                local bufnr = event.buf
+                local client = vim.lsp.get_client_by_id(event.data.client_id)
+                if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+                  vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }), { bufnr = bufnr })
+                end
+              end
+            '';
+            desc = "LSP on-attach enable inlay hints autocmd";
+            event = ["LspAttach"];
+          }
+        ]
+        else [];
+
       pluginRC.lsp-setup = ''
         vim.g.formatsave = ${boolToString cfg.formatOnSave};
 

modules/plugins/lsp/default.nix

@@ -15,7 +15,6 @@
     ./lightbulb
     ./otter
     ./lspkind
-    ./lsplines
     ./nvim-docs-view
   ];
 }

modules/plugins/lsp/lsplines/config.nix

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

modules/plugins/lsp/lsplines/lsplines.nix

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

modules/plugins/lsp/lspsaga/lspsaga.nix

@@ -6,6 +6,19 @@
   inherit (lib.modules) mkRemovedOptionModule;
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.nvim.types) borderType mkPluginSetupOption;
+  inherit (lib.nvim.lua) mkLuaInline;
+
+  uiKindSetupOpts =
+    if config.vim.theme.enable && config.vim.theme.name == "catppuccin"
+    then {
+      ui.kind =
+        mkLuaInline
+        # lua
+        ''
+          require("catppuccin.groups.integrations.lsp_saga").custom_kind()
+        '';
+    }
+    else {};
 in {
   imports = [
     (mkRemovedOptionModule ["vim" "lsp" "lspsaga" "mappings"] ''
@@ -21,12 +34,14 @@ in {
   options.vim.lsp.lspsaga = {
     enable = mkEnableOption "LSP Saga";
 
-    setupOpts = mkPluginSetupOption "lspsaga" {
+    setupOpts =
-      border_style = mkOption {
+      mkPluginSetupOption "lspsaga" {
-        type = borderType;
+        border_style = mkOption {
-        default = config.vim.ui.borders.globalStyle;
+          type = borderType;
-        description = "Border type, see {command}`:help nvim_open_win`";
+          default = config.vim.ui.borders.globalStyle;
-      };
+          description = "Border type, see {command}`:help nvim_open_win`";
-    };
+        };
+      }
+      // uiKindSetupOpts;
   };
 }

modules/plugins/lsp/module.nix

@@ -5,6 +5,9 @@ in {
   options.vim.lsp = {
     enable = mkEnableOption "LSP, also enabled automatically through null-ls and lspconfig options";
     formatOnSave = mkEnableOption "format on save";
+    inlayHints = {
+      enable = mkEnableOption "inlay hints";
+    };
     mappings = {
       goToDefinition =
         mkMappingOption "Go to definition"

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

@@ -4,13 +4,12 @@
   ...
 }: let
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.attrsets) mapAttrs;
+  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.trivial) boolToString;
+  inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.nvim.dag) entryAnywhere entryAfter entryBetween;
 
-  cfg = config.vim.lsp;
+  cfg = config.vim.lsp.null-ls;
 in {
-  config = mkIf cfg.null-ls.enable (mkMerge [
+  config = mkIf cfg.enable (mkMerge [
     {
       vim = {
         startPlugins = [
@@ -18,35 +17,14 @@ in {
           "plenary-nvim"
         ];
 
-        # null-ls implies LSP already being set up
+        # null-ls implies that LSP is already being set up
-        # since it will hook into LSPs to receive information
+        # as it will hook into LSPs to receive information.
         lsp.enable = true;
 
-        pluginRC = {
+        pluginRC.null_ls = entryAfter ["lsp-setup"] ''
-          # early setup for null-ls
+          require('null-ls').setup(${toLuaObject cfg.setupOpts})
-          null_ls-setup = entryAnywhere ''
+        '';
-            local null_ls = require("null-ls")
-            local null_helpers = require("null-ls.helpers")
-            local null_methods = require("null-ls.methods")
-            local ls_sources = {}
-          '';
-
-          # null-ls setup
-          null_ls = entryAfter ["null_ls-setup" "lsp-setup"] ''
-            require('null-ls').setup({
-              debug = ${boolToString cfg.null-ls.debug},
-              diagnostics_format = "${cfg.null-ls.diagnostics_format}",
-              debounce = ${toString cfg.null-ls.debounce},
-              default_timeout = ${toString cfg.null-ls.default_timeout},
-              sources = ls_sources,
-              on_attach = default_on_attach
-            })
-          '';
-        };
       };
     }
-    {
-      vim.pluginRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
-    }
   ]);
 }

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

@@ -1,34 +1,87 @@
 {lib, ...}: let
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.types) attrsOf str int;
+  inherit (lib.types) listOf str int nullOr;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.types) luaInline mkPluginSetupOption;
+  inherit (lib.nvim.config) batchRenameOptions;
+
+  migrationTable = {
+    debug = "debug";
+    diagnostics_format = "diagnostics_format";
+    debounce = "debounce";
+    default_timeout = "default_timeout";
+    sources = "sources";
+  };
+
+  renamedSetupOpts =
+    batchRenameOptions
+    ["vim" "lsp" "null-ls"]
+    ["vim" "lsp" "null-ls" "setupOpts"]
+    migrationTable;
 in {
+  imports = renamedSetupOpts;
+
   options.vim.lsp.null-ls = {
-    enable = mkEnableOption "null-ls, also enabled automatically";
+    enable = mkEnableOption ''
+      null-ls, plugin to use Neovim as a language server to inject LSP diagnostics,
+      code actions, and more via Lua.
+    '';
 
-    debug = mkEnableOption "debugging information for `null-ls";
+    setupOpts = mkPluginSetupOption "null-ls" {
+      debug = mkEnableOption ''
+        debugging information for null-ls.
 
-    diagnostics_format = mkOption {
+        Displays all possible log messages and writes them to the null-ls log,
-      type = str;
+        which you can view with the command `:NullLsLog`
-      default = "[#{m}] #{s} (#{c})";
+      '';
-      description = "Diagnostic output format for null-ls";
-    };
 
-    debounce = mkOption {
+      diagnostics_format = mkOption {
-      type = int;
+        type = str;
-      default = 250;
+        default = "[#{m}] #{s} (#{c})";
-      description = "Default debounce";
+        description = ''
-    };
+          Sets the default format used for diagnostics. null-ls will replace th
+          e following special components with the relevant diagnostic information:
 
-    default_timeout = mkOption {
+          * `#{m}`: message
-      type = int;
+          * `#{s}`: source name (defaults to null-ls if not specified)
-      default = 5000;
+          * `#{c}`: code (if available)
-      description = "Default timeout value, in milliseconds";
+        '';
-    };
+      };
 
-    sources = mkOption {
+      debounce = mkOption {
-      description = "null-ls sources";
+        type = int;
-      type = attrsOf str;
+        default = 250;
-      default = {};
+        description = ''
+          Amount of time between the last change to a buffer and the next `textDocument/didChange` notification.
+        '';
+      };
+
+      default_timeout = mkOption {
+        type = int;
+        default = 5000;
+        description = ''
+          Amount of time (in milliseconds) after which built-in sources will time out.
+
+          :::{.note}
+          Built-in sources can define their own timeout period and users can override
+          the timeout period on a per-source basis
+          :::
+        '';
+      };
+
+      sources = mkOption {
+        type = nullOr (listOf luaInline);
+        default = null;
+        description = "Sources for null-ls to register";
+      };
+
+      on_attach = mkOption {
+        type = nullOr luaInline;
+        default = mkLuaInline "on_attach";
+        description = ''
+          Defines an on_attach callback to run whenever null-ls attaches to a buffer.
+        '';
+      };
     };
   };
 }

modules/plugins/mini/cursorword/config.nix

@@ -0,0 +1,19 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.mini.cursorword;
+in {
+  vim = mkIf cfg.enable {
+    startPlugins = ["mini-cursorword"];
+
+    pluginRC.mini-ai = entryAnywhere ''
+      require("mini.cursorword").setup(${toLuaObject cfg.setupOpts})
+    '';
+  };
+}

modules/plugins/mini/cursorword/cursorword.nix

@@ -0,0 +1,9 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+in {
+  options.vim.mini.cursorword = {
+    enable = mkEnableOption "mini.cursorword";
+    setupOpts = mkPluginSetupOption "mini.cursorword" {};
+  };
+}

modules/plugins/mini/cursorword/default.nix

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

modules/plugins/mini/default.nix

@@ -11,6 +11,7 @@
     ./colors
     ./comment
     ./completion
+    ./cursorword
     ./diff
     ./doc
     ./extra

modules/plugins/mini/indentscope/config.nix

@@ -3,6 +3,7 @@
   lib,
   ...
 }: let
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.modules) mkIf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
@@ -10,6 +11,21 @@
   cfg = config.vim.mini.indentscope;
 in {
   vim = mkIf cfg.enable {
+    autocmds = [
+      {
+        callback = mkLuaInline ''
+          function()
+            local ignore_filetypes = ${toLuaObject cfg.setupOpts.ignore_filetypes}
+            if vim.tbl_contains(ignore_filetypes, vim.bo.filetype) then
+              vim.b.miniindentscope_disable = true
+            end
+          end
+        '';
+        desc = "Disable indentscope for certain filetypes";
+        event = ["FileType"];
+      }
+    ];
+
     startPlugins = ["mini-indentscope"];
 
     pluginRC.mini-indentscope = entryAnywhere ''

modules/plugins/mini/indentscope/indentscope.nix

@@ -1,13 +1,16 @@
-{
+{lib, ...}: let
-  config,
+  inherit (lib.options) mkOption mkEnableOption;
-  lib,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption;
   inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.types) str listOf;
 in {
   options.vim.mini.indentscope = {
     enable = mkEnableOption "mini.indentscope";
-    setupOpts = mkPluginSetupOption "mini.indentscope" {};
+    setupOpts = mkPluginSetupOption "mini.indentscope" {
+      ignore_filetypes = mkOption {
+        type = listOf str;
+        default = ["help" "neo-tree" "notify" "NvimTree" "TelescopePrompt"];
+        description = "File types to ignore for illuminate";
+      };
+    };
   };
 }

modules/plugins/statusline/lualine/config.nix

@@ -14,12 +14,28 @@
   bCfg = config.vim.ui.breadcrumbs;
 in {
   config = mkMerge [
-    # TODO: move into nvim-tree file
+    {
-    (mkIf config.vim.filetree.nvimTree.enable {
+      vim.statusline.lualine.setupOpts.extensions =
-      vim.statusline.lualine.setupOpts = {
+        (lib.optionals config.vim.filetree.nvimTree.enable ["nvim-tree"])
-        extensions = ["nvim-tree"];
+        ++ (lib.optionals config.vim.filetree.neo-tree.enable ["neo-tree"])
-      };
+        ++ (lib.optionals config.vim.utility.snacks-nvim.enable [
-    })
+          {
+            # same extensions as nerdtree / neo-tree
+            # https://github.com/nvim-lualine/lualine.nvim/blob/master/lua/lualine/extensions/nerdtree.lua
+            # https://github.com/nvim-lualine/lualine.nvim/blob/master/lua/lualine/extensions/neo-tree.lua
+            sections = {
+              lualine_a = mkLuaInline ''
+                {
+                  function()
+                    return vim.fn.fnamemodify(vim.fn.getcwd(), ":~")
+                  end,
+                }
+              '';
+            };
+            filetypes = ["snacks_picker_list" "snacks_picker_input"];
+          }
+        ]);
+    }
 
     (mkIf (bCfg.enable && bCfg.lualine.winbar.enable && bCfg.source == "nvim-navic") {
       vim.statusline.lualine.setupOpts = {

modules/plugins/statusline/lualine/lualine.nix

@@ -239,35 +239,26 @@ in {
             {
               -- Lsp server name
               function()
-                local buf_ft = vim.api.nvim_get_option_value('filetype', {})
+                local buf_ft = vim.bo.filetype
+                local excluded_buf_ft = { toggleterm = true, NvimTree = true, ["neo-tree"] = true, TelescopePrompt = true }
 
-                -- List of buffer types to exclude
+                if excluded_buf_ft[buf_ft] then
-                local excluded_buf_ft = {"toggleterm", "NvimTree", "neo-tree", "TelescopePrompt"}
+                  return ""
-
-                -- Check if the current buffer type is in the excluded list
-                for _, excluded_type in ipairs(excluded_buf_ft) do
-                  if buf_ft == excluded_type then
-                    return ""
                   end
+
+                local bufnr = vim.api.nvim_get_current_buf()
+                local clients = vim.lsp.get_clients({ bufnr = bufnr })
+
+                if vim.tbl_isempty(clients) then
+                  return "No Active LSP"
                 end
 
-                -- Get the name of the LSP server active in the current buffer
+                local active_clients = {}
-                local clients = vim.lsp.get_active_clients()
-                local msg = 'No Active Lsp'
-
-                -- if no lsp client is attached then return the msg
-                if next(clients) == nil then
-                  return msg
-                end
-
                 for _, client in ipairs(clients) do
-                  local filetypes = client.config.filetypes
+                  table.insert(active_clients, client.name)
-                  if filetypes and vim.fn.index(filetypes, buf_ft) ~= -1 then
-                    return client.name
-                  end
                 end
 
-                return msg
+                return table.concat(active_clients, ", ")
               end,
               icon = ' ',
               separator = {left = ''},

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

@@ -9,7 +9,7 @@
   inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.tabline.nvimBufferline;
-  self = import ./nvim-bufferline.nix {inherit lib;};
+  self = import ./nvim-bufferline.nix {inherit config lib;};
   inherit (self.options.vim.tabline.nvimBufferline) mappings;
 in {
   config = mkIf cfg.enable {

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

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) enum bool either nullOr str int listOf attrs;
   inherit (lib.generators) mkLuaInline;
@@ -23,7 +27,14 @@ in {
     setupOpts = mkPluginSetupOption "Bufferline-nvim" {
       highlights = mkOption {
         type = either attrs luaInline;
-        default = {};
+        default =
+          if config.vim.theme.enable && config.vim.theme.name == "catppuccin"
+          then
+            mkLuaInline
+            ''
+              require("catppuccin.groups.integrations.bufferline").get()
+            ''
+          else {};
         description = ''
           Overrides the highlight groups of bufferline.
 
@@ -261,14 +272,12 @@ in {
 
         offsets = mkOption {
           type = listOf attrs;
-          default = [
+          default = map (filetype: {
-            {
+            inherit filetype;
-              filetype = "NvimTree";
+            text = "File Explorer";
-              text = "File Explorer";
+            highlight = "Directory";
-              highlight = "Directory";
+            separator = true;
-              separator = true;
+          }) ["NvimTree" "neo-tree" "snacks_layout_box"];
-            }
-          ];
           description = "The windows to offset bufferline above, see `:help bufferline-offset`";
         };
 

modules/plugins/theme/supported-themes.nix

@@ -66,21 +66,22 @@ in {
         transparent_background = ${boolToString transparent},
         term_colors = true,
         integrations = {
-      	  nvimtree = {
+          nvimtree = {
-      		  enabled = true,
+            enabled = true,
-      		  transparent_panel = ${boolToString transparent},
+            transparent_panel = ${boolToString transparent},
-      		  show_root = true,
+            show_root = true,
-      	  },
+          },
 
           hop = true,
-      	  gitsigns = true,
+          gitsigns = true,
-      	  telescope = true,
+          telescope = true,
-      	  treesitter = true,
+          treesitter = true,
           treesitter_context = true,
-      	  ts_rainbow = true,
+          ts_rainbow = true,
           fidget = true,
           alpha = true,
           leap = true,
+          lsp_saga = true,
           markdown = true,
           noice = true,
           notify = true, -- nvim-notify
@@ -106,9 +107,9 @@ in {
       style' =
         warnIf (style == "light") "oxocarbon: light theme is not well-supported" style;
     in ''
-       require('oxocarbon')
+      require('oxocarbon')
-       vim.opt.background = "${style'}"
+      vim.opt.background = "${style'}"
-       vim.cmd.colorscheme = "oxocarbon"
+      vim.cmd.colorscheme = "oxocarbon"
       ${optionalString transparent ''
         vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
         vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })

modules/plugins/treesitter/treesitter.nix

@@ -24,12 +24,19 @@ in {
     grammars = mkOption {
       type = listOf package;
       default = [];
+      example = literalExpression ''
+        pkgs.vimPlugins.nvim-treesitter.builtGrammars; [
+          regex
+          kdl
+        ];
+      '';
       description = ''
-        List of treesitter grammars to install.
+        List of treesitter grammars to install. For grammars to be installed properly,
+        you must use grammars from `pkgs.vimPlugins.nvim-treesitter.builtGrammars`.
 
-        For languages already supported by nvf, you may
+        For languages already supported by nvf, you may use
-        use the {option}`vim.language.<lang>.treesitter` options, which
+        {option}`vim.language.<lang>.treesitter` options, which will automatically add
-        will automatically add the required grammars to this.
+        the required grammars to this.
       '';
     };
 

modules/plugins/ui/illuminate/illuminate.nix

@@ -11,7 +11,7 @@ in {
     setupOpts = mkPluginSetupOption "vim-illuminate" {
       filetypes_denylist = mkOption {
         type = listOf str;
-        default = ["dirvish" "fugitive" "NvimTree" "TelescopePrompt"];
+        default = ["dirvish" "fugitive" "help" "neo-tree" "notify" "NvimTree" "TelescopePrompt"];
         description = "Filetypes to not illuminate, this overrides `filetypes_allowlist`";
       };
     };

modules/plugins/utility/default.nix

@@ -15,8 +15,10 @@
     ./multicursors
     ./new-file-template
     ./nix-develop
+    ./oil-nvim
     ./outline
     ./preview
+    ./sleuth
     ./snacks-nvim
     ./surround
     ./telescope

modules/plugins/utility/fzf-lua/fzf-lua.nix

@@ -1,15 +1,21 @@
 {
   config,
   lib,
+  pkgs,
   ...
 }: let
-  inherit (lib.types) nullOr enum;
+  inherit (lib.types) enum str;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.nvim.types) mkPluginSetupOption borderType;
 in {
   options.vim.fzf-lua = {
     enable = mkEnableOption "fzf-lua";
     setupOpts = mkPluginSetupOption "fzf-lua" {
+      fzf_bin = mkOption {
+        type = str;
+        default = "${lib.getExe pkgs.fzf}";
+        description = "Path to fzf executable";
+      };
       winopts.border = mkOption {
         type = borderType;
         default = config.vim.ui.borders.globalStyle;

modules/plugins/utility/motion/default.nix

@@ -1,5 +1,6 @@
 _: {
   imports = [
+    ./flash
     ./hop
     ./leap
     ./precognition

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

@@ -0,0 +1,34 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.binds) mkKeymap;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.dag) entryAnywhere;
+
+  cfg = config.vim.utility.motion.flash-nvim;
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      lazy.plugins = {
+        "flash-nvim" = {
+          package = "flash-nvim";
+          setupModule = "flash";
+          setupOpts = cfg.setupOpts;
+
+          lazy = true;
+
+          keys = [
+            (mkKeymap ["n" "o" "x"] cfg.mappings.jump "<cmd>lua require(\"flash\").jump()<cr>" {desc = "Flash";})
+            (mkKeymap ["n" "o" "x"] cfg.mappings.treesitter "<cmd>lua require(\"flash\").treesitter()<cr>" {desc = "Flash Treesitter";})
+            (mkKeymap "o" cfg.mappings.remote "<cmd>lua require(\"flash\").remote()<cr>" {desc = "Remote Flash";})
+            (mkKeymap ["o" "x"] cfg.mappings.treesitter_search "<cmd>lua require(\"flash\").treesitter_search()<cr>" {desc = "Treesitter Search";})
+            (mkKeymap "c" cfg.mappings.toggle "<cmd>lua require(\"flash\").toggle()<cr>" {desc = "Toggle Flash Search";})
+          ];
+        };
+      };
+    };
+  };
+}

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

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

modules/plugins/utility/motion/flash/flash.nix

@@ -0,0 +1,38 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) nullOr str;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+in {
+  options.vim.utility.motion.flash-nvim = {
+    enable = mkEnableOption "enhanced code navigation with flash.nvim";
+    setupOpts = mkPluginSetupOption "flash-nvim" {};
+
+    mappings = {
+      jump = mkOption {
+        type = nullOr str;
+        default = "s";
+        description = "Jump";
+      };
+      treesitter = mkOption {
+        type = nullOr str;
+        default = "S";
+        description = "Treesitter";
+      };
+      remote = mkOption {
+        type = nullOr str;
+        default = "r";
+        description = "Remote Flash";
+      };
+      treesitter_search = mkOption {
+        type = nullOr str;
+        default = "R";
+        description = "Treesitter Search";
+      };
+      toggle = mkOption {
+        type = nullOr str;
+        default = "<c-s>";
+        description = "Toggle Flash Search";
+      };
+    };
+  };
+}

modules/plugins/utility/oil-nvim/config.nix

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

modules/plugins/utility/oil-nvim/default.nix

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

modules/plugins/utility/oil-nvim/oil-nvim.nix

@@ -0,0 +1,12 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+in {
+  options.vim.utility.oil-nvim = {
+    enable = mkEnableOption ''
+      Neovim file explorer: edit your filesystem like a buffer [oil-nvim]
+    '';
+
+    setupOpts = mkPluginSetupOption "oil-nvim" {};
+  };
+}

modules/plugins/utility/sleuth/config.nix

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

modules/plugins/utility/sleuth/default.nix

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

modules/plugins/utility/sleuth/sleuth.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.utility.sleuth.enable = mkEnableOption ''
+    automatically adjusting options such as `shiftwidth` or `expandtab`, using `vim-sleuth`
+  '';
+}

modules/plugins/utility/telescope/telescope.nix

@@ -11,6 +11,12 @@
 
   cfg = config.vim.telescope;
   setupOptions = {
+    pickers.find_files.find_command = mkOption {
+      description = "cmd to use for finding files";
+      type = either (listOf str) luaInline;
+      default = ["${pkgs.fd}/bin/fd" "--type=file"];
+    };
+
     defaults = {
       vimgrep_arguments = mkOption {
         type = listOf str;
@@ -138,8 +144,7 @@
 
       file_ignore_patterns = mkOption {
         type = listOf str;
-        default = ["node_modules" ".git/" "dist/" "build/" "target/" "result/"];
+        default = ["node_modules" "%.git/" "dist/" "build/" "target/" "result/"];
-        description = "A table of lua regex that define the files that should be ignored.";
       };
 
       color_devicons = mkOption {

modules/plugins/visuals/nvim-scrollbar/config.nix

@@ -12,8 +12,7 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = ["nvim-scrollbar"];
-
+      pluginRC.nvim-scrollbar = entryAnywhere ''
-      pluginRC.cursorline = entryAnywhere ''
         require("scrollbar").setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/visuals/nvim-scrollbar/scrollbar-nvim.nix

@@ -13,7 +13,7 @@ in {
     setupOpts = mkPluginSetupOption "scrollbar-nvim" {
       excluded_filetypes = mkOption {
         type = listOf str;
-        default = ["prompt" "TelescopePrompt" "noice" "noice" "NvimTree" "neo-tree" "alpha" "notify" "Navbuddy"];
+        default = ["prompt" "TelescopePrompt" "noice" "NvimTree" "neo-tree" "alpha" "notify" "Navbuddy" "fastaction_popup"];
         description = "Filetypes to hide the scrollbar on";
       };
     };

modules/wrapper/build/config.nix

@@ -48,16 +48,9 @@
       patches = [./patches/flutter-tools.patch];
 
       # Disable failing require check hook checks
-      nvimSkipModule = [
+      doCheck = false;
-        "flutter-tools.devices"
-        "flutter-tools.dap"
-        "flutter-tools.runners.job_runner"
-        "flutter-tools.decorations"
-        "flutter-tools.commands"
-        "flutter-tools.executable"
-        "flutter-tools.dev_tools"
-      ];
     };
+
     inherit (inputs.self.legacyPackages.${pkgs.stdenv.system}) blink-cmp;
   };
 

modules/wrapper/rc/config.nix

@@ -5,7 +5,7 @@
 }: let
   inherit (builtins) map mapAttrs filter;
   inherit (lib.attrsets) mapAttrsToList;
-  inherit (lib.strings) concatLines concatMapStringsSep;
+  inherit (lib.strings) concatLines concatMapStringsSep optionalString;
   inherit (lib.trivial) showWarnings;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter mkLuarcSection resolveDag entryAnywhere;
@@ -72,6 +72,14 @@ in {
           dag = cfg.luaConfigRC;
           mapResult = result:
             concatLines [
+              (optionalString (cfg.additionalRuntimePaths != []) ''
+                vim.opt.runtimepath:append(${toLuaObject cfg.additionalRuntimePaths})
+              '')
+              (optionalString cfg.enableLuaLoader ''
+                if vim.loader then
+                  vim.loader.enable()
+                end
+              '')
               cfg.luaConfigPre
               (concatMapStringsSep "\n" mkLuarcSection result)
               cfg.luaConfigPost

modules/wrapper/rc/options.nix

@@ -1,15 +1,7 @@
-{
+{lib, ...}: let
-  config,
-  lib,
-  ...
-}: let
   inherit (lib.options) mkOption literalMD literalExpression;
-  inherit (lib.strings) optionalString;
   inherit (lib.types) str bool int enum attrsOf lines listOf either path submodule anything;
   inherit (lib.nvim.types) dagOf;
-  inherit (lib.nvim.lua) listToLuaTable;
-
-  cfg = config.vim;
 in {
   options.vim = {
     enableLuaLoader = mkOption {
@@ -286,21 +278,7 @@ in {
 
     luaConfigPre = mkOption {
       type = str;
-      default = ''
+      default = "";
-        ${optionalString (cfg.additionalRuntimePaths != []) ''
-          -- The following list is generated from `vim.additionalRuntimePaths`
-          -- and is used to append additional runtime paths to the
-          -- `runtimepath` option.
-          vim.opt.runtimepath:append(${listToLuaTable cfg.additionalRuntimePaths})
-        ''}
-
-        ${optionalString cfg.enableLuaLoader ''
-          if vim.loader then
-            vim.loader.enable()
-          end
-        ''}
-      '';
-
       defaultText = literalMD ''
         By default, this option will **append** paths in
         [](#opt-vim.additionalRuntimePaths)

npins/sources.nix

@@ -98,7 +98,9 @@ builtins.mapAttrs
             Channel = getZip;
             Tarball = getUrl;
           }
-          .${spec.type}
+          .${
+            spec.type
+          }
           or (builtins.throw "Unknown source type ${spec.type}");
       in
         spec // {outPath = mayOverride (func spec);}