.github/labels.yml

@@ -1,55 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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,16 +18,12 @@ 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 = !isMaximal; # conflicts with blink in maximal
+      lspSignature.enable = true;
       otter-nvim.enable = isMaximal;
       nvim-docs-view.enable = isMaximal;
     };
@@ -42,7 +38,8 @@ 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 = {
-      enableFormat = true; #
+      enableLSP = true;
+      enableFormat = true;
       enableTreesitter = true;
       enableExtraDiagnostics = true;
 
@@ -127,15 +124,7 @@ isMaximal: {
 
     autopairs.nvim-autopairs.enable = true;
 
-    # nvf provides various autocomplete options. The tried and tested nvim-cmp
+    autocomplete.nvim-cmp.enable = true;
-    # 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 = {
@@ -153,7 +142,6 @@ isMaximal: {
     binds = {
       whichKey.enable = true;
       cheatsheet.enable = true;
-      hardtime-nvim.enable = isMaximal;
     };
 
     telescope.enable = true;
@@ -199,7 +187,6 @@ isMaximal: {
       };
       images = {
         image-nvim.enable = false;
-        img-clip.enable = isMaximal;
       };
     };
 
@@ -248,7 +235,6 @@ isMaximal: {
         cmp.enable = isMaximal;
       };
       codecompanion-nvim.enable = false;
-      avante-nvim.enable = isMaximal;
     };
 
     session = {

docs/default.nix

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

docs/manual/configuring.md

@@ -1,15 +1,5 @@
 # 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
@@ -17,5 +7,4 @@ configuring/overriding-plugins.md
 configuring/languages.md
 configuring/dags.md
 configuring/dag-entries.md
-configuring/autocmds.md
 ```

docs/manual/configuring/autocmds.md

@@ -1,119 +0,0 @@
-# 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 [](#opt-vim.package) option.
+your configuration. This is done with the `vim.package` option.
 
 ```nix
 {inputs, pkgs, ...}: {
   # using the neovim-nightly overlay
-  vim.package = inputs.neovim-overlay.packages.${pkgs.stdenv.system}.neovim;
+  vim.package = inputs.neovim-overlay.packages.${pkgs.system}.neovim;
 }
 ```
 

docs/manual/configuring/custom-plugins.md

@@ -1,33 +1,22 @@
 # Custom Plugins {#ch-custom-plugins}
 
-**nvf** exposes a very wide variety of plugins by default, which are consumed by
+**nvf**, by default, exposes a wide variety of plugins as module options for
-module options. This is done for your convenience, and to bundle all necessary
+your convenience and bundles necessary dependencies into **nvf**'s runtime. In
-dependencies into **nvf**'s runtime with full control of versioning, testing and
+case a plugin is not available in **nvf**, you may consider making a pull
-dependencies. In the case a plugin you need is _not_ available, you may consider
+request to **nvf** to include it as a module or you may add it to your
-making a pull request to add the package you're looking for, or you may add it
+configuration locally.
-to your configuration locally. The below section describes how new plugins may
-be added to the user's configuration.
 
 ## Adding Plugins {#ch-adding-plugins}
 
-Per **nvf**'s design choices, there are several ways of adding custom plugins to
+There are multiple ways of adding custom plugins to your **nvf** configuration.
-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.
 
-:::{.info}
+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.
 
-To add a plugin to your runtime, you will need to add it to
+Adding a plugin to `startPlugins` will not allow you to configure the plugin
-[](#opt-vim.startPlugins) list in your configuration. This is akin to cloning a
+that you have added, but **nvf** provides multiple ways of configuring any custom
-plugin to `~/.config/nvim`, but they are only ever placed in the Nix store and
+plugins that you might have added to your configuration.
-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,20 +1,13 @@
 # Configuring {#sec-configuring-plugins}
 
 Just making the plugin to your Neovim configuration available might not always
-be enough., for example, if the plugin requires a setup table. In that case, you
+be enough. In that case, you can write custom lua config using either
-can write custom Lua configuration using one of
+`config.vim.lazy.plugins.*.setupOpts` `config.vim.extraPlugins.*.setup` or
+`config.vim.luaConfigRC`.
 
-- `config.vim.lazy.plugins.*.setupOpts`
+The first option uses an extended version of `lz.n`'s PluginSpec. `setupModule`
-- `config.vim.extraPlugins.*.setup`
+and `setupOpt` can be used if the plugin uses a `require('module').setup(...)`
-- `config.vim.luaConfigRC`.
+pattern. Otherwise, the `before` and `after` hooks should do what you need.
-
-## 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
 {
@@ -32,61 +25,50 @@ hooks should do what you need.
 }
 ```
 
-## Standard API {#ch-vim-extra-plugins}
+The second option uses an attribute set, which maps DAG section names to a
-
-`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
-{pkgs, ...}: {
+config.vim.extraPlugins = with pkgs.vimPlugins; {
-  config.vim.extraPlugins = {
   aerial = {
-      package = pkgs.vimPlugins.aerial-nvim;
+    package = aerial-nvim;
     setup = "require('aerial').setup {}";
   };
 
   harpoon = {
-      package = pkgs.vimPlugins.harpoon;
+    package = harpoon;
     setup = "require('harpoon').setup {}";
     after = ["aerial"]; # place harpoon configuration after aerial
   };
-  };
 }
 ```
 
-### Setup using luaConfigRC {#setup-using-luaconfigrc}
+The third option also uses an attribute set, but this one is resolved as a DAG
-
-`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 a section called "aquarium" in the 'init.lua' with the
+  # this will create an "aquarium" section in your init.lua with the contents of your custom config
-  # contents of your custom configuration. By default 'entryAnywhere' is implied
+  # which will be *appended* to the rest of your configuration, inside your init.vim
-  # 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
+One of the greatest strengths of nvf is the ability to order
-configuration snippets precisely using the [DAG system]. DAGs
+snippets of configuration via the DAG system. It will allow specifying positions
-are a very powerful mechanism that allows specifying positions
+of individual sections of configuration as needed. nvf provides helper functions
-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] in the nvf manual
+Please refer to the [DAG section](#ch-dag-entries) 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,8 +1,7 @@
 # Lazy Method {#sec-lazy-method}
 
-As of version **0.7**, an API is exposed to allow configuring lazy-loaded
+As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
-plugins via `lz.n` and `lzn-auto-require`. Below is a comprehensive example of
+`lz.n` and `lzn-auto-require`.
-how it may be loaded to lazy-load an arbitrary plugin.
 
 ```nix
 {
@@ -42,8 +41,7 @@ how it may be loaded to lazy-load an arbitrary plugin.
 
 ## LazyFile event {#sec-lazyfile-event}
 
-**nvf** re-implements `LazyFile` as a familiar user event to load a plugin when
+You can use the `LazyFile` user event to load a plugin when a file is opened:
-a file is opened:
 
 ```nix
 {
@@ -57,6 +55,5 @@ a file is opened:
 }
 ```
 
-You can consider the `LazyFile` event as an alias to the combination of
+You can consider `LazyFile` as an alias to
-`"BufReadPost"`, `"BufNewFile"` and `"BufWritePre"`, i.e., a list containing all
+`["BufReadPost" "BufNewFile" "BufWritePre"]`
-three of those events: `["BufReadPost" "BufNewFile" "BufWritePre"]`

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

@@ -1,31 +1,26 @@
 # Legacy Method {#sec-legacy-method}
 
-Prior to version **0.5**, the method of adding new plugins was adding the plugin
+Prior to version v0.5, the method of adding new plugins was adding the plugin
-package to [](#opt-vim.startPlugins) and adding its configuration as a DAG under
+package to `vim.startPlugins` and add its configuration as a DAG under one of
-one of `vim.configRC` or [](#opt-vim.luaConfigRC). While `configRC` has been
+`vim.configRC` or `vim.luaConfigRC`. Users who have not yet updated to 0.5, or
-deprecated, users who have not yet updated to 0.5 or those who prefer a more
+prefer a more hands-on approach may use the old method where the load order of
-hands-on approach may choose to use the old method where the load order of the
+the plugins is determined by DAGs.
-plugins is explicitly determined by DAGs without internal abstractions.
 
-## Adding New Plugins {#sec-adding-new-plugins}
+## Adding plugins {#sec-adding-plugins}
 
-To add a plugin not available in **nvf** as a module to your configuration using
+To add a plugin not available in nvf as a module to your configuration, you may
-the legacy method, you must add it to [](#opt-vim.startPlugins) in order to make
+add it to [](#opt-vim.startPlugins) in order to make it available to Neovim at
-it available to Neovim at runtime.
+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];
 }
 ```
 
-Once the package is available in Neovim's runtime, you may use the `luaConfigRC`
+And to configure the added plugin, you can use the `luaConfigRC` option to
-option to provide configuration as a DAG using the **nvf** extended library in
+provide configuration as a DAG using the **nvf** extended library.
-order to configure the added plugin,
 
 ```nix
 {inputs, ...}: let
@@ -34,8 +29,6 @@ order to configure the added plugin,
   # 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,15 +1,14 @@
 # Non-lazy Method {#sec-non-lazy-method}
 
-As of version **0.5**, we have a more extensive API for configuring plugins that
+As of version **0.5**, we have a more extensive API for configuring plugins,
-should be preferred over the legacy method. This API is available as
+under `vim.extraPlugins`. Instead of using DAGs exposed by the library, you may
-[](#opt-vim.extraPlugins). Instead of using DAGs exposed by the library
+use the extra plugin module as follows:
-_directly_, you may use the extra plugin module as follows:
 
 ```nix
-{pkgs, ...}: {
+{
-  config.vim.extraPlugins = {
+  config.vim.extraPlugins = with pkgs.vimPlugins; {
     aerial = {
-      package = pkgs.vimPlugins.aerial-nvim;
+      package = aerial-nvim;
       setup = ''
         require('aerial').setup {
           -- some lua configuration here
@@ -18,12 +17,10 @@ _directly_, you may use the extra plugin module as follows:
     };
 
     harpoon = {
-      package = pkgs.vimPlugins.harpoon;
+      package = 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,22 +1,17 @@
 # LSP Custom Packages/Command {#sec-languages-custom-lsp-packages}
 
-One of the strengths of **nvf** is convenient aliases to quickly configure LSP
+In any of the `opt.languages.<language>.lsp.package` options you can provide
-servers through the Nix module system. By default the LSP packages for relevant
+your own LSP package, or provide the command to launch the language server, as a
-language modules will be pulled into the closure. If this is not desirable, you
+list of strings. You can use this to skip automatic installation of a language
-may provide **a custom LSP package** (e.g., a Bash script that calls a command)
+server, and instead use the one found in your `$PATH` during runtime, for
-or **a list of strings** to be interpreted as the command to launch the language
+example:
-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
-    # This expects 'jdt-language-server' to be in your PATH or in
+    # or in `vim.extraPackages`
-    # '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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,11 @@
+# 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

@@ -0,0 +1,9 @@
+# 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
-                treesitter.enable = true;
+                tree-sitter.enable = true;
 
                 # Other options will go here. Refer to the config
                 # reference in Appendix B of the nvf manual.

docs/manual/manual.md

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

docs/manual/tips.md

@@ -1,14 +1,7 @@
 # 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

@@ -1,131 +0,0 @@
-# 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,12 +26,7 @@ $ nix run github:notashelf/nvf#nix
 $ nix run github:notashelf/nvf#maximal
 ```
 
-### Available Configurations {#sec-available-configs}
+### Available Configs {#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}
 
@@ -39,32 +34,15 @@ The below configurations are provided for demonstration purposes, and are
 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.
 
-```bash
+::: {.tip}
-$ nix run github:notashelf/nvf#maximal -- test.nix
-```
 
-It uses the same configuration template with the [Nix](#sec-configs-nix)
+You are _strongly_ recommended to use the binary cache if you would like to try
-configuration, but supports many more languages, and enables more utility,
+the Maximal configuration.
-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,8 +50,9 @@ soon.
 
 - A new section has been added for language support: `vim.languages.<language>`.
 
-  - The options `enableLSP` [](#opt-vim.languages.enableTreesitter), etc. will
+  - The options [](#opt-vim.languages.enableLSP),
-    enable the respective section for all languages that have been enabled.
+    [](#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`
 
-[poz](https://poz.pet):
+[jacekpoz](https://jacekpoz.pl):
 
 - 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.
 
-[poz](https://poz.pet):
+[jacekpoz](https://jacekpoz.pl):
 
 - 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
 
-[poz](https://poz.pet):
+[jacekpoz](https://jacekpoz.pl):
 
 [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,11 +19,6 @@
   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
@@ -96,11 +91,6 @@
   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
@@ -119,7 +109,6 @@
 - 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):
 
@@ -289,7 +278,6 @@
 [BANanaD3V](https://github.com/BANanaD3V):
 
 - `alpha` is now configured with nix.
-- Add `markview-nvim` markdown renderer.
 
 [viicslen](https://github.com/viicslen):
 
@@ -308,7 +296,6 @@
   `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):
 
@@ -325,8 +312,6 @@
 - 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):
 
@@ -340,15 +325,11 @@
 
 [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):
 
@@ -370,60 +351,4 @@
 
 [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": 1748278309,
+        "lastModified": 1745705214,
-        "narHash": "sha256-JCeiMrUhFku44kfKsgiD9Ibzho4MblBD2WmOQYsQyTY=",
+        "narHash": "sha256-XGfaHbFI4vvDuaoVO3IFYZKezXIO8rhUaMCGcjY71Ac=",
         "owner": "Gerg-L",
         "repo": "mnw",
-        "rev": "486a17ba1279ab2357cae8ff66b309db622f8831",
+        "rev": "c1f4587db4c53dcefa432c46c7a899a116d8e924",
         "type": "github"
       },
       "original": {
@@ -77,11 +77,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1748217807,
+        "lastModified": 1745377448,
-        "narHash": "sha256-P3u2PXxMlo49PutQLnk2PhI/imC69hFl1yY4aT5Nax8=",
+        "narHash": "sha256-jhZDfXVKdD7TSEGgzFJQvEEZ2K65UMiqW5YJ2aIqxMA=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "3108eaa516ae22c2360928589731a4f1581526ef",
+        "rev": "507b63021ada5fee621b6ca371c4fca9ca46f52c",
         "type": "github"
       },
       "original": {

flake.nix

@@ -18,7 +18,10 @@
       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

@@ -1,80 +0,0 @@
-{
-  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

@@ -1,38 +0,0 @@
-{
-  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,14 +3,13 @@
     pkgs,
     config,
     self',
-    inputs',
     ...
   }: {
     devShells = {
       default = self'.devShells.lsp;
       nvim-nix = pkgs.mkShellNoCC {packages = [config.packages.nix];};
       lsp = pkgs.mkShellNoCC {
-        packages = with pkgs; [inputs'.nil.packages.default statix deadnix alejandra npins];
+        packages = with pkgs; [nil statix deadnix alejandra npins];
       };
     };
 

flake/legacyPackages.nix

@@ -0,0 +1,35 @@
+{
+  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

@@ -0,0 +1,37 @@
+{
+  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

@@ -0,0 +1,19 @@
+{
+  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,8 +1,4 @@
-{
+{inputs, ...}: {
-  inputs,
-  self,
-  ...
-} @ args: {
   perSystem = {
     config,
     pkgs,
@@ -10,27 +6,8 @@
     ...
   }: 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;
@@ -84,9 +61,9 @@
         '';
 
       # Exposed neovim configurations
-      nix = buildPkg false;
+      nix = config.legacyPackages.neovim-nix;
-      maximal = buildPkg true;
+      maximal = config.legacyPackages.neovim-maximal;
-      default = config.packages.nix;
+      default = config.legacyPackages.neovim-nix;
     };
   };
 }

flake/templates/standalone/flake.nix

@@ -26,22 +26,12 @@
         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 self;};
+  types = import ./types {inherit lib;};
   config = import ./config.nix {inherit lib;};
   binds = import ./binds.nix {inherit lib;};
   dag = import ./dag.nix {inherit lib;};

lib/languages.nix

@@ -1,11 +1,10 @@
+# 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) listOf bool str submodule attrsOf anything either nullOr;
+  inherit (lib.types) bool;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) luaInline;
 in {
-  # TODO: remove
   diagnosticsToLua = {
     lang,
     config,
@@ -33,48 +32,4 @@ 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,9 +1,6 @@
-{
+{lib}: let
-  lib,
-  self,
-}: let
   typesDag = import ./dag.nix {inherit lib;};
-  typesPlugin = import ./plugins.nix {inherit lib self;};
+  typesPlugin = import ./plugins.nix {inherit lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
   customTypes = import ./custom.nix {inherit lib;};
 in {

lib/types/plugins.nix

@@ -1,7 +1,4 @@
-{
+{lib}: let
-  lib,
-  self,
-}: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
   inherit (lib.strings) hasPrefix removePrefix;
@@ -15,7 +12,7 @@
     mapAttrs' (n: v: nameValuePair (removePrefix prefix n) {src = v;}) (filterAttrs (n: _: hasPrefix prefix n) inputs);
 
   #  Get the names of all npins
-  pluginInputNames = ["blink-cmp"] ++ attrNames self.pins;
+  pluginInputNames = attrNames (lib.importJSON ../../npins/sources.json).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
-    scrollOffset = "scrolloff";
+    scrollOff = "scrolloff";
   };
 in {
   imports = concatLists [
@@ -111,15 +111,6 @@ 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,7 +33,6 @@
       "minimap"
       "notes"
       "projects"
-      "repl"
       "rich-presence"
       "runner"
       "session"

modules/neovim/init/basic.nix

@@ -6,10 +6,11 @@
   inherit (lib.options) mkOption mkEnableOption literalMD;
   inherit (lib.strings) optionalString;
   inherit (lib.attrsets) optionalAttrs;
-  inherit (lib.types) enum bool str either;
+  inherit (lib.types) enum bool str int 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;
@@ -21,12 +22,24 @@ 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";
@@ -131,6 +144,10 @@ 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

@@ -1,80 +0,0 @@
-{
-  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,11 +2,9 @@
   imports = [
     ./autocmds.nix
     ./basic.nix
-    ./clipboard.nix
     ./debug.nix
     ./diagnostics.nix
     ./highlight.nix
-    ./lsp.nix
     ./spellcheck.nix
   ];
 }

modules/neovim/init/lsp.nix

@@ -1,93 +0,0 @@
-{
-  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

@@ -1,325 +0,0 @@
-{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

@@ -1,41 +0,0 @@
-{
-  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

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

modules/plugins/assistant/codecompanion/config.nix

@@ -21,17 +21,7 @@ in {
         };
       };
 
-      treesitter = {
+      treesitter.enable = true;
-        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,6 +3,5 @@
     ./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" "cmdline"];
+        type = enum ["default" "none" "super-tab" "enter"];
         default = "none";
         description = "keymap presets";
       };
@@ -48,7 +48,7 @@ in {
       cmdline = {
         sources = mkOption {
           type = nullOr (listOf str);
-          default = null;
+          default = [];
           description = "List of sources to enable for cmdline. Null means use default source list.";
         };
 

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

@@ -122,21 +122,6 @@ 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,48 +683,15 @@ in {
               };
 
               git_placement = mkOption {
-                type = enum ["before" "after" "signcolumn" "right_align"];
+                type = enum ["before" "after" "signcolumn"];
+                description = "Place where the git icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
                 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" "right_align"];
+                type = enum ["before" "after" "signcolumn"];
+                description = "Place where the modified icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
                 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,9 +1,12 @@
-{lib, ...}: let
+{
-  inherit (lib.generators) mkLuaInline;
+  pkgs,
-  inherit (lib.options) mkOption mkEnableOption literalMD;
+  lib,
-  inherit (lib.types) attrs either nullOr;
+  ...
-  inherit (lib.nvim.lua) toLuaObject;
+}: let
-  inherit (lib.nvim.types) luaInline mkPluginSetupOption;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
+  inherit (lib.types) attrs enum nullOr;
+  inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.nvim.lua) mkLuaInline;
 in {
   options.vim.formatter.conform-nvim = {
     enable = mkEnableOption "lightweight yet powerful formatter plugin for Neovim [conform-nvim]";
@@ -28,44 +31,24 @@ in {
       };
 
       format_on_save = mkOption {
-        type = nullOr (either attrs luaInline);
+        type = nullOr attrs;
-        default = mkLuaInline ''
+        default = {
-          function()
+          lsp_format = "fallback";
-            if not vim.g.formatsave or vim.b.disableFormatSave then
+          timeout_ms = 500;
-              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 = ''
-          Attribute set or Lua function that will be passed to
+          Table that will be passed to `conform.format()`. If this
-          `conform.format()`. If this is set, Conform will run the formatter
+          is set, Conform will run the formatter on save.
-          on save.
         '';
       };
 
-      format_after_save = let
+      format_after_save = mkOption {
-        defaultFormatAfterSaveOpts = {lsp_format = "fallback";};
+        type = nullOr attrs;
-      in
+        default = {lsp_format = "fallback";};
-        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
+          Table that will be passed to `conform.format()`. If this
-            is set, Conform will run the formatter asynchronously after save.
+          is set, Conform will run the formatter asynchronously after
+          save.
         '';
       };
     };

modules/plugins/git/gitsigns/config.nix

@@ -81,11 +81,9 @@ in {
     (mkIf cfg.codeActions.enable {
       vim.lsp.null-ls = {
         enable = true;
-        setupOpts.sources = [
+        setupOpts.sources.gitsigns-ca = mkLuaInline ''
-          (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.lsp.enable;};
+      enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.languages.enableLSP;};
 
       package = mkOption {
         type = package;

modules/plugins/languages/astro.nix

@@ -81,7 +81,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Astro LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "clang LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
         description = "The clang LSP server to use";

modules/plugins/languages/clojure.nix

@@ -1,56 +0,0 @@
-{
-  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.lsp.enable;};
+        enable = mkEnableOption "C# LSP support" // {default = config.vim.languages.enableLSP;};
         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.lsp.enable;};
+      enable = mkEnableOption "CSS LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "CUE LSP support" // {default = config.vim.languages.enableLSP;};
 
       package = mkOption {
         type = package;

modules/plugins/languages/dart.nix

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

modules/plugins/languages/default.nix

@@ -1,5 +1,4 @@
 {lib, ...}: let
-  inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.nvim.languages) mkEnable;
 in {
   imports = [
@@ -9,7 +8,6 @@ in {
     ./cue.nix
     ./dart.nix
     ./clang.nix
-    ./clojure.nix
     ./css.nix
     ./elixir.nix
     ./fsharp.nix
@@ -46,13 +44,10 @@ in {
     ./wgsl.nix
     ./yaml.nix
     ./ruby.nix
-
-    # This is now a hard deprecation.
-    (mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])
   ];
 
   options.vim.languages = {
-    # Those are still managed by plugins, and should be enabled here.
+    enableLSP = mkEnable "LSP";
     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.lsp.enable;};
+      enable = mkEnableOption "Elixir LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+        enable = mkEnableOption "F# LSP support" // {default = config.vim.languages.enableLSP;};
         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.lsp.enable;};
+      enable = mkEnableOption "Gleam LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Go LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.languages.enableLSP;};
       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.lsp.enable;};
+      enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
       # 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.lsp.enable;};
+      enable = mkEnableOption "Helm LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.languages.enableLSP;};
       package = mkOption {
         description = "java language server package, or the command to run as a list of strings";
         example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';

modules/plugins/languages/julia.nix

@@ -78,7 +78,7 @@ in {
       lsp = {
         enable = mkOption {
           type = bool;
-          default = config.vim.lsp.enable;
+          default = config.vim.languages.enableLSP;
           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.lsp.enable;};
+      enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.languages.enableLSP;};
 
       package = mkOption {
         description = "LuaLS package, or the command to run as a list of strings";

modules/plugins/languages/markdown.nix

@@ -67,7 +67,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
         type = enum (attrNames servers);
@@ -130,18 +130,6 @@ 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 = {
@@ -187,13 +175,6 @@ 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.lsp.enable;};
+      enable = mkEnableOption "Nim LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
         description = "Nim LSP server to use";
         type = str;

modules/plugins/languages/nix.nix

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

modules/plugins/languages/ruby.nix

@@ -9,8 +9,6 @@
   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;
@@ -26,25 +24,7 @@
           flags = {
             debounce_text_changes = 150,
           },
-          cmd = ${
+          cmd = { "${pkgs.solargraph}/bin/solargraph", "stdio" }
-          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" }''
-        }
         }
       '';
     };
@@ -77,7 +57,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Ruby LSP support" // {default = config.vim.languages.enableLSP;};
 
       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 literalMD;
+  inherit (lib.options) mkOption mkEnableOption;
   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.lsp.enable;};
+      enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.languages.enableLSP;};
       package = mkOption {
         description = "rust-analyzer package, or the command to run as a list of strings";
         example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
@@ -68,14 +68,7 @@ in {
     };
 
     format = {
-      enable =
+      enable = mkEnableOption "Rust formatting" // {default = config.vim.languages.enableFormat;};
-        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.lsp.enable;};
+      enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.languages.enableLSP;};
       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.lsp.enable;};
+      enable = mkEnableOption "SQL LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Svelte LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
 
       package = mkOption {
         description = "terraform-ls package";

modules/plugins/languages/ts.nix

@@ -101,7 +101,6 @@
           "eslint.config.js"
           "eslint.config.mjs"
           ".eslintrc"
-          ".eslintrc.cjs"
           ".eslintrc.json"
           ".eslintrc.js"
           ".eslintrc.yml"
@@ -121,7 +120,7 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Vala LSP support" // {default = config.vim.languages.enableLSP;};
       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.lsp.enable;};
+      enable = mkEnableOption "WGSL LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "YAML LSP support" // {default = config.vim.languages.enableLSP;};
 
       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.lsp.enable;};
+      enable = mkEnableOption "Zig LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
         type = enum (attrNames servers);