Merge branch 'main' into telescope-ext

Add "auto" flavour for catppuccin theme

.github/labels.yml

@@ -0,0 +1,55 @@
+# This file is used by .github/workflows/labels.yml
+"topic: plugins":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - modules/plugins/**/*
+
+"topic: modules":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - modules/**/*
+
+"topic: dependencies":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - npins
+        - flake.lock
+
+"topic: CI":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - .github/workflows/*.yml
+        - .github/typos.toml
+        - .github/dependabot.yml
+
+"topic: meta":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - .github/CODEOWNERS
+        - LICENSE
+        - .github/README.md
+        - .github/funding.yml
+        - .github/assets
+        - .github/*_TEMPLATE
+        - .gitignore
+        - .editorconfig
+        - release.json
+
+"topic: documentation":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+        - docs/**/*
+        - .github/CONTRIBUTING.md
+        - .github/README.md
+"topic: packaging":
+  - any:
+    - changed-files:
+      - any-glob-to-any-file:
+          - flake.nix
+          - flake/packages.nix

.github/workflows/backport.yml

@@ -0,0 +1,33 @@
+name: Backport PR on Label
+
+on:
+  pull_request_target:
+    types:
+      - labeled
+
+# Permissions needed for the korthout/backport-action to create branches and PRs
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  backport:
+    name: Create Backport PR
+    runs-on: ubuntu-latest
+    if: |
+      github.event.pull_request.merged == true && startsWith(github.event.label.name, 'backport-')
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          token: ${{ steps.app-token.outputs.token }}
+
+      - name: Backport Action
+        uses: korthout/backport-action@v3
+        with:
+          # Regex pattern for labels that should trigger a backport AND extracts the target branch
+          # from the name (e.g. v0.x or v0.x.y; we use zerover). This action will ONLY proceed if
+          # the label that triggered the workflow fully matches this pattern.
+          # Example matching labels: "backport-v0.1", "backport-v0.10.1"
+          # Example non-matching labels: "backport-foo", "backport-v1.0"
+          label_pattern: '^backport-(v0\.\d+(\.\d+)?)$'

.github/workflows/labeler.yml

@@ -0,0 +1,21 @@
+name: "Label PR"
+
+on:
+  pull_request_target:
+    types: [edited, opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  labels:
+    name: "Label PR"
+    runs-on: ubuntu-latest
+    if: "!contains(github.event.pull_request.title, '[skip ci]')"
+    steps:
+      - uses: actions/labeler@v5
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          configuration-path: .github/labels.yml
+          sync-labels: true

configuration.nix

@@ -18,12 +18,16 @@ isMaximal: {
     };
 
     lsp = {
+      # This must be enabled for the language modules to hook into
+      # the LSP API.
+      enable = true;
+
       formatOnSave = true;
       lspkind.enable = false;
       lightbulb.enable = true;
       lspsaga.enable = false;
       trouble.enable = true;
-      lspSignature.enable = true;
+      lspSignature.enable = !isMaximal; # conflicts with blink in maximal
       otter-nvim.enable = isMaximal;
       nvim-docs-view.enable = isMaximal;
     };
@@ -38,8 +42,7 @@ isMaximal: {
     # This section does not include a comprehensive list of available language modules.
     # To list all available language module options, please visit the nvf manual.
     languages = {
-      enableLSP = true;
-      enableFormat = true;
+      enableFormat = true; #
       enableTreesitter = true;
       enableExtraDiagnostics = true;
 
@@ -124,7 +127,15 @@ isMaximal: {
 
     autopairs.nvim-autopairs.enable = true;
 
-    autocomplete.nvim-cmp.enable = true;
+    # nvf provides various autocomplete options. The tried and tested nvim-cmp
+    # is enabled in default package, because it does not trigger a build. We
+    # enable blink-cmp in maximal because it needs to build its rust fuzzy
+    # matcher library.
+    autocomplete = {
+      nvim-cmp.enable = !isMaximal;
+      blink-cmp.enable = isMaximal;
+    };
+
     snippets.luasnip.enable = true;
 
     filetree = {
@@ -142,6 +153,7 @@ isMaximal: {
     binds = {
       whichKey.enable = true;
       cheatsheet.enable = true;
+      hardtime-nvim.enable = isMaximal;
     };
 
     telescope.enable = true;
@@ -187,6 +199,7 @@ isMaximal: {
       };
       images = {
         image-nvim.enable = false;
+        img-clip.enable = isMaximal;
       };
     };
 
@@ -235,6 +248,7 @@ isMaximal: {
         cmp.enable = isMaximal;
       };
       codecompanion-nvim.enable = false;
+      avante-nvim.enable = isMaximal;
     };
 
     session = {

docs/default.nix

@@ -12,6 +12,7 @@
     inherit
       (
         (lib.evalModules {
+          specialArgs = {inherit inputs;};
           modules =
             import ../modules/modules.nix {
               inherit lib pkgs;

docs/manual/configuring.md

@@ -1,5 +1,15 @@
 # Configuring nvf {#ch-configuring}
 
+[helpful tips section]: #ch-helpful-tips
+
+nvf allows for _very_ extensive configuration in Neovim through the Nix module
+interface. The below chapters describe several of the options exposed in nvf for
+your convenience. You might also be interested in the [helpful tips section] for
+more advanced or unusual configuration options supported by nvf.
+
+Note that this section does not cover module _options_. For an overview of all
+module options provided by nvf, please visit the [appendix](/options.html)
+
 ```{=include=} chapters
 configuring/custom-package.md
 configuring/custom-plugins.md
@@ -7,4 +17,5 @@ configuring/overriding-plugins.md
 configuring/languages.md
 configuring/dags.md
 configuring/dag-entries.md
+configuring/autocmds.md
 ```

docs/manual/configuring/autocmds.md

@@ -0,0 +1,119 @@
+# Autocommands and Autogroups {#ch-autocmds-augroups}
+
+This module allows you to declaratively configure Neovim autocommands and
+autogroups within your Nix configuration.
+
+## Autogroups (`vim.augroups`) {#sec-vim-augroups}
+
+Autogroups (`augroup`) organize related autocommands. This allows them to be
+managed collectively, such as clearing them all at once to prevent duplicates.
+Each entry in the list is a submodule with the following options:
+
+| Option   | Type   | Default | Description                                                                                          | Example           |
+| :------- | :----- | :------ | :--------------------------------------------------------------------------------------------------- | :---------------- |
+| `enable` | `bool` | `true`  | Enables or disables this autogroup definition.                                                       | `true`            |
+| `name`   | `str`  | _None_  | **Required.** The unique name for the autogroup.                                                     | `"MyFormatGroup"` |
+| `clear`  | `bool` | `true`  | Clears any existing autocommands within this group before adding new ones defined in `vim.autocmds`. | `true`            |
+
+**Example:**
+
+```nix
+{
+  vim.augroups = [
+    {
+      name = "MyCustomAuGroup";
+      clear = true; # Clear previous autocommands in this group on reload
+    }
+    {
+      name = "Formatting";
+      # clear defaults to true
+    }
+  ];
+}
+```
+
+## Autocommands (`vim.autocmds`) {#sec-vim-autocmds}
+
+Autocommands (`autocmd`) trigger actions based on events happening within Neovim
+(e.g., saving a file, entering a buffer). Each entry in the list is a submodule
+with the following options:
+
+| Option     | Type                  | Default | Description                                                                                                                                                                      | Example                                                          |
+| :--------- | :-------------------- | :------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------- |
+| `enable`   | `bool`                | `true`  | Enables or disables this autocommand definition.                                                                                                                                 | `true`                                                           |
+| `event`    | `nullOr (listOf str)` | `null`  | **Required.** List of Neovim events that trigger this autocommand (e.g., `BufWritePre`, `FileType`).                                                                             | `[ "BufWritePre" ]`                                              |
+| `pattern`  | `nullOr (listOf str)` | `null`  | List of file patterns (globs) to match against (e.g., `*.py`, `*`). If `null`, matches all files for the given event.                                                            | `[ "*.lua", "*.nix" ]`                                           |
+| `callback` | `nullOr luaInline`    | `null`  | A Lua function to execute when the event triggers. Use `lib.nvim.types.luaInline` or `lib.options.literalExpression "mkLuaInline '''...'''"`. **Cannot be used with `command`.** | `lib.nvim.types.luaInline "function() print('File saved!') end"` |
+| `command`  | `nullOr str`          | `null`  | A Vimscript command to execute when the event triggers. **Cannot be used with `callback`.**                                                                                      | `"echo 'File saved!'"`                                           |
+| `group`    | `nullOr str`          | `null`  | The name of an `augroup` (defined in `vim.augroups`) to associate this autocommand with.                                                                                         | `"MyCustomAuGroup"`                                              |
+| `desc`     | `nullOr str`          | `null`  | A description for the autocommand (useful for introspection).                                                                                                                    | `"Format buffer on save"`                                        |
+| `once`     | `bool`                | `false` | If `true`, the autocommand runs only once and then automatically removes itself.                                                                                                 | `false`                                                          |
+| `nested`   | `bool`                | `false` | If `true`, allows this autocommand to trigger other autocommands.                                                                                                                | `false`                                                          |
+
+:::{.warning}
+
+You cannot define both `callback` (for Lua functions) and `command` (for
+Vimscript) for the same autocommand. Choose one.
+
+:::
+
+**Examples:**
+
+```nix
+{ lib, ... }:
+{
+  vim.augroups = [ { name = "UserSetup"; } ];
+
+  vim.autocmds = [
+    # Example 1: Using a Lua callback
+    {
+      event = [ "BufWritePost" ];
+      pattern = [ "*.lua" ];
+      group = "UserSetup";
+      desc = "Notify after saving Lua file";
+      callback = lib.nvim.types.luaInline ''
+        function()
+          vim.notify("Lua file saved!", vim.log.levels.INFO)
+        end
+      '';
+    }
+
+    # Example 2: Using a Vim command
+    {
+      event = [ "FileType" ];
+      pattern = [ "markdown" ];
+      group = "UserSetup";
+      desc = "Set spellcheck for Markdown";
+      command = "setlocal spell";
+    }
+
+    # Example 3: Autocommand without a specific group
+    {
+      event = [ "BufEnter" ];
+      pattern = [ "*.log" ];
+      desc = "Disable line numbers in log files";
+      command = "setlocal nonumber";
+      # No 'group' specified
+    }
+
+    # Example 4: Using Lua for callback
+    {
+      event = [ "BufWinEnter" ];
+      pattern = [ "*" ];
+      desc = "Simple greeting on entering a buffer window";
+      callback = lib.generators.mkLuaInline ''
+        function(args)
+          print("Entered buffer: " .. args.buf)
+        end
+      '';
+      
+      # Run only once per session trigger
+      once = true; 
+    }
+  ];
+}
+```
+
+These definitions are automatically translated into the necessary Lua code to
+configure `vim.api.nvim_create_augroup` and `vim.api.nvim_create_autocmd` when
+Neovim starts.

docs/manual/configuring/custom-package.md

@@ -1,12 +1,12 @@
 # Custom Neovim Package {#ch-custom-package}
 
 As of v0.5, you may now specify the Neovim package that will be wrapped with
-your configuration. This is done with the `vim.package` option.
+your configuration. This is done with the [](#opt-vim.package) option.
 
 ```nix
 {inputs, pkgs, ...}: {
   # using the neovim-nightly overlay
-  vim.package = inputs.neovim-overlay.packages.${pkgs.system}.neovim;
+  vim.package = inputs.neovim-overlay.packages.${pkgs.stdenv.system}.neovim;
 }
 ```
 

docs/manual/configuring/custom-plugins.md

@@ -1,22 +1,33 @@
 # Custom Plugins {#ch-custom-plugins}
 
-**nvf**, by default, exposes a wide variety of plugins as module options for
-your convenience and bundles necessary dependencies into **nvf**'s runtime. In
-case a plugin is not available in **nvf**, you may consider making a pull
-request to **nvf** to include it as a module or you may add it to your
-configuration locally.
+**nvf** exposes a very wide variety of plugins by default, which are consumed by
+module options. This is done for your convenience, and to bundle all necessary
+dependencies into **nvf**'s runtime with full control of versioning, testing and
+dependencies. In the case a plugin you need is _not_ available, you may consider
+making a pull request to add the package you're looking for, or you may add it
+to your configuration locally. The below section describes how new plugins may
+be added to the user's configuration.
 
 ## Adding Plugins {#ch-adding-plugins}
 
-There are multiple ways of adding custom plugins to your **nvf** configuration.
+Per **nvf**'s design choices, there are several ways of adding custom plugins to
+your configuration as you need them. As we aim for extensive configuration, it
+is possible to add custom plugins (from nixpkgs, pinning tools, flake inputs,
+etc.) to your Neovim configuration before they are even implemented in **nvf**
+as a module.
 
-You can use custom plugins, before they are implemented in the flake. To add a
-plugin to the runtime, you need to add it to the [](#opt-vim.startPlugins) list
-in your configuration.
+:::{.info}
 
-Adding a plugin to `startPlugins` will not allow you to configure the plugin
-that you have added, but **nvf** provides multiple ways of configuring any custom
-plugins that you might have added to your configuration.
+To add a plugin to your runtime, you will need to add it to
+[](#opt-vim.startPlugins) list in your configuration. This is akin to cloning a
+plugin to `~/.config/nvim`, but they are only ever placed in the Nix store and
+never exposed to the outside world for purity and full isolation.
+
+:::
+
+As you would configure a cloned plugin, you must configure the new plugins that
+you've added to `startPlugins.` **nvf** provides multiple ways of configuring
+any custom plugins that you might have added to your configuration.
 
 ```{=include=} sections
 custom-plugins/configuring.md

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

@@ -1,13 +1,20 @@
 # Configuring {#sec-configuring-plugins}
 
 Just making the plugin to your Neovim configuration available might not always
-be enough. In that case, you can write custom lua config using either
-`config.vim.lazy.plugins.*.setupOpts` `config.vim.extraPlugins.*.setup` or
-`config.vim.luaConfigRC`.
+be enough., for example, if the plugin requires a setup table. In that case, you
+can write custom Lua configuration using one of
 
-The first option uses an extended version of `lz.n`'s PluginSpec. `setupModule`
-and `setupOpt` can be used if the plugin uses a `require('module').setup(...)`
-pattern. Otherwise, the `before` and `after` hooks should do what you need.
+- `config.vim.lazy.plugins.*.setupOpts`
+- `config.vim.extraPlugins.*.setup`
+- `config.vim.luaConfigRC`.
+
+## Lazy Plugins {#ch-vim-lazy-plugins}
+
+`config.vim.lazy.plugins.*.setupOpts` is useful for lazy-loading plugins, and
+uses an extended version of `lz.n's` `PluginSpec` to expose a familiar
+interface. `setupModule` and `setupOpt` can be used if the plugin uses a
+`require('module').setup(...)` pattern. Otherwise, the `before` and `after`
+hooks should do what you need.
 
 ```nix
 {
@@ -25,50 +32,61 @@ pattern. Otherwise, the `before` and `after` hooks should do what you need.
 }
 ```
 
-The second option uses an attribute set, which maps DAG section names to a
+## Standard API {#ch-vim-extra-plugins}
+
+`vim.extraPlugins` uses an attribute set, which maps DAG section names to a
 custom type, which has the fields `package`, `after`, `setup`. They allow you to
 set the package of the plugin, the sections its setup code should be after (note
 that the `extraPlugins` option has its own DAG scope), and the its setup code
 respectively. For example:
 
 ```nix
-config.vim.extraPlugins = with pkgs.vimPlugins; {
-  aerial = {
-    package = aerial-nvim;
-    setup = "require('aerial').setup {}";
-  };
+{pkgs, ...}: {
+  config.vim.extraPlugins = {
+    aerial = {
+      package = pkgs.vimPlugins.aerial-nvim;
+      setup = "require('aerial').setup {}";
+    };
 
-  harpoon = {
-    package = harpoon;
-    setup = "require('harpoon').setup {}";
-    after = ["aerial"]; # place harpoon configuration after aerial
+    harpoon = {
+      package = pkgs.vimPlugins.harpoon;
+      setup = "require('harpoon').setup {}";
+      after = ["aerial"]; # place harpoon configuration after aerial
+    };
   };
 }
 ```
 
-The third option also uses an attribute set, but this one is resolved as a DAG
+### Setup using luaConfigRC {#setup-using-luaconfigrc}
+
+`vim.luaConfigRC` also uses an attribute set, but this one is resolved as a DAG
 directly. The attribute names denote the section names, and the values lua code.
 For example:
 
 ```nix
 {
-  # this will create an "aquarium" section in your init.lua with the contents of your custom config
-  # which will be *appended* to the rest of your configuration, inside your init.vim
+  # This will create a section called "aquarium" in the 'init.lua' with the
+  # contents of your custom configuration. By default 'entryAnywhere' is implied
+  # in DAGs, so this will be inserted to an arbitrary position. In the case you 
+  # wish to control the position of this section with more precision, please
+  # look into the DAGs section of the manual.
   config.vim.luaConfigRC.aquarium = "vim.cmd('colorscheme aquiarum')";
 }
 ```
 
 <!-- deno-fmt-ignore-start -->
+[DAG system]: #ch-using-dags
+[DAG section]: #ch-dag-entries
 
 ::: {.note}
-One of the greatest strengths of nvf is the ability to order
-snippets of configuration via the DAG system. It will allow specifying positions
-of individual sections of configuration as needed. nvf provides helper functions
+One of the **greatest strengths** of **nvf** is the ability to order
+configuration snippets precisely using the [DAG system]. DAGs
+are a very powerful mechanism that allows specifying positions
+of individual sections of configuration as needed. We provide helper functions
 in the extended library, usually under `inputs.nvf.lib.nvim.dag` that you may
 use.
 
-Please refer to the [DAG section](#ch-dag-entries) in the nvf manual
+Please refer to the [DAG section] in the nvf manual
 to find out more about the DAG system.
 :::
-
 <!-- deno-fmt-ignore-end -->

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

@@ -1,7 +1,8 @@
 # Lazy Method {#sec-lazy-method}
 
-As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
-`lz.n` and `lzn-auto-require`.
+As of version **0.7**, an API is exposed to allow configuring lazy-loaded
+plugins via `lz.n` and `lzn-auto-require`. Below is a comprehensive example of
+how it may be loaded to lazy-load an arbitrary plugin.
 
 ```nix
 {
@@ -41,7 +42,8 @@ As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
 
 ## LazyFile event {#sec-lazyfile-event}
 
-You can use the `LazyFile` user event to load a plugin when a file is opened:
+**nvf** re-implements `LazyFile` as a familiar user event to load a plugin when
+a file is opened:
 
 ```nix
 {
@@ -55,5 +57,6 @@ You can use the `LazyFile` user event to load a plugin when a file is opened:
 }
 ```
 
-You can consider `LazyFile` as an alias to
-`["BufReadPost" "BufNewFile" "BufWritePre"]`
+You can consider the `LazyFile` event as an alias to the combination of
+`"BufReadPost"`, `"BufNewFile"` and `"BufWritePre"`, i.e., a list containing all
+three of those events: `["BufReadPost" "BufNewFile" "BufWritePre"]`

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

@@ -1,26 +1,31 @@
 # Legacy Method {#sec-legacy-method}
 
-Prior to version v0.5, the method of adding new plugins was adding the plugin
-package to `vim.startPlugins` and add its configuration as a DAG under one of
-`vim.configRC` or `vim.luaConfigRC`. Users who have not yet updated to 0.5, or
-prefer a more hands-on approach may use the old method where the load order of
-the plugins is determined by DAGs.
+Prior to version **0.5**, the method of adding new plugins was adding the plugin
+package to [](#opt-vim.startPlugins) and adding its configuration as a DAG under
+one of `vim.configRC` or [](#opt-vim.luaConfigRC). While `configRC` has been
+deprecated, users who have not yet updated to 0.5 or those who prefer a more
+hands-on approach may choose to use the old method where the load order of the
+plugins is explicitly determined by DAGs without internal abstractions.
 
-## Adding plugins {#sec-adding-plugins}
+## Adding New Plugins {#sec-adding-new-plugins}
 
-To add a plugin not available in nvf as a module to your configuration, you may
-add it to [](#opt-vim.startPlugins) in order to make it available to Neovim at
-runtime.
+To add a plugin not available in **nvf** as a module to your configuration using
+the legacy method, you must add it to [](#opt-vim.startPlugins) in order to make
+it available to Neovim at runtime.
 
 ```nix
 {pkgs, ...}: {
   # Add a Neovim plugin from Nixpkgs to the runtime.
+  # This does not need to come explicitly from packages. 'vim.startPlugins'
+  # takes a list of *string* (to load internal plugins) or *package* to load
+  # a Neovim package from any source.
   vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];
 }
 ```
 
-And to configure the added plugin, you can use the `luaConfigRC` option to
-provide configuration as a DAG using the **nvf** extended library.
+Once the package is available in Neovim's runtime, you may use the `luaConfigRC`
+option to provide configuration as a DAG using the **nvf** extended library in
+order to configure the added plugin,
 
 ```nix
 {inputs, ...}: let
@@ -29,6 +34,8 @@ provide configuration as a DAG using the **nvf** extended library.
   # to specialArgs, the 'inputs' prefix may be omitted.
   inherit (inputs.nvf.lib.nvim.dag) entryAnywhere;
 in {
+  # luaConfigRC takes Lua configuration verbatim and inserts it at an arbitrary
+  # position by default or if 'entryAnywhere' is used.
   vim.luaConfigRC.aerial-nvim= entryAnywhere ''
     require('aerial').setup {
       -- your configuration here

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

@@ -1,14 +1,15 @@
 # Non-lazy Method {#sec-non-lazy-method}
 
-As of version **0.5**, we have a more extensive API for configuring plugins,
-under `vim.extraPlugins`. Instead of using DAGs exposed by the library, you may
-use the extra plugin module as follows:
+As of version **0.5**, we have a more extensive API for configuring plugins that
+should be preferred over the legacy method. This API is available as
+[](#opt-vim.extraPlugins). Instead of using DAGs exposed by the library
+_directly_, you may use the extra plugin module as follows:
 
 ```nix
-{
-  config.vim.extraPlugins = with pkgs.vimPlugins; {
+{pkgs, ...}: {
+  config.vim.extraPlugins = {
     aerial = {
-      package = aerial-nvim;
+      package = pkgs.vimPlugins.aerial-nvim;
       setup = ''
         require('aerial').setup {
           -- some lua configuration here
@@ -17,10 +18,12 @@ use the extra plugin module as follows:
     };
 
     harpoon = {
-      package = harpoon;
+      package = pkgs.vimPlugins.harpoon;
       setup = "require('harpoon').setup {}";
       after = ["aerial"];
     };
   };
 }
 ```
+
+This provides a level of abstraction over the DAG system for faster iteration.

docs/manual/configuring/languages/lsp.md

@@ -1,17 +1,22 @@
 # LSP Custom Packages/Command {#sec-languages-custom-lsp-packages}
 
-In any of the `opt.languages.<language>.lsp.package` options you can provide
-your own LSP package, or provide the command to launch the language server, as a
-list of strings. You can use this to skip automatic installation of a language
-server, and instead use the one found in your `$PATH` during runtime, for
-example:
+One of the strengths of **nvf** is convenient aliases to quickly configure LSP
+servers through the Nix module system. By default the LSP packages for relevant
+language modules will be pulled into the closure. If this is not desirable, you
+may provide **a custom LSP package** (e.g., a Bash script that calls a command)
+or **a list of strings** to be interpreted as the command to launch the language
+server. By using a list of strings, you can use this to skip automatic
+installation of a language server, and instead use the one found in your `$PATH`
+during runtime, for example:
 
 ```nix
 vim.languages.java = {
   lsp = {
     enable = true;
-    # this expects jdt-language-server to be in your PATH
-    # or in `vim.extraPackages`
+
+    # This expects 'jdt-language-server' to be in your PATH or in
+    # 'vim.extraPackages.' There are no additional checks performed to see
+    # if the command provided is valid.
     package = ["jdt-language-server" "-data" "~/.cache/jdtls/workspace"];
   };
 }

docs/manual/default-configs.md

@@ -1,10 +0,0 @@
-# Default Configs {#ch-default-configs}
-
-While you can configure **nvf** yourself using the builder, you can also use the
-pre-built configs that are available. Here are a few default configurations you
-can use.
-
-```{=include=} chapters
-default-configs/maximal.md
-default-configs/nix.md
-```

docs/manual/default-configs/maximal.md

@@ -1,11 +0,0 @@
-# Maximal {#sec-default-maximal}
-
-```bash
-$ nix run github:notashelf/nvf#maximal -- test.nix
-```
-
-It is the same fully configured Neovim as with the [Nix](#sec-default-nix)
-configuration, but with every supported language enabled.
-
-::: {.note} Running the maximal config will download _a lot_ of packages as it
-is downloading language servers, formatters, and more. :::

docs/manual/default-configs/nix.md

@@ -1,9 +0,0 @@
-# Nix {#sec-default-nix}
-
-```bash
-$ nix run github:notashelf/nvf#nix test.nix
-```
-
-Enables all the of Neovim plugins, with language support for specifically Nix.
-This lets you see what a fully configured neovim setup looks like without
-downloading a whole bunch of language servers and associated tools.

docs/manual/installation/custom-configuration.md

@@ -39,7 +39,7 @@ An example flake that exposes your custom Neovim configuration might look like
                 theme.enable = true;
 
                 # Enable Treesitter
-                tree-sitter.enable = true;
+                treesitter.enable = true;
 
                 # Other options will go here. Refer to the config
                 # reference in Appendix B of the nvf manual.

docs/manual/manual.md

@@ -8,7 +8,6 @@ try-it-out.md
 ```
 
 ```{=include=} parts
-default-configs.md
 installation.md
 configuring.md
 tips.md

docs/manual/tips.md

@@ -1,7 +1,14 @@
 # Helpful Tips {#ch-helpful-tips}
 
+This section provides helpful tips that may be considered "unorthodox" or "too
+advanced" for some users. We will cover basic debugging steps, offline
+documentation, configuring **nvf** with pure Lua and using custom plugin sources
+in **nvf** in this section. For general configuration tips, please see previous
+chapters.
+
 ```{=include=} chapters
-tips/pure-lua-config.md
 tips/debugging-nvf.md
 tips/offline-docs.md
+tips/pure-lua-config.md
+tips/plugin-sources.md
 ```

docs/manual/tips/plugin-sources.md

@@ -0,0 +1,131 @@
+# Adding Plugins From Different Sources {#sec-plugin-sources}
+
+**nvf** attempts to avoid depending on Nixpkgs for Neovim plugins. For the most
+part, this is accomplished by defining each plugin's source and building them
+from source.
+
+[npins]: https://github.com/andir/npins
+
+To define plugin sources, we use [npins] and pin each plugin source using
+builtin fetchers. You are not bound by this restriction. In your own
+configuration, any kind of fetcher or plugin source is fine.
+
+## Nixpkgs & Friends {#ch-plugins-from-nixpkgs}
+
+`vim.startPlugins` and `vim.optPlugins` options take either a **string**, in
+which case a plugin from nvf's internal plugins registry will be used, or a
+**package**. If your plugin does not require any setup, or ordering for it s
+configuration, then it is possible to add it to `vim.startPlugins` to load it on
+startup.
+
+```nix
+{pkgs, ...}: {
+  # Aerial does require some setup. In the case you pass a plugin that *does*
+  # require manual setup, then you must also call the setup function.
+  vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];
+}
+```
+
+[`vim.extraPlugins`]: https://notashelf.github.io/nvf/options.html#opt-vim.extraPlugins
+
+This will fetch aerial.nvim from nixpkgs, and add it to Neovim's runtime path to
+be loaded manually. Although for plugins that require manual setup, you are
+encouraged to use [`vim.extraPlugins`].
+
+```nix
+{
+  vim.extraPlugins = {
+    aerial = {
+      package = pkgs.vimPlugins.aerial-nvim;
+      setup = "require('aerial').setup {}";
+    };
+  };
+}
+```
+
+[custom plugins section]: https://notashelf.github.io/nvf/index.xhtml#ch-custom-plugins
+
+More details on the extraPlugins API is documented in the
+[custom plugins section].
+
+## Building Your Own Plugins {#ch-plugins-from-source}
+
+In the case a plugin is not available in Nixpkgs, or the Nixpkgs package is
+outdated (or, more likely, broken) it is possible to build the plugins from
+source using a tool, such as [npins]. You may also use your _flake inputs_ as
+sources.
+
+Example using plugin inputs:
+
+```nix
+{
+  # In your flake.nix
+  inputs = {
+    aerial-nvim = {
+      url = "github:stevearc/aerial.nvim"
+      flake = false;
+    };
+  };
+
+  # Make sure that 'inputs' is properly propagated into Nvf, for example, through
+  # specialArgs.
+  outputs = { ... };
+}
+```
+
+In the case, you may use the input directly for the plugin's source attribute in
+`buildVimPlugin`.
+
+```nix
+# Make sure that 'inputs' is properly propagated! It will be missing otherwise
+# and the resulting errors might be too obscure.
+{inputs, ...}: let
+  aerial-from-source = pkgs.vimUtils.buildVimPlugin {
+      name = "aerial-nvim";
+      src = inputs.aerial-nvim;
+    };
+in {
+  vim.extraPlugins = {
+    aerial = {
+      package = aerial-from-source;
+      setup = "require('aerial').setup {}";
+    };
+  };
+}
+```
+
+Alternatively, if you do not want to keep track of the source using flake inputs
+or npins, you may call `fetchFromGitHub` (or other fetchers) directly. An
+example would look like this.
+
+```nix
+regexplainer = buildVimPlugin {
+  name = "nvim-regexplainer";
+  src = fetchFromGitHub {
+    owner = "bennypowers";
+    repo = "nvim-regexplainer";
+    rev = "4250c8f3c1307876384e70eeedde5149249e154f";
+    hash = "sha256-15DLbKtOgUPq4DcF71jFYu31faDn52k3P1x47GL3+b0=";
+  };
+
+  # The 'buildVimPlugin' imposes some "require checks" on all plugins build from
+  # source. Failing tests, if they are not relevant, can be disabled using the
+  # 'nvimSkipModule' argument to the 'buildVimPlugin' function.
+  nvimSkipModule = [
+    "regexplainer"
+    "regexplainer.buffers.init"
+    "regexplainer.buffers.popup"
+    "regexplainer.buffers.register"
+    "regexplainer.buffers.shared"
+    "regexplainer.buffers.split"
+    "regexplainer.component.descriptions"
+    "regexplainer.component.init"
+    "regexplainer.renderers.narrative.init"
+    "regexplainer.renderers.narrative.narrative"
+    "regexplainer.renderers.init"
+    "regexplainer.utils.defer"
+    "regexplainer.utils.init"
+    "regexplainer.utils.treesitter"
+  ];
+}
+```

docs/manual/try-it-out.md

@@ -26,7 +26,12 @@ $ nix run github:notashelf/nvf#nix
 $ nix run github:notashelf/nvf#maximal
 ```
 
-### Available Configs {#sec-available-configs}
+### Available Configurations {#sec-available-configs}
+
+::: {.info}
+
+The below configurations are provided for demonstration purposes, and are
+**not** designed to be installed as is. You may
 
 #### Nix {#sec-configs-nix}
 
@@ -34,15 +39,32 @@ $ nix run github:notashelf/nvf#maximal
 a set of visual and functional plugins. By running `nix run .#`, which is the
 default package, you will build Neovim with this config.
 
+```bash
+$ nix run github:notashelf/nvf#nix test.nix
+```
+
+This command will start Neovim with some opinionated plugin configurations, and
+is designed specifically for Nix. the `nix` configuration lets you see how a
+fully configured Neovim setup _might_ look like without downloading too many
+packages or shell utilities.
+
 #### Maximal {#sec-configs-maximal}
 
 `Maximal` is the ultimate configuration that will enable support for more
 commonly used language as well as additional complementary plugins. Keep in
 mind, however, that this will pull a lot of dependencies.
 
-::: {.tip}
+```bash
+$ nix run github:notashelf/nvf#maximal -- test.nix
+```
 
-You are _strongly_ recommended to use the binary cache if you would like to try
-the Maximal configuration.
+It uses the same configuration template with the [Nix](#sec-configs-nix)
+configuration, but supports many more languages, and enables more utility,
+companion or fun plugins.
+
+::: {.warning}
+
+Running the maximal config will download _a lot_ of packages as it is
+downloading language servers, formatters, and more.
 
 :::

docs/release-notes/rl-0.3.md

@@ -50,9 +50,8 @@ soon.
 
 - A new section has been added for language support: `vim.languages.<language>`.
 
-  - The options [](#opt-vim.languages.enableLSP),
-    [](#opt-vim.languages.enableTreesitter), etc. will enable the respective
-    section for all languages that have been enabled.
+  - The options `enableLSP` [](#opt-vim.languages.enableTreesitter), etc. will
+    enable the respective section for all languages that have been enabled.
   - All LSP languages have been moved here
   - `plantuml` and `markdown` have been moved here
   - A new section has been added for `html`. The old

docs/release-notes/rl-0.5.md

@@ -91,7 +91,7 @@ Release notes for release 0.5
 - Updated indent-blankine.nvim to v3 - this comes with a few option changes,
   which will be migrated with `renamedOptionModule`
 
-[jacekpoz](https://jacekpoz.pl):
+[poz](https://poz.pet):
 
 - Fixed scrollOffset not being used
 

docs/release-notes/rl-0.6.md

@@ -69,7 +69,7 @@ vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap =
 
 - Added rose-pine theme.
 
-[jacekpoz](https://jacekpoz.pl):
+[poz](https://poz.pet):
 
 - Added `vim.autocomplete.alwaysComplete`. Allows users to have the autocomplete
   window popup only when manually activated.

docs/release-notes/rl-0.7.md

@@ -162,7 +162,7 @@ The changes are, in no particular order:
 - Add [lz.n] support and lazy-load some builtin plugins.
 - Add simpler helper functions for making keymaps
 
-[jacekpoz](https://jacekpoz.pl):
+[poz](https://poz.pet):
 
 [ocaml-lsp]: https://github.com/ocaml/ocaml-lsp
 [new-file-template.nvim]: https://github.com/otavioschwanck/new-file-template.nvim

docs/release-notes/rl-0.8.md

@@ -19,6 +19,11 @@
   unavailable as they have been refactored out of the main none-ls repository
   upstream.
 
+- `vim.useSystemClipboard` has been deprecated as a part of removing most
+  top-level convenience options, and should instead be configured in the new
+  module interface. You may set [](#opt-vim.clipboard.registers) appropriately
+  to configure Neovim to use the system clipboard.
+
 [NotAShelf](https://github.com/notashelf):
 
 [typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
@@ -91,6 +96,11 @@
   options for `vim.diagnostic.config()` can now be customized through the
   [](#opt-vim.diagnostics.config) in nvf.
 
+- Add `vim.clipboard` module for easily managing Neovim clipboard providers and
+  relevant packages in a simple UI.
+  - This deprecates `vim.useSystemClipboard` as well, see breaking changes
+    section above for migration options.
+
 [amadaluzia](https://github.com/amadaluzia):
 
 [haskell-tools.nvim]: https://github.com/MrcJkb/haskell-tools.nvim
@@ -109,6 +119,7 @@
 - Add tsx support in conform and lint
 - Moved code setting `additionalRuntimePaths` and `enableLuaLoader` out of
   `luaConfigPre`'s default to prevent being overridden
+- Use conform over custom autocmds for LSP format on save
 
 [diniamo](https://github.com/diniamo):
 
@@ -278,6 +289,7 @@
 [BANanaD3V](https://github.com/BANanaD3V):
 
 - `alpha` is now configured with nix.
+- Add `markview-nvim` markdown renderer.
 
 [viicslen](https://github.com/viicslen):
 
@@ -296,6 +308,7 @@
   `vim.diagnostics.nvim-lint.linters.*.required_files`.
 - Add global function `nvf_lint` under
   `vim.diagnostics.nvim-lint.lint_function`.
+- Deprecate `vim.scrollOffset` in favor of `vim.options.scrolloff`.
 
 [Sc3l3t0n](https://github.com/Sc3l3t0n):
 
@@ -312,6 +325,8 @@
 - 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`.
+- Add support for `vim.lsp.formatOnSave` and
+  `vim.lsp.mappings.toggleFormatOnSave`
 
 [tebuevd](https://github.com/tebuevd):
 
@@ -325,11 +340,15 @@
 
 [flash.nvim]: https://github.com/folke/flash.nvim
 [gitlinker.nvim]: https://github.com/linrongbin16/gitlinker.nvim
+[nvim-treesitter-textobjects]: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
 
 - 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`
+- Add [nvim-treesitter-textobjects] plugin to `vim.treesitter.textobjects`
+- Default to disabling Conform for Rust if rust-analyzer is used
+  - To force using Conform, set `languages.rust.format.enable = true`.
 
 [rrvsh](https://github.com/rrvsh):
 
@@ -351,4 +370,60 @@
 
 [aionoid](https://github.com/aionoid):
 
+[avante-nvim]: https://github.com/yetone/avante.nvim
+
 - Fix [render-markdown.nvim] file_types option type to list, to accept merging.
+- Add [avante.nvim] plugin under `vim.assistant.avante-nvim`.
+
+[poz](https://poz.pet):
+
+- Fix gitsigns null-ls issue.
+
+[Haskex](https://github.com/haskex):
+
+[Hardtime.nvim]: https://github.com/m4xshen/hardtime.nvim
+
+- Add Plugin [Hardtime.nvim] under `vim.binds.hardtime-nvim` with `enable` and
+  `setupOpts` options
+
+[taylrfnt](https://github.com/taylrfnt):
+
+[nvim-tree](https://github.com/nvim-tree/nvim-tree.lua):
+
+- Add missing `right_align` option for existing `renderer.icons` options.
+- Add missing `render.icons` options (`hidden_placement`,
+  `diagnostics_placement`, and `bookmarks_placement`).
+
+[cramt](https://github.com/cramt):
+
+- Add `rubylsp` option in `vim.languages.ruby.lsp.server` to use shopify's
+  ruby-lsp language server
+
+[Haskex](https://github.com/haskex):
+
+[solarized-osaka.nvim]: https://github.com/craftzdog/solarized-osaka.nvim
+
+- Add [solarized-osaka.nvim] theme
+
+[img-clip.nvim]: https://github.com/hakonharnes/img-clip.nvim
+
+- Add [img-clip.nvim] plugin in `vim.utility.images.img-clip` with `enable` and
+  `setupOpts`
+- Add `vim.utility.images.img-clip.enable = isMaximal` in configuration.nix
+
+[anil9](https://github.com/anil9):
+
+[clojure-lsp]: https://github.com/clojure-lsp/clojure-lsp
+[conjure]: https://github.com/Olical/conjure
+
+- Add Clojure support under `vim.languages.clojure` using [clojure-lsp]
+- Add code evaluation environment [conjure] under `vim.repl.conjure`
+
+[CallumGilly](https://github.com/CallumGilly):
+
+- Add missing `transparent` option for existing
+  [onedark.nvim](https://github.com/navarasu/onedark.nvim) theme.
+  
+[theutz](https://github.com/theutz):
+
+- Added "auto" flavour for catppuccin theme

flake.lock

@@ -38,11 +38,11 @@
     },
     "mnw": {
       "locked": {
-        "lastModified": 1745705214,
-        "narHash": "sha256-XGfaHbFI4vvDuaoVO3IFYZKezXIO8rhUaMCGcjY71Ac=",
+        "lastModified": 1748278309,
+        "narHash": "sha256-JCeiMrUhFku44kfKsgiD9Ibzho4MblBD2WmOQYsQyTY=",
         "owner": "Gerg-L",
         "repo": "mnw",
-        "rev": "c1f4587db4c53dcefa432c46c7a899a116d8e924",
+        "rev": "486a17ba1279ab2357cae8ff66b309db622f8831",
         "type": "github"
       },
       "original": {
@@ -77,11 +77,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1745377448,
-        "narHash": "sha256-jhZDfXVKdD7TSEGgzFJQvEEZ2K65UMiqW5YJ2aIqxMA=",
+        "lastModified": 1748217807,
+        "narHash": "sha256-P3u2PXxMlo49PutQLnk2PhI/imC69hFl1yY4aT5Nax8=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "507b63021ada5fee621b6ca371c4fca9ca46f52c",
+        "rev": "3108eaa516ae22c2360928589731a4f1581526ef",
         "type": "github"
       },
       "original": {

flake.nix

@@ -18,10 +18,7 @@
       systems = import inputs.systems;
       imports = [
         ./flake/templates
-
         ./flake/apps.nix
-        ./flake/legacyPackages.nix
-        ./flake/overlays.nix
         ./flake/packages.nix
         ./flake/develop.nix
       ];

flake/avante-nvim/default.nix

@@ -0,0 +1,80 @@
+{
+  nix-update-script,
+  openssl,
+  pkg-config,
+  rustPlatform,
+  stdenv,
+  vimPlugins,
+  vimUtils,
+  makeWrapper,
+  pkgs,
+  version,
+  src,
+  pins,
+}: let
+  inherit version src;
+  avante-nvim-lib = rustPlatform.buildRustPackage {
+    pname = "avante-nvim-lib";
+    inherit version src;
+
+    useFetchCargoVendor = true;
+    cargoHash = "sha256-pmnMoNdaIR0i+4kwW3cf01vDQo39QakTCEG9AXA86ck=";
+
+    nativeBuildInputs = [
+      pkg-config
+      makeWrapper
+      pkgs.perl
+    ];
+
+    buildInputs = [
+      openssl
+    ];
+
+    buildFeatures = ["luajit"];
+
+    checkFlags = [
+      # Disabled because they access the network.
+      "--skip=test_hf"
+      "--skip=test_public_url"
+      "--skip=test_roundtrip"
+      "--skip=test_fetch_md"
+    ];
+  };
+in
+  vimUtils.buildVimPlugin {
+    pname = "avante-nvim";
+    inherit version src;
+
+    dependencies =
+      [vimPlugins.nvim-treesitter]
+      ++ (builtins.map (name: let
+        pin = pins.${name};
+      in
+        pkgs.fetchFromGitHub {
+          inherit (pin.repository) owner repo;
+          rev = pin.revision;
+          sha256 = pin.hash;
+        }) [
+        "dressing-nvim"
+        "plenary-nvim"
+        "nui-nvim"
+      ]);
+
+    postInstall = let
+      ext = stdenv.hostPlatform.extensions.sharedLibrary;
+    in ''
+      mkdir -p $out/build
+      ln -s ${avante-nvim-lib}/lib/libavante_repo_map${ext} $out/build/avante_repo_map${ext}
+      ln -s ${avante-nvim-lib}/lib/libavante_templates${ext} $out/build/avante_templates${ext}
+      ln -s ${avante-nvim-lib}/lib/libavante_tokenizers${ext} $out/build/avante_tokenizers${ext}
+      ln -s ${avante-nvim-lib}/lib/libavante_html2md${ext} $out/build/avante_html2md${ext}
+    '';
+
+    nvimSkipModules = [
+      # Requires setup with corresponding provider
+      "avante.providers.azure"
+      "avante.providers.copilot"
+      "avante.providers.vertex_claude"
+      "avante.providers.ollama"
+    ];
+  }

flake/blink/default.nix

@@ -0,0 +1,38 @@
+{
+  rustPlatform,
+  fetchFromGitHub,
+  writeShellScriptBin,
+}:
+rustPlatform.buildRustPackage (finalAttrs: {
+  pname = "blink-cmp";
+  version = "1.2.0";
+
+  src = fetchFromGitHub {
+    owner = "Saghen";
+    repo = "blink.cmp";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-bKe8SSg1HPWE7b4iRQJwiOVCrvvgttuHCOIa4U/38AY=";
+  };
+
+  forceShare = [
+    "man"
+    "info"
+  ];
+
+  postInstall = ''
+    cp -r {lua,plugin} "$out"
+    mkdir -p "$out/doc"
+    cp 'doc/'*'.txt' "$out/doc/"
+    mkdir -p "$out/target"
+    mv "$out/lib" "$out/target/release"
+  '';
+
+  cargoHash = "sha256-IDoDugtNWQovfSstbVMkKHLBXKa06lxRWmywu4zyS3M=";
+  useFetchCargoVendor = true;
+
+  nativeBuildInputs = [
+    (writeShellScriptBin "git" "exit 1")
+  ];
+
+  env.RUSTC_BOOTSTRAP = true;
+})

flake/develop.nix

@@ -3,13 +3,14 @@
     pkgs,
     config,
     self',
+    inputs',
     ...
   }: {
     devShells = {
       default = self'.devShells.lsp;
       nvim-nix = pkgs.mkShellNoCC {packages = [config.packages.nix];};
       lsp = pkgs.mkShellNoCC {
-        packages = with pkgs; [nil statix deadnix alejandra npins];
+        packages = with pkgs; [inputs'.nil.packages.default statix deadnix alejandra npins];
       };
     };
 

flake/legacyPackages.nix

@@ -1,35 +0,0 @@
-{
-  inputs,
-  self,
-  ...
-}: {
-  perSystem = {
-    system,
-    inputs',
-    ...
-  }: {
-    legacyPackages = import inputs.nixpkgs {
-      inherit system;
-      overlays = [
-        inputs.self.overlays.default
-
-        (final: prev: {
-          # Build nil from source to get most recent
-          # features as they are added.
-          nil = inputs'.nil.packages.default;
-          blink-cmp = let
-            pin = self.pins.blink-cmp;
-          in
-            final.callPackage ./legacyPackages/blink-cmp.nix {
-              inherit (pin) version;
-              src = prev.fetchFromGitHub {
-                inherit (pin.repository) owner repo;
-                rev = pin.revision;
-                sha256 = pin.hash;
-              };
-            };
-        })
-      ];
-    };
-  };
-}

flake/legacyPackages/blink-cmp.nix

@@ -1,37 +0,0 @@
-{
-  stdenv,
-  rustPlatform,
-  vimUtils,
-  gitMinimal,
-  src,
-  version,
-}: let
-  blink-fuzzy-lib = rustPlatform.buildRustPackage {
-    pname = "blink-fuzzy-lib";
-    inherit version src;
-
-    # TODO: remove this if plugin stops using nightly rust
-    env.RUSTC_BOOTSTRAP = true;
-
-    useFetchCargoVendor = true;
-    cargoHash = "sha256-MWElqh7ENJ6CbLOnvz0DsP5YYu+e+y12GSUOfW1IKGU=";
-
-    nativeBuildInputs = [gitMinimal];
-  };
-in
-  vimUtils.buildVimPlugin {
-    pname = "blink-cmp";
-    inherit version src;
-
-    # blink references a repro.lua which is placed outside the lua/ directory
-    doCheck = false;
-    preInstall = let
-      ext = stdenv.hostPlatform.extensions.sharedLibrary;
-    in ''
-      mkdir -p target/release
-      ln -s ${blink-fuzzy-lib}/lib/libblink_cmp_fuzzy${ext} target/release/libblink_cmp_fuzzy${ext}
-    '';
-
-    # Module for reproducing issues
-    nvimSkipModules = ["repro"];
-  }

flake/overlays.nix

@@ -1,19 +0,0 @@
-{
-  pkgs,
-  lib,
-  ...
-}: let
-  inherit (lib.nvim) neovimConfiguration;
-
-  buildPkg = pkgs: modules: (neovimConfiguration {inherit pkgs modules;}).neovim;
-
-  nixConfig = import ../configuration.nix false;
-  maximalConfig = import ../configuration.nix true;
-in {
-  flake.overlays.default = final: _prev: {
-    inherit neovimConfiguration;
-    neovim-nix = buildPkg final [nixConfig];
-    neovim-maximal = buildPkg final [maximalConfig];
-    devPkg = buildPkg pkgs [nixConfig {config.vim.languages.html.enable = pkgs.lib.mkForce true;}];
-  };
-}

flake/packages.nix

@@ -1,4 +1,8 @@
-{inputs, ...}: {
+{
+  inputs,
+  self,
+  ...
+} @ args: {
   perSystem = {
     config,
     pkgs,
@@ -6,8 +10,27 @@
     ...
   }: let
     docs = import ../docs {inherit pkgs inputs lib;};
+    buildPkg = maximal:
+      (args.config.flake.lib.nvim.neovimConfiguration {
+        inherit pkgs;
+        modules = [(import ../configuration.nix maximal)];
+      }).neovim;
   in {
     packages = {
+      blink-cmp = pkgs.callPackage ./blink {};
+      avante-nvim = let
+        pin = self.pins.avante-nvim;
+      in
+        pkgs.callPackage ./avante-nvim {
+          version = pin.branch;
+          src = pkgs.fetchFromGitHub {
+            inherit (pin.repository) owner repo;
+            rev = pin.revision;
+            sha256 = pin.hash;
+          };
+          pins = self.pins;
+        };
+
       inherit (docs.manual) htmlOpenTool;
       # Documentation
       docs = docs.manual.html;
@@ -61,9 +84,9 @@
         '';
 
       # Exposed neovim configurations
-      nix = config.legacyPackages.neovim-nix;
-      maximal = config.legacyPackages.neovim-maximal;
-      default = config.legacyPackages.neovim-nix;
+      nix = buildPkg false;
+      maximal = buildPkg true;
+      default = config.packages.nix;
     };
   };
 }

flake/templates/standalone/flake.nix

@@ -26,12 +26,22 @@
         config.vim = {
           theme.enable = true;
 
+          lsp = {
+            # Enable LSP functionality globally. This is required for modules found
+            # in `vim.languages` to enable relevant LSPs.
+            enable = true;
+
+            # You may define your own LSP configurations using `vim.lsp.servers` in
+            # nvf without ever needing lspconfig to do it. This will use the native
+            # API provided by Neovim > 0.11
+            servers = {};
+          };
+
           # Language support and automatic configuration of companion plugins.
           # Note that enabling, e.g., languages.<lang>.diagnostics will automatically
           # enable top-level options such as enableLSP or enableExtraDiagnostics as
           # they are needed.
           languages = {
-            enableLSP = true;
             enableFormat = true;
             enableTreesitter = true;
             enableExtraDiagnostics = true;

lib/default.nix

@@ -4,7 +4,7 @@
   lib,
   ...
 }: {
-  types = import ./types {inherit lib;};
+  types = import ./types {inherit lib self;};
   config = import ./config.nix {inherit lib;};
   binds = import ./binds.nix {inherit lib;};
   dag = import ./dag.nix {inherit lib;};

lib/languages.nix

@@ -1,10 +1,11 @@
-# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/booleans.nix
 {lib}: let
   inherit (builtins) isString getAttr;
   inherit (lib.options) mkOption;
-  inherit (lib.types) bool;
+  inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr;
   inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) luaInline;
 in {
+  # TODO: remove
   diagnosticsToLua = {
     lang,
     config,
@@ -32,4 +33,48 @@ in {
       type = bool;
       description = "Turn on ${desc} for enabled languages by default";
     };
+
+  lspOptions = submodule {
+    freeformType = attrsOf anything;
+    options = {
+      enable = mkOption {
+        type = bool;
+        default = true;
+        description = "Whether to enable this LSP server.";
+      };
+
+      capabilities = mkOption {
+        type = nullOr (either luaInline (attrsOf anything));
+        default = null;
+        description = "LSP capabilitiess to pass to lspconfig";
+      };
+
+      on_attach = mkOption {
+        type = nullOr luaInline;
+        default = null;
+        description = "Function to execute when an LSP server attaches to a buffer";
+      };
+
+      filetypes = mkOption {
+        type = nullOr (listOf str);
+        default = null;
+        description = "Filetypes to auto-attach LSP in";
+      };
+
+      cmd = mkOption {
+        type = nullOr (listOf str);
+        default = null;
+        description = "Command used to start the LSP server";
+      };
+
+      root_markers = mkOption {
+        type = nullOr (listOf str);
+        default = null;
+        description = ''
+          "root markers" used to determine the root directory of the workspace, and
+          the filetypes associated with this LSP server.
+        '';
+      };
+    };
+  };
 }

lib/types/default.nix

@@ -1,6 +1,9 @@
-{lib}: let
+{
+  lib,
+  self,
+}: let
   typesDag = import ./dag.nix {inherit lib;};
-  typesPlugin = import ./plugins.nix {inherit lib;};
+  typesPlugin = import ./plugins.nix {inherit lib self;};
   typesLanguage = import ./languages.nix {inherit lib;};
   customTypes = import ./custom.nix {inherit lib;};
 in {

lib/types/plugins.nix

@@ -1,4 +1,7 @@
-{lib}: let
+{
+  lib,
+  self,
+}: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
   inherit (lib.strings) hasPrefix removePrefix;
@@ -12,7 +15,7 @@
     mapAttrs' (n: v: nameValuePair (removePrefix prefix n) {src = v;}) (filterAttrs (n: _: hasPrefix prefix n) inputs);
 
   #  Get the names of all npins
-  pluginInputNames = attrNames (lib.importJSON ../../npins/sources.json).pins;
+  pluginInputNames = ["blink-cmp"] ++ attrNames self.pins;
 
   # You can either use the name of the plugin or a package.
   pluginType = nullOr (

modules/extra/deprecations.nix

@@ -18,7 +18,7 @@
     showSignColumn = "signcolumn";
 
     # 2025-02-07
-    scrollOff = "scrolloff";
+    scrollOffset = "scrolloff";
   };
 in {
   imports = concatLists [
@@ -111,6 +111,15 @@ in {
         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.
       '')
+
+      # 2025-05-04
+      (mkRemovedOptionModule ["vim" "useSystemClipboard"] ''
+        Clipboard behaviour should now be controlled through the new, more fine-grained module
+        interface found in 'vim.clipboard'. To replicate previous behaviour, you may either
+        add 'vim.opt.clipboard:append("unnamedplus")' in luaConfigRC, or preferably set it
+        in 'vim.clipboard.registers'. Please see the documentation for the new module for more
+        details, or open an issue if you are confused.
+      '')
     ]
 
     # Migrated via batchRenameOptions. Further batch renames must be below this line.

modules/modules.nix

@@ -33,6 +33,7 @@
       "minimap"
       "notes"
       "projects"
+      "repl"
       "rich-presence"
       "runner"
       "session"

modules/neovim/init/basic.nix

@@ -6,11 +6,10 @@
   inherit (lib.options) mkOption mkEnableOption literalMD;
   inherit (lib.strings) optionalString;
   inherit (lib.attrsets) optionalAttrs;
-  inherit (lib.types) enum bool str int either;
+  inherit (lib.types) enum bool str either;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.binds) pushDownDefault;
-  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) luaInline;
 
   cfg = config.vim;
@@ -22,24 +21,12 @@ in {
       description = "Hide search highlight so it doesn't stay highlighted";
     };
 
-    scrollOffset = mkOption {
-      type = int;
-      default = 8;
-      description = "Start scrolling this number of lines from the top or bottom of the page.";
-    };
-
     syntaxHighlighting = mkOption {
       type = bool;
       default = !config.vim.treesitter.highlight.enable;
       description = "Enable syntax highlighting";
     };
 
-    useSystemClipboard = mkOption {
-      type = bool;
-      default = false;
-      description = "Make use of the clipboard for default yank and paste operations. Don't use * and +";
-    };
-
     lineNumberMode = mkOption {
       type = enum ["relative" "number" "relNumber" "none"];
       default = "relNumber";
@@ -144,10 +131,6 @@ in {
     # to pre-set Neovim options. Fear not, though as the Lua DAG is still as powerful as it
     # could be.
     luaConfigRC.basic = entryAfter ["globalsScript"] ''
-      ${optionalString cfg.useSystemClipboard ''
-        vim.opt.clipboard:append("unnamedplus")
-      ''}
-
       ${optionalString cfg.syntaxHighlighting ''
         vim.cmd("syntax on")
       ''}

modules/neovim/init/clipboard.nix

@@ -0,0 +1,80 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.options) mkOption mkEnableOption mkPackageOption;
+  inherit (lib.types) nullOr either str listOf submodule;
+  inherit (lib.attrsets) mapAttrs mapAttrsToList filterAttrs;
+  cfg = config.vim.clipboard;
+in {
+  options = {
+    vim = {
+      clipboard = {
+        enable = mkEnableOption ''
+          clipboard management for Neovim. Users may still choose to manage their
+          clipboard through [](#opt-vim.options) should they wish to avoid using
+          this module.
+        '';
+
+        registers = mkOption {
+          type = either str (listOf str);
+          default = "";
+          example = "unnamedplus";
+          description = ''
+            The register to be used by the Neovim clipboard. Recognized types are:
+
+            * unnamed: Vim will use the clipboard register `"*"` for all yank, delete,
+              change and put operations which would normally go to the unnamed register.
+
+            * unnamedplus: A variant of the "unnamed" flag which uses the clipboard register
+            `"+"` ({command}`:h quoteplus`) instead of register `"*"` for all yank, delete,
+            change and put operations which would normally go to the unnamed register.
+
+            When `unnamed` and `unnamedplus` is included simultaneously yank and delete
+            operations (but not put) will additionally copy the text into register `"*"`.
+
+            Please see  {command}`:h clipboard` for more details.
+
+          '';
+        };
+
+        providers = mkOption {
+          type = submodule {
+            options = let
+              clipboards = {
+                # name = "package name";
+                wl-copy = "wl-clipboard";
+                xclip = "xclip";
+                xsel = "xsel";
+              };
+            in
+              mapAttrs (name: pname: {
+                enable = mkEnableOption name;
+                package = mkPackageOption pkgs pname {nullable = true;};
+              })
+              clipboards;
+          };
+          default = {};
+          description = ''
+            Clipboard providers for which packages will be added to nvf's
+            {option}`extraPackages`. The `package` field may be set to `null`
+            if related packages are already found in system packages to
+            potentially reduce closure sizes.
+          '';
+        };
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    vim = {
+      options.clipboard = cfg.registers;
+      extraPackages = mapAttrsToList (_: v: v.package) (
+        filterAttrs (_: v: v.enable && v.package != null) cfg.providers
+      );
+    };
+  };
+}

modules/neovim/init/default.nix

@@ -2,9 +2,11 @@
   imports = [
     ./autocmds.nix
     ./basic.nix
+    ./clipboard.nix
     ./debug.nix
     ./diagnostics.nix
     ./highlight.nix
+    ./lsp.nix
     ./spellcheck.nix
   ];
 }

modules/neovim/init/lsp.nix

@@ -0,0 +1,93 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (builtins) filter;
+  inherit (lib.modules) mkIf mkMerge mkDefault;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) attrsOf;
+  inherit (lib.strings) concatLines;
+  inherit (lib.attrsets) mapAttrsToList attrNames filterAttrs;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+
+  cfg = config.vim.lsp;
+
+  lspConfigurations =
+    mapAttrsToList (
+      name: value: ''
+        vim.lsp.config["${name}"] = ${toLuaObject value}
+      ''
+    )
+    cfg.servers;
+
+  enabledServers = filterAttrs (_: u: u.enable) cfg.servers;
+in {
+  options = {
+    vim.lsp = {
+      enable = mkEnableOption ''
+        global LSP functionality for Neovim.
+
+        This option controls whether to enable LSP functionality within modules under
+        {option}`vim.languages`. You do not need to set this to `true` for language
+        servers defined in {option}`vim.lsp.servers` to take effect, since they are
+        enabled automatically.
+      '';
+
+      servers = mkOption {
+        type = attrsOf lspOptions;
+        default = {};
+        example = ''
+          {
+            "*" = {
+              root_markers = [".git"];
+              capabilities = {
+                textDocument = {
+                  semanticTokens = {
+                    multilineTokenSupport = true;
+                  };
+                };
+              };
+            };
+
+            "clangd" = {
+              filetypes = ["c"];
+            };
+          }
+        '';
+        description = ''
+          LSP configurations that will be managed using `vim.lsp.config()` and related
+          utilities added in Neovim 0.11. LSPs defined here will be added to the
+          resulting {file}`init.lua` using `vim.lsp.config` and enabled through
+          `vim.lsp.enable()` API from Neovim below the configuration table.
+
+          You may review the generated configuration by running {command}`nvf-print-config`
+          in a shell. Please see {command}`:help lsp-config` for more details
+          on the underlying API.
+        '';
+      };
+    };
+  };
+
+  config = mkMerge [
+    {
+      vim.lsp.servers."*" = {
+        capabilities = mkDefault (mkLuaInline "capabilities");
+        on_attach = mkDefault (mkLuaInline "default_on_attach");
+      };
+    }
+
+    (mkIf (cfg.servers != {}) {
+      vim.luaConfigRC.lsp-servers = entryAnywhere ''
+        -- Individual LSP configurations managed by nvf.
+        ${concatLines lspConfigurations}
+
+        -- Enable configured LSPs explicitly
+        vim.lsp.enable(${toLuaObject (filter (name: name != "*") (attrNames enabledServers))})
+      '';
+    })
+  ];
+}

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

@@ -0,0 +1,325 @@
+{lib, ...}: let
+  inherit (lib.options) mkOption mkEnableOption literalMD;
+  inherit (lib.types) int str enum nullOr attrs bool;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+in {
+  options.vim.assistant = {
+    avante-nvim = {
+      enable = mkEnableOption "complementary Neovim plugin for avante.nvim";
+      setupOpts = mkPluginSetupOption "avante-nvim" {
+        provider = mkOption {
+          type = nullOr str;
+          default = null;
+          description = "The provider used in Aider mode or in the planning phase of Cursor Planning Mode.";
+        };
+
+        vendors = mkOption {
+          type = nullOr attrs;
+          default = null;
+          description = "Define Your Custom providers.";
+          example = literalMD ''
+            ```nix
+            ollama = {
+              __inherited_from = "openai";
+              api_key_name = "";
+              endpoint = "http://127.0.0.1:11434/v1";
+              model = "qwen2.5u-coder:7b";
+              max_tokens = 4096;
+              disable_tools = true;
+            };
+            ollama_ds = {
+              __inherited_from = "openai";
+              api_key_name = "";
+              endpoint = "http://127.0.0.1:11434/v1";
+              model = "deepseek-r1u:7b";
+              max_tokens = 4096;
+              disable_tools = true;
+            };
+            ```
+          '';
+        };
+
+        auto_suggestions_provider = mkOption {
+          type = str;
+          default = "claude";
+          description = ''
+            Since auto-suggestions are a high-frequency operation and therefore expensive,
+            currently designating it as `copilot` provider is dangerous because:
+            https://github.com/yetone/avante.nvim/issues/1048
+            Of course, you can reduce the request frequency by increasing `suggestion.debounce`.
+          '';
+        };
+
+        cursor_applying_provider = mkOption {
+          type = nullOr str;
+          default = null;
+          description = ''
+            The provider used in the applying phase of Cursor Planning Mode, defaults to `nil`,
+            Config.provider will be used as the provider for the applying phase when `nil`.
+          '';
+        };
+
+        dual_boost = {
+          enabled = mkEnableOption "dual_boost mode.";
+
+          first_provider = mkOption {
+            type = str;
+            default = "openai";
+            description = "The first provider to generate response.";
+          };
+
+          second_provider = mkOption {
+            type = str;
+            default = "claude";
+            description = "The second provider to generate response.";
+          };
+
+          prompt = mkOption {
+            type = str;
+            default = ''
+              Based on the two reference outputs below, generate a response that incorporates
+              elements from both but reflects your own judgment and unique perspective.
+              Do not provide any explanation, just give the response directly. Reference Output 1:
+              [{{provider1_output}}], Reference Output 2: [{{provider2_output}}'';
+            description = "The prompt to generate response based on the two reference outputs.";
+          };
+
+          timeout = mkOption {
+            type = int;
+            default = 60000;
+            description = "Timeout in milliseconds.";
+          };
+        };
+
+        behaviour = {
+          auto_suggestions =
+            mkEnableOption "auto suggestions.";
+
+          auto_set_highlight_group =
+            mkEnableOption "automatically set the highlight group for the current line."
+            // {
+              default = true;
+            };
+
+          auto_set_keymaps =
+            mkEnableOption "automatically set the keymap for the current line."
+            // {
+              default = true;
+            };
+
+          auto_apply_diff_after_generation =
+            mkEnableOption "automatically apply diff after LLM response.";
+
+          support_paste_from_clipboard = mkEnableOption ''
+            pasting image from clipboard.
+            This will be determined automatically based whether img-clip is available or not.
+          '';
+
+          minimize_diff =
+            mkEnableOption "remove unchanged lines when applying a code block."
+            // {
+              default = true;
+            };
+
+          enable_token_counting =
+            mkEnableOption "token counting."
+            // {
+              default = true;
+            };
+
+          enable_cursor_planning_mode =
+            mkEnableOption "Cursor Planning Mode.";
+
+          enable_claude_text_editor_tool_mode =
+            mkEnableOption "Claude Text Editor Tool Mode.";
+        };
+
+        mappings = {
+          diff = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for diff.";
+          };
+
+          suggestion = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for suggestion actions.";
+          };
+
+          jump = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for jump actions.";
+          };
+
+          submit = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for submit actions.";
+          };
+
+          cancel = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for cancel actions.";
+          };
+
+          sidebar = mkOption {
+            type = nullOr attrs;
+            default = null;
+            description = "Define or override the default keymaps for sidebar actions.";
+          };
+        };
+
+        hints.enabled =
+          mkEnableOption ""
+          // {
+            default = true;
+            description = ''
+              Whether to enable hints.
+            '';
+          };
+
+        windows = {
+          position = mkOption {
+            type = enum ["right" "left" "top" "bottom"];
+            default = "right";
+            description = "The position of the sidebar.";
+          };
+
+          wrap =
+            mkEnableOption ""
+            // {
+              default = true;
+              description = ''
+                similar to vim.o.wrap.
+              '';
+            };
+
+          width = mkOption {
+            type = int;
+            default = 30;
+            description = "Default % based on available width.";
+          };
+
+          sidebar_header = {
+            enabled = mkOption {
+              type = bool;
+              default = true;
+              description = "enable/disable the header.";
+            };
+
+            align = mkOption {
+              type = enum ["right" "center" "left"];
+              default = "center";
+              description = "Position of the title.";
+            };
+
+            rounded = mkOption {
+              type = bool;
+              default = true;
+              description = "Enable rounded sidebar header";
+            };
+          };
+
+          input = {
+            prefix = mkOption {
+              type = str;
+              default = "> ";
+              description = "The prefix used on the user input.";
+            };
+
+            height = mkOption {
+              type = int;
+              default = 8;
+              description = ''
+                Height of the input window in vertical layout.
+              '';
+            };
+          };
+
+          edit = {
+            border = mkOption {
+              type = str;
+              default = "rounded";
+              description = "The border type on the edit window.";
+            };
+
+            start_insert = mkOption {
+              type = bool;
+              default = true;
+              description = ''
+                Start insert mode when opening the edit window.
+              '';
+            };
+          };
+
+          ask = {
+            floating = mkOption {
+              type = bool;
+              default = false;
+              description = ''
+                Open the 'AvanteAsk' prompt in a floating window.
+              '';
+            };
+
+            start_insert = mkOption {
+              type = bool;
+              default = true;
+              description = ''
+                Start insert mode when opening the ask window.
+              '';
+            };
+
+            border = mkOption {
+              type = str;
+              default = "rounded";
+              description = "The border type on the ask window.";
+            };
+
+            focus_on_apply = mkOption {
+              type = enum ["ours" "theirs"];
+              default = "ours";
+              description = "Which diff to focus after applying.";
+            };
+          };
+        };
+
+        diff = {
+          autojump =
+            mkEnableOption ""
+            // {
+              default = true;
+              description = "Automatically jumps to the next change.";
+            };
+
+          override_timeoutlen = mkOption {
+            type = int;
+            default = 500;
+            example = -1;
+            description = ''
+              Override the 'timeoutlen' setting while hovering over a diff (see {command}`:help timeoutlen`).
+              Helps to avoid entering operator-pending mode with diff mappings starting with `c`.
+              Disable by setting to -1.
+            '';
+          };
+        };
+
+        suggestion = {
+          debounce = mkOption {
+            type = int;
+            default = 600;
+            description = "Suggestion debounce in milliseconds.";
+          };
+
+          throttle = mkOption {
+            type = int;
+            default = 600;
+            description = "Suggestion throttle in milliseconds.";
+          };
+        };
+      };
+    };
+  };
+}

modules/plugins/assistant/avante/config.nix

@@ -0,0 +1,41 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+  inherit (lib.lists) optionals;
+
+  cfg = config.vim.assistant.avante-nvim;
+in {
+  config = mkIf cfg.enable {
+    vim = {
+      startPlugins =
+        [
+          "nvim-treesitter"
+          "plenary-nvim"
+          "dressing-nvim"
+          "nui-nvim"
+        ]
+        ++ (optionals config.vim.mini.pick.enable ["mini-pick"])
+        ++ (optionals config.vim.telescope.enable ["telescope"])
+        ++ (optionals config.vim.autocomplete.nvim-cmp.enable ["nvim-cmp"])
+        ++ (optionals config.vim.fzf-lua.enable ["fzf-lua"])
+        ++ (optionals config.vim.visuals.nvim-web-devicons.enable ["nvim-web-devicons"])
+        ++ (optionals config.vim.utility.images.img-clip.enable ["img-clip"]);
+
+      lazy.plugins = {
+        avante-nvim = {
+          package = "avante-nvim";
+          setupModule = "avante";
+          inherit (cfg) setupOpts;
+          event = ["DeferredUIEnter"];
+        };
+      };
+
+      treesitter.enable = true;
+
+      languages.markdown.extensions.render-markdown-nvim.setupOpts.file_types = lib.mkAfter ["Avante"];
+    };
+  };
+}

modules/plugins/assistant/avante/default.nix

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

modules/plugins/assistant/codecompanion/config.nix

@@ -21,7 +21,17 @@ in {
         };
       };
 
-      treesitter.enable = true;
+      treesitter = {
+        enable = true;
+
+        # Codecompanion depends on the YAML grammar being added. Below is
+        # an easy way of adding an user-configurable grammar package exposed
+        # by the YAML language module *without* enabling the whole YAML language
+        # module. The package is defined even when the module is disabled.
+        grammars = [
+          config.vim.languages.yaml.treesitter.package
+        ];
+      };
 
       autocomplete.nvim-cmp = {
         sources = {codecompanion-nvim = "[codecompanion]";};

modules/plugins/assistant/default.nix

@@ -3,5 +3,6 @@
     ./chatgpt
     ./copilot
     ./codecompanion
+    ./avante
   ];
 }

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

@@ -10,7 +10,7 @@
     freeformType = attrsOf (listOf (either str luaInline));
     options = {
       preset = mkOption {
-        type = enum ["default" "none" "super-tab" "enter"];
+        type = enum ["default" "none" "super-tab" "enter" "cmdline"];
         default = "none";
         description = "keymap presets";
       };
@@ -48,7 +48,7 @@ in {
       cmdline = {
         sources = mkOption {
           type = nullOr (listOf str);
-          default = [];
+          default = null;
           description = "List of sources to enable for cmdline. Null means use default source list.";
         };
 

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

@@ -122,6 +122,21 @@ in {
             "fallback"
           ];
         };
+
+        # cmdline is not enabled by default, we're just providing keymaps in
+        # case the user enables them
+        cmdline.keymap = {
+          ${mappings.complete} = ["show" "fallback"];
+          ${mappings.close} = ["hide" "fallback"];
+          ${mappings.scrollDocsUp} = ["scroll_documentation_up" "fallback"];
+          ${mappings.scrollDocsDown} = ["scroll_documentation_down" "fallback"];
+          # NOTE: mappings.confirm is skipped because our default, <CR> would
+          # lead to accidental triggers of blink.accept instead of executing
+          # the cmd
+
+          ${mappings.next} = ["select_next" "show" "fallback"];
+          ${mappings.previous} = ["select_prev" "fallback"];
+        };
       };
     };
   };

modules/plugins/filetree/nvimtree/nvimtree.nix

@@ -683,15 +683,48 @@ in {
               };
 
               git_placement = mkOption {
-                type = enum ["before" "after" "signcolumn"];
-                description = "Place where the git icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
+                type = enum ["before" "after" "signcolumn" "right_align"];
                 default = "before";
+                description = ''
+                  Place where the git icons will be rendered.
+                  `signcolumn` requires `view.signcolumn` to be enabled.
+                '';
               };
 
               modified_placement = mkOption {
-                type = enum ["before" "after" "signcolumn"];
-                description = "Place where the modified icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
+                type = enum ["before" "after" "signcolumn" "right_align"];
                 default = "after";
+                description = ''
+                  Place where the modified icons will be rendered.
+                  `signcolumn` requires `view.signcolumn` to be enabled.
+                '';
+              };
+
+              hidden_placement = mkOption {
+                type = enum ["before" "after" "signcolumn" "right_align"];
+                default = "after";
+                description = ''
+                  Place where the hidden icons will be rendered.
+                  `signcolumn` requires `view.signcolumn` to be enabled.
+                '';
+              };
+
+              diagnostics_placement = mkOption {
+                type = enum ["before" "after" "signcolumn" "right_align"];
+                default = "after";
+                description = ''
+                  Place where the diagnostics icons will be rendered.
+                  `signcolumn` requires `view.signcolumn` to be enabled.
+                '';
+              };
+
+              bookmarks_placement = mkOption {
+                type = enum ["before" "after" "signcolumn" "right_align"];
+                default = "after";
+                description = ''
+                  Place where the bookmark icons will be rendered.
+                  `signcolumn` requires `view.signcolumn` to be enabled.
+                '';
               };
 
               padding = mkOption {

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

@@ -1,12 +1,9 @@
-{
-  pkgs,
-  lib,
-  ...
-}: let
-  inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.types) attrs enum nullOr;
-  inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.lua) mkLuaInline;
+{lib, ...}: let
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.options) mkOption mkEnableOption literalMD;
+  inherit (lib.types) attrs either nullOr;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.types) luaInline mkPluginSetupOption;
 in {
   options.vim.formatter.conform-nvim = {
     enable = mkEnableOption "lightweight yet powerful formatter plugin for Neovim [conform-nvim]";
@@ -31,26 +28,46 @@ in {
       };
 
       format_on_save = mkOption {
-        type = nullOr attrs;
-        default = {
-          lsp_format = "fallback";
-          timeout_ms = 500;
-        };
+        type = nullOr (either attrs luaInline);
+        default = mkLuaInline ''
+          function()
+            if not vim.g.formatsave or vim.b.disableFormatSave then
+              return
+            else
+              return {lsp_format = "fallback", timeout_ms = 500}
+            end
+          end
+        '';
+        defaultText = literalMD ''
+          enabled by default, and respects {option}`vim.lsp.formatOnSave` and
+          {option}`vim.lsp.mappings.toggleFormatSave`
+        '';
         description = ''
-          Table that will be passed to `conform.format()`. If this
-          is set, Conform will run the formatter on save.
+          Attribute set or Lua function that will be passed to
+          `conform.format()`. If this is set, Conform will run the formatter
+          on save.
         '';
       };
 
-      format_after_save = mkOption {
-        type = nullOr attrs;
-        default = {lsp_format = "fallback";};
-        description = ''
-          Table that will be passed to `conform.format()`. If this
-          is set, Conform will run the formatter asynchronously after
-          save.
-        '';
-      };
+      format_after_save = let
+        defaultFormatAfterSaveOpts = {lsp_format = "fallback";};
+      in
+        mkOption {
+          type = nullOr (either attrs luaInline);
+          default = mkLuaInline ''
+            function()
+              if not vim.g.formatsave or vim.b.disableFormatSave then
+                return
+              else
+                return ${toLuaObject defaultFormatAfterSaveOpts}
+              end
+            end
+          '';
+          description = ''
+            Table or function(luainline) that will be passed to `conform.format()`. If this
+            is set, Conform will run the formatter asynchronously after save.
+          '';
+        };
     };
   };
 }

modules/plugins/git/gitsigns/config.nix

@@ -81,9 +81,11 @@ in {
     (mkIf cfg.codeActions.enable {
       vim.lsp.null-ls = {
         enable = true;
-        setupOpts.sources.gitsigns-ca = mkLuaInline ''
-          require("null-ls").builtins.code_actions.gitsigns
-        '';
+        setupOpts.sources = [
+          (mkLuaInline ''
+            require("null-ls").builtins.code_actions.gitsigns
+          '')
+        ];
       };
     })
   ]);

modules/plugins/languages/asm.nix

@@ -20,7 +20,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.lsp.enable;};
 
       package = mkOption {
         type = package;

modules/plugins/languages/astro.nix

@@ -81,7 +81,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Astro LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/bash.nix

@@ -56,7 +56,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Bash LSP server to use";

modules/plugins/languages/clang.nix

@@ -98,7 +98,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "clang LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "clang LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "The clang LSP server to use";

modules/plugins/languages/clojure.nix

@@ -0,0 +1,56 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.lists) isList;
+  inherit (lib.types) either listOf package str;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.lua) expToLua;
+
+  cfg = config.vim.languages.clojure;
+in {
+  options.vim.languages.clojure = {
+    enable = mkEnableOption "Clojure language support";
+
+    treesitter = {
+      enable = mkEnableOption "Clojure treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "clojure";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Clojure LSP support" // {default = config.vim.lsp.enable;};
+      package = mkOption {
+        type = either package (listOf str);
+        default = pkgs.clojure-lsp;
+        description = "Clojure LSP";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.clojure-lsp = ''
+        lspconfig.clojure_lsp.setup {
+          capabilities = capabilities;
+          on_attach = default_on_attach;
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{"${getExe cfg.lsp.package}"}''
+        };
+        }
+      '';
+    })
+
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+  ]);
+}

modules/plugins/languages/csharp.nix

@@ -91,7 +91,7 @@ in {
       };
 
       lsp = {
-        enable = mkEnableOption "C# LSP support" // {default = config.vim.languages.enableLSP;};
+        enable = mkEnableOption "C# LSP support" // {default = config.vim.lsp.enable;};
         server = mkOption {
           description = "C# LSP server to use";
           type = enum (attrNames servers);

modules/plugins/languages/css.nix

@@ -80,7 +80,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "CSS LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "CSS LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "CSS LSP server to use";

modules/plugins/languages/cue.nix

@@ -21,7 +21,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "CUE LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "CUE LSP support" // {default = config.vim.lsp.enable;};
 
       package = mkOption {
         type = package;

modules/plugins/languages/dart.nix

@@ -77,7 +77,7 @@ in {
     flutter-tools = {
       enable = mkOption {
         type = bool;
-        default = config.vim.languages.enableLSP;
+        default = config.vim.lsp.enable;
         description = "Enable flutter-tools for flutter support";
       };
 
@@ -143,8 +143,6 @@ in {
     })
 
     (mkIf ftcfg.enable {
-      lsp.enable = true;
-
       startPlugins = [
         (
           if ftcfg.enableNoResolvePatch

modules/plugins/languages/default.nix

@@ -1,4 +1,5 @@
 {lib, ...}: let
+  inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.nvim.languages) mkEnable;
 in {
   imports = [
@@ -8,6 +9,7 @@ in {
     ./cue.nix
     ./dart.nix
     ./clang.nix
+    ./clojure.nix
     ./css.nix
     ./elixir.nix
     ./fsharp.nix
@@ -44,10 +46,13 @@ in {
     ./wgsl.nix
     ./yaml.nix
     ./ruby.nix
+
+    # This is now a hard deprecation.
+    (mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])
   ];
 
   options.vim.languages = {
-    enableLSP = mkEnable "LSP";
+    # Those are still managed by plugins, and should be enabled here.
     enableDAP = mkEnable "Debug Adapter";
     enableTreesitter = mkEnable "Treesitter";
     enableFormat = mkEnable "Formatting";

modules/plugins/languages/elixir.nix

@@ -53,7 +53,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Elixir LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Elixir LSP server to use";

modules/plugins/languages/fsharp.nix

@@ -51,7 +51,7 @@ in {
       };
 
       lsp = {
-        enable = mkEnableOption "F# LSP support" // {default = config.vim.languages.enableLSP;};
+        enable = mkEnableOption "F# LSP support" // {default = config.vim.lsp.enable;};
         server = mkOption {
           type = enum (attrNames servers);
           default = defaultServer;

modules/plugins/languages/gleam.nix

@@ -41,7 +41,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Gleam LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/go.nix

@@ -67,7 +67,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Go LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Go LSP server to use";

modules/plugins/languages/haskell.nix

@@ -25,7 +25,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.lsp.enable;};
       package = mkOption {
         description = "Haskell LSP package or command to run the Haskell LSP";
         example = ''[ (lib.getExe pkgs.haskellPackages.haskell-language-server) "--debug" ]'';

modules/plugins/languages/hcl.nix

@@ -43,7 +43,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
       # TODO: (maybe, is it better?) it would be cooler to use vscode-extensions.hashicorp.hcl probably, shouldn't be too hard
       package = mkOption {
         type = package;

modules/plugins/languages/helm.nix

@@ -54,7 +54,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Helm LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Helm LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Helm LSP server to use";

modules/plugins/languages/java.nix

@@ -23,7 +23,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.lsp.enable;};
       package = mkOption {
         description = "java language server package, or the command to run as a list of strings";
         example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';

modules/plugins/languages/julia.nix

@@ -78,7 +78,7 @@ in {
       lsp = {
         enable = mkOption {
           type = bool;
-          default = config.vim.languages.enableLSP;
+          default = config.vim.lsp.enable;
           description = ''
             Whether to enable Julia LSP support.
 

modules/plugins/languages/kotlin.nix

@@ -30,7 +30,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.lsp.enable;};
 
       package = mkOption {
         description = "kotlin_language_server package with Kotlin runtime";

modules/plugins/languages/lua.nix

@@ -43,7 +43,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.lsp.enable;};
 
       package = mkOption {
         description = "LuaLS package, or the command to run as a list of strings";

modules/plugins/languages/markdown.nix

@@ -67,7 +67,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);
@@ -130,6 +130,18 @@ in {
           };
         };
       };
+      markview-nvim = {
+        enable =
+          mkEnableOption ""
+          // {
+            description = ''
+              [markview.nvim]: https://github.com/OXY2DEV/markview.nvim
+
+              [markview.nvim] - a hackable markdown, Typst, latex, html(inline) & YAML previewer
+            '';
+          };
+        setupOpts = mkPluginSetupOption "markview-nvim" {};
+      };
     };
 
     extraDiagnostics = {
@@ -175,6 +187,13 @@ in {
       '';
     })
 
+    (mkIf cfg.extensions.markview-nvim.enable {
+      vim.startPlugins = ["markview-nvim"];
+      vim.pluginRC.markview-nvim = entryAnywhere ''
+        require("markview").setup(${toLuaObject cfg.extensions.markview-nvim.setupOpts})
+      '';
+    })
+
     (mkIf cfg.extraDiagnostics.enable {
       vim.diagnostics.nvim-lint = {
         enable = true;

modules/plugins/languages/nim.nix

@@ -54,7 +54,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Nim LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Nim LSP support" // {default = config.vim.lsp.enable;};
       server = mkOption {
         description = "Nim LSP server to use";
         type = str;

modules/plugins/languages/nix.nix

@@ -2,6 +2,7 @@
   config,
   pkgs,
   lib,
+  inputs,
   ...
 }: let
   inherit (builtins) attrNames;
@@ -27,7 +28,7 @@
     else ''{"${package}/bin/${defaultCmd}"}'';
   servers = {
     nil = {
-      package = pkgs.nil;
+      package = inputs.nil.packages.${pkgs.stdenv.system}.nil;
       internalFormatter = true;
       lspConfig = ''
         lspconfig.nil_ls.setup{
@@ -143,7 +144,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
       server = mkOption {
         description = "Nix LSP server to use";
         type = enum (attrNames servers);

modules/plugins/languages/nu.nix

@@ -40,7 +40,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Nu LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Nu LSP support" // {default = config.vim.lsp.enable;};
       server = mkOption {
         type = str;
         default = defaultServer;

modules/plugins/languages/ocaml.nix

@@ -49,7 +49,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.lsp.enable;};
       server = mkOption {
         description = "OCaml LSP server to user";
         type = enum (attrNames servers);

modules/plugins/languages/odin.nix

@@ -41,7 +41,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Odin LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Odin LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/php.nix

@@ -95,7 +95,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "PHP LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "PHP LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "PHP LSP server to use";

modules/plugins/languages/python.nix

@@ -169,7 +169,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Python LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Python LSP server to use";

modules/plugins/languages/r.nix

@@ -79,7 +79,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "R LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "R LSP server to use";

modules/plugins/languages/ruby.nix

@@ -9,6 +9,8 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.lists) isList;
   inherit (lib.types) either listOf package str enum;
 
   cfg = config.vim.languages.ruby;
@@ -24,7 +26,25 @@
           flags = {
             debounce_text_changes = 150,
           },
-          cmd = { "${pkgs.solargraph}/bin/solargraph", "stdio" }
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{ "${cfg.lsp.package}/bin/solargraph", "stdio" }''
+        }
+        }
+      '';
+    };
+    rubylsp = {
+      package = pkgs.ruby-lsp;
+      lspConfig = ''
+        lspconfig.ruby_lsp.setup {
+          capabilities = capabilities,
+          on_attach = default_on_attach,
+          cmd = ${
+          if isList cfg.lsp.package
+          then expToLua cfg.lsp.package
+          else ''{ "${cfg.lsp.package}/bin/ruby-lsp" }''
+        }
         }
       '';
     };
@@ -57,7 +77,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Ruby LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/rust.nix

@@ -7,7 +7,7 @@
   inherit (builtins) attrNames;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.options) mkOption mkEnableOption literalMD;
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString;
   inherit (lib.lists) isList;
@@ -43,7 +43,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.lsp.enable;};
       package = mkOption {
         description = "rust-analyzer package, or the command to run as a list of strings";
         example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
@@ -68,7 +68,14 @@ in {
     };
 
     format = {
-      enable = mkEnableOption "Rust formatting" // {default = config.vim.languages.enableFormat;};
+      enable =
+        mkEnableOption "Rust formatting"
+        // {
+          default = !cfg.lsp.enable && config.vim.languages.enableFormat;
+          defaultText = literalMD ''
+            Disabled if Rust LSP is enabled, otherwise follows {option}`vim.languages.enableFormat`
+          '';
+        };
 
       type = mkOption {
         description = "Rust formatter to use";

modules/plugins/languages/scala.nix

@@ -33,7 +33,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.lsp.enable;};
       package = mkPackageOption pkgs "metals" {
         default = ["metals"];
       };

modules/plugins/languages/sql.nix

@@ -79,7 +79,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "SQL LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "SQL LSP server to use";

modules/plugins/languages/svelte.nix

@@ -77,7 +77,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Svelte LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Svelte LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Svelte LSP server to use";

modules/plugins/languages/tailwind.nix

@@ -35,7 +35,7 @@ in {
     enable = mkEnableOption "Tailwindcss language support";
 
     lsp = {
-      enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Tailwindcss LSP server to use";

modules/plugins/languages/terraform.nix

@@ -20,7 +20,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
 
       package = mkOption {
         description = "terraform-ls package";

modules/plugins/languages/ts.nix

@@ -101,6 +101,7 @@
           "eslint.config.js"
           "eslint.config.mjs"
           ".eslintrc"
+          ".eslintrc.cjs"
           ".eslintrc.json"
           ".eslintrc.js"
           ".eslintrc.yml"
@@ -120,7 +121,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Typescript/Javascript LSP server to use";

modules/plugins/languages/typst.nix

@@ -76,7 +76,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         description = "Typst LSP server to use";

modules/plugins/languages/vala.nix

@@ -50,7 +50,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Vala LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Vala LSP support" // {default = config.vim.lsp.enable;};
       server = mkOption {
         description = "Vala LSP server to use";
         type = enum (attrNames servers);

modules/plugins/languages/wgsl.nix

@@ -42,7 +42,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "WGSL LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "WGSL LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/yaml.nix

@@ -55,7 +55,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "YAML LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "YAML LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);

modules/plugins/languages/zig.nix

@@ -72,7 +72,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Zig LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Zig LSP support" // {default = config.vim.lsp.enable;};
 
       server = mkOption {
         type = enum (attrNames servers);