Neovim: configure using lazy.nvim

modules/editor/vim.nix

@@ -152,6 +152,11 @@ in {
         };
 
         keymaps = [
+          # Search
+          {
+            key = "<leader><leader>";
+            action = "<CMD>Telescope fd layout_strategy=vertical<CR>";
+          }
           {
             key = "<leader>sh";
             action = "<CMD>Telescope help_tags<CR>";
@@ -169,28 +174,20 @@ in {
           }
           {
             key = "<leader>/";
-            action = "<CMD>Telescope live_grep<CR>";
+            action = "<CMD>Telescope live_grep layout_strategy=vertical<CR>";
-            options.desc = "[S]earch by [G]rep";
+            options.desc = "Search with rg";
           }
           {
             key = "<leader>sr";
             action = "<CMD>Telescope resume<CR>";
             options.desc = "[S]earch [R]esume";
           }
-          {
-            key = "<leader>.";
-            action.__raw = /*lua*/''
-              function()
-                require("yazi").yazi()
-              end
-            '';
-            options.desc = "Open file manager";
-          }
           {
             key = "<leader>cx";
-            action = "<CMD>Telescope diagnostics<CR>";
+            action = "<CMD>Telescope diagnostics layout_strategy=vertical<CR>";
             options.desc = "Search diagnostics";
           }
+          # File
           {
             key = "<leader>fs";
             action.__raw = /*lua*/''
@@ -201,22 +198,27 @@ in {
             '';
             options.desc = "Format and save buffer";
           }
+          {
+            mode = "n";
+            key = "<leader>fn";
+            action = "<CMD>enew<CR>";
+            options.desc = "New File";
+          }
+          # Project
           {
             key = "<leader>ps";
             action = "<CMD>wa<CR>";
             options.desc = "Save all buffers";
           }
+          # Git
           {
             key = "<leader>gg";
             action = "<CMD>Neogit<CR>";
           }
-          {
+          # Buffers
-            key = "<leader><leader>";
-            action = "<CMD>Telescope fd<CR>";
-          }
           {
             key = "<leader>bb";
-            action = "<CMD>Telescope buffers<CR>";
+            action = "<CMD>Telescope buffers layout_strategy=vertical<CR>";
           }
           {
             key = "<leader>bn";
@@ -235,217 +237,557 @@ in {
           }
           {
             key = "<leader>bk";
-            action = "<CMD>bdel<CR>";
+            action = "<CMD>bd<CR>";
-            options.desc = "Delete buffer";
+            options.desc = "Delete buffer and Window";
           }
           {
             key = "<leader>bd";
-            action = "<CMD>bdel<CR>";
+            action = "<CMD>bd<CR>";
-            options.desc = "Delete buffer";
+            options.desc = "Delete buffer and Window";
+          }
+          # Windows
+          {
+            mode = "n";
+            key = "<leader>ww";
+            action = "<C-w>p";
+            options = { desc = "Other Window"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<leader>wd";
+            action = "<C-w>c";
+            options = { desc = "Delete Window"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<leader>ws";
+            action = "<C-w>s";
+            options = { desc = "Split Window Below"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<leader>wv";
+            action = "<C-w>v";
+            options = { desc = "Split Window Right"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<c-j>";
+            action = "<C-w>j";
+            options = { desc = "Go to Lower Winddow"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<leader>wj";
+            action = "<C-w>j";
+            options = { desc = "Go to Lower Winddow"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<c-k>";
+            action = "<C-w>k";
+            options = { desc = "Go to Upper Winddow"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<leader>wk";
+            action = "<C-w>k";
+            options = { desc = "Go to Upper Winddow"; remap = true; };
+          }
+          {
+            mode = "n";
+            key = "<c-l>";
+            action = "<C-w>l";
+            options = { desc = "Go to Right Winddow"; remap = true; };
+          }
+          # Move lines
+          {
+            mode = "n";
+            key = "<A-j>";
+            action = "<cmd>m .+1<cr>==";
+            options.desc = "Move Down";
+          }
+          {
+            mode = "n";
+            key = "<A-k>";
+            action = "<cmd>m .-2<cr>==";
+            options.desc = "Move Up";
+          }
+          {
+            mode = "i";
+            key = "<A-j>";
+            action = "<esc><cmd>m .+1<cr>==gi";
+            options.desc = "Move Down";
+          }
+          {
+            mode = "i";
+            key = "<A-k>";
+            action = "<esc><cmd>m .-2<cr>==gi";
+            options.desc = "Move Up";
+          }
+          {
+            mode = "v";
+            key = "<A-j>";
+            action = ":m '>+1<cr>gv=gv";
+            options.desc = "Move Down";
+          }
+          {
+            mode = "v";
+            key = "<A-k>";
+            action = ":m '<-2<cr>gv=gv";
+            options.desc = "Move Up";
+          }
+          # Better indenting
+          {
+            mode = "v";
+            key = "<";
+            action = "<gv";
+          }
+          {
+            mode = "v";
+            key = ">";
+            action = ">gv";
           }
         ];
 
         plugins = {
-          lualine = {
+          lazy = {
             enable = true;
-          };
+            plugins = [
-          cmp = {
+              {
-            enable = true;
+                pkg = pkgs.vimPlugins.mini-nvim;
-            settings = {
+                event = "VeryLazy";
-              sources =
+                opts.__raw = /*lua*/ ''
-                [
+                  {
-                  { name = "nvim_lsp"; }
+                    modes = { insert = true, command = true, terminal = false },
-                  { name = "path"; }
+                    -- skip autopair when next character is one of these
-                  { name = "buffer"; }
+                    skip_next = [=[[%w%%%'%[%"%.%`%$]]=],
-                  { name = "cmdline"; }
+                    -- skip autopair when the cursor is inside these treesitter nodes
+                    skip_ts = { "string" },
+                    -- skip autopair when next character is closing pair
+                    -- and there are more closing pairs than opening pairs
+                    skip_unbalanced = true,
+                    -- better deal with markdown code blocks
+                    markdown = true,
+                  }
+                '';
+                config = /*lua*/ ''
+                  function (_, opts)
+                    local pairs = require("mini.pairs")
+                    pairs.setup(opts)
+                    local open = pairs.open
+                    pairs.open = function(pair, neigh_pattern)
+                      if vim.fn.getcmdline() ~= "" then
+                        return open(pair, neigh_pattern)
+                      end
+                      local o, c = pair:sub(1, 1), pair:sub(2, 2)
+                      local line = vim.api.nvim_get_current_line()
+                      local cursor = vim.api.nvim_win_get_cursor(0)
+                      local next = line:sub(cursor[2] + 1, cursor[2] + 1)
+                      local before = line:sub(1, cursor[2])
+                      if opts.markdown and o == "`" and vim.bo.filetype == "markdown" and before:match("^%s*``") then
+                        return "`\n```" .. vim.api.nvim_replace_termcodes("<up>", true, true, true)
+                      end
+                      if opts.skip_next and next ~= "" and next:match(opts.skip_next) then
+                        return o
+                      end
+                      if opts.skip_ts and #opts.skip_ts > 0 then
+                        local ok, captures = pcall(vim.treesitter.get_captures_at_pos, 0, cursor[1] - 1, math.max(cursor[2] - 1, 0))
+                        for _, capture in ipairs(ok and captures or {}) do
+                          if vim.tbl_contains(opts.skip_ts, capture.capture) then
+                            return o
+                          end
+                        end
+                      end
+                      if opts.skip_unbalanced and next == c and c ~= o then
+                        local _, count_open = line:gsub(vim.pesc(pair:sub(1, 1)), "")
+                        local _, count_close = line:gsub(vim.pesc(pair:sub(2, 2)), "")
+                        if count_close > count_open then
+                          return o
+                        end
+                      end
+                      return open(pair, neigh_pattern)
+                    end
+                  end
+                '';
+              }
+              {
+                pkg = pkgs.vimPlugins.lualine-nvim;
+                event = "VeryLazy";
+                init = /*lua*/ ''
+                  function()
+                    vim.g.lualine_laststatus = vim.o.laststatus
+                    if vim.fn.argc(-1) > 0 then
+                      -- set an empty statusline till lualine loads
+                      vim.o.statusline = " "
+                    else
+                      -- hide the statusline on the starter page
+                      vim.o.laststatus = 0
+                    end
+                  end
+                '';
+                opts.__raw = /*lua*/ ''
+                  {
+                    options = {
+                      icons_enabled = true,
+                    }
+                  }
+                '';
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.neogit;
+                dependencies = [ pkgs.vimPlugins.plenary-nvim pkgs.vimPlugins.diffview-nvim pkgs.vimPlugins.telescope-nvim ];
+                event = "VeryLazy";
+                config = true;
+              }
+              {
+                pkg = pkgs.vimPlugins.gitsigns-nvim;
+                opts.__raw = /*lua*/ ''
+                  {
+                    on_attach = function(buffer)
+                      local gs = package.loaded.gitsigns
+
+                      local function map(mode, l ,r, desc)
+                        vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc})
+                      end
+
+                      map("n", "<leader>h;", function()
+                        if vim.wo.diff then
+                          vim.cmd.normal({ "]c", bang = true })
+                        else
+                          gs.nav_hunk("next")
+                        end
+                      end, "Next Hunk")
+                      map("n", "<leader>h,", function()
+                        if vim.wo.diff then
+                          vim.cmd.normal({ "[c", bang = true })
+                        else
+                          gs.nav_hunk("prev")
+                        end
+                      end, "Prev Hunk")
+                      map({ "n", "v" }, "<leader>gs", gs.stage_hunk, "Stage Hunk")
+                      map({ "n", "v" }, "<leader>gr", gs.reset_hunk, "Reset Hunk")
+                      map("n", "<leader>gS", gs.stage_buffer, "Stage Buffer")
+                      map("n", "<leader>gu", gs.undo_stage_hunk, "Undo Stage Hunk")
+                      map("n", "<leader>gR", gs.reset_buffer, "Reset Buffer")
+                      map("n", "<leader>gp", gs.preview_hunk_inline, "Preview Hunk Inline")
+                      map("n", "<leader>gb", function() gs.blame_line({ full = true }) end, "Blame Line")
+                      map("n", "<leader>gd", gs.diffthis, "Diff This")
+                      map("n", "<leader>gD", function() gs.diffthis("~") end, "Diff This ~")
+                      map('n', '<leader>tb', gs.toggle_current_line_blame, "Toggle current line blame")
+                      map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
+                    end,
+                  }
+                '';
+              }
+              {
+                pkg =
+                  (pkgs.vimUtils.buildVimPlugin {
+                    name = "yazi.nvim";
+                    src = inputs.vim-yazi;
+                  });
+                event = "VeryLazy";
+                keys.__raw = /*lua*/ ''
+                  {
+                    { "<leader>.", function() require("yazi").yazi() end, desc = "Open file manager" },
+                    { "<bs>", desc = "Decrement Selection", mode = "x" },
+                  }
+                '';
+                opts.__raw = /*lua*/ ''
+                  {
+                    open_for_directories = true,
+                  }
+                '';
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.fidget-nvim;
+                opts.__raw = /*lua*/ ''
+                  {
+                    logger = { level = vim.log.levels.WARN },
+                    notification = { filter = vim.log.levels.INFO },
+                  }
+                '';
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.indent-blankline-nvim;
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.vim-sleuth;
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.comment-nvim;
+              }
+              {
+                pkg = pkgs.vimPlugins.leap-nvim;
+                config = /*lua*/ ''
+                  function (_, opts)
+                    local leap = require("leap")
+                    for k, v in pairs(opts) do
+                      leap.opts[k] = v
+                    end
+                    leap.add_default_mappings(true)
+                  end
+                '';
+              }
+              {
+                pkg = pkgs.vimPlugins.telescope-nvim;
+                dependencies = [
+                  pkgs.vimPlugins.plenary-nvim
+                  pkgs.vimPlugins.nvim-web-devicons
+                  pkgs.vimPlugins.telescope-ui-select-nvim
+                  pkgs.vimPlugins.telescope-fzf-native-nvim
                 ];
-              mapping = {
+                opts.__raw = /*lua*/ ''
-                "<CR>" = "cmp.mapping.confirm({ select = true })";
+                  {
-                "<C-Space>" = "cmp.mapping.complete()";
+                    defaults = {
-                "<C-u>" = "cmp.mapping.scroll_docs(-4)";
+                      layout_config = {
-                "<C-e>" = "cmp.mapping.close()";
+                        vertical = { width = 0.9 }
-                "<C-d>" = "cmp.mapping.scroll_docs(4)";
+                      },
-                "<S-Tab>" = "cmp.mapping(cmp.mapping.select_prev_item(), {'i', 's'})";
+                    },
-                "<Tab>" = "cmp.mapping(cmp.mapping.select_next_item(), {'i', 's'})";
+                  }
-              };
+                '';
-            };
+              }
-          };
+              {
-          gitgutter.enable = true;
+                pkg = pkgs.vimPlugins.nvim-treesitter.withAllGrammars;
-          leap.enable = true;
+                lazy.__raw = "vim.fn.argc(-1) == 0";
-          fidget.enable = true;
+                init = /*lua*/ ''
-          neogit = {
+                  function(plugin)
-            enable = true;
+                    -- PERF: add nvim-treesitter queries to the rtp and it's custom query predicates early
-            package = pkgs.unstable.vimPlugins.neogit;
+                    -- This is needed because a bunch of plugins no longer `require("nvim-treesitter")`, which
-          };
+                    -- no longer trigger the **nvim-treesitter** module to be loaded in time.
-          sleuth.enable = true;
+                    -- Luckily, the only things that those plugins need are the custom queries, which we make available
-          comment.enable = true;
+                    -- during startup.
-          direnv.enable = true;
+                    require("lazy.core.loader").add_to_rtp(plugin)
-          nix.enable = true;
+                    require("nvim-treesitter.query_predicates")
-          treesitter = {
+                  end
-            enable = true;
+                '';
-            indent = true;
+                cmd = [ "TSUpdateSync" "TSUpdate" "TSInstall" ];
-            incrementalSelection.enable = true;
+                keys.__raw = /*lua*/ ''
-            ignoreInstall = [ "org" ];
+                  {
-          };
+                    { "<c-space>", desc = "Increment Selection" },
-          telescope = {
+                    { "<bs>", desc = "Decrement Selection", mode = "x" },
-            enable = true;
+                  }
-            extensions.fzf-native.enable = true;
+                '';
-            extensions.ui-select.enable = true;
+                opts.__raw = /*lua*/ ''
-          };
+                  {
-          which-key = {
+                    highlight = { enable = true },
-            enable = true;
+                    indent = { enable = true },
-            registrations = {
+                    ensure_installed = "all",
-              "<leader>b".name = "[B]uffer";
+                    parser_install_dir = vim.fs.joinpath(vim.fn.stdpath('data'), 'site'),
-              "<leader>c".name = "[C]ode";
+                    incremental_selection = {
-              "<leader>d".name = "[D]ocument";
+                      enable = true,
-              "<leader>f".name = "[F]ile";
+                      keymaps = {
-              "<leader>g".name = "[G]it";
+                        init_selection = "<C-space>",
-              "<leader>r".name = "[R]ename";
+                        node_incremental = "<C-space>",
-              "<leader>s".name = "[S]earch";
+                        scope_incremental = false,
-              "<leader>w".name = "[W]orkspace";
+                        node_decremental = "<bs>",
-              "<leader>t".name = "[T]oggle";
+                      },
-              "<leader>h".name = "Git [H]unk";
+                    },
-            };
+                    ignore_install = { "org" },
-          };
+                  }
-          lsp = {
+                '';
-            enable = true;
+                config = /*lua*/ ''
-            servers = {
+                  function (_, opts)
-              ansiblels.enable = true;
+                    require("nvim-treesitter.configs").setup(opts)
-              bashls.enable = true;
+                    vim.opt.runtimepath:prepend(vim.fs.joinpath(vim.fn.stdpath('data'), 'site'))
-              cssls.enable = true;
+                  end
-              docker-compose-language-service.enable = true;
+                '';
-              dockerls.enable = true;
+              }
-              eslint.enable = true;
+              {
-              nixd.enable = true;
+                pkg = pkgs.unstable.vimPlugins.which-key-nvim;
-              html.enable = true;
+                event = "VimEnter";
-              lua-ls.enable = true;
+                config = /*lua*/ ''
-              marksman.enable = true;
+                  function ()
-              sqls.enable = true;
+                    require('which-key').setup()
-              terraformls.enable = true;
+                    require('which-key').register {
-              tsserver.enable = true;
+                      ['<leader>b'] = { name = 'Buffer', _ = 'which_key_ignore' },
-              jsonls.enable = true;
+                      ['<leader>c'] = { name = 'Code', _ = 'which_key_ignore' },
-              yamlls.enable = true;
+                      ['<leader>d'] = { name = 'Document', _ = 'which_key_ignore' },
-              typos-lsp = {
+                      ['<leader>f'] = { name = 'File', _ = 'which_key_ignore' },
-                enable = true;
+                      ['<leader>g'] = { name = 'Git', _ = 'which_key_ignore' },
-                extraOptions.init_options.diagnosticSeverity = "Hint";
+                      ['<leader>o'] = { name = 'Org', _ = 'which_key_ignore' },
-              };
+                      ['<leader>n'] = { name = 'Org-roam', _ = 'which_key_ignore' },
-            };
+                      ['<leader>p'] = { name = 'Project', _ = 'which_key_ignore' },
-            keymaps = {
+                      ['<leader>r'] = { name = 'Rename', _ = 'which_key_ignore' },
-              silent = true;
+                      ['<leader>s'] = { name = 'Search', _ = 'which_key_ignore' },
-              lspBuf = {
+                      ['<leader>w'] = { name = 'Window', _ = 'which_key_ignore' },
-                gd = {
+                      ['<leader>t'] = { name = 'Toggle', _ = 'which_key_ignore' },
-                  action = "definition";
+                    }
-                  desc = "Goto Definition";
+                  end
-                };
+                '';
-                gr = {
+              }
-                  action = "references";
+              {
-                  desc = "Goto References";
+                pkg = pkgs.vimPlugins.nvim-lspconfig;
-                };
+                config = /*lua*/ ''
-                gD = {
+                  function ()
-                  action = "declaration";
+                    vim.api.nvim_create_autocmd('LspAttach', {
-                  desc = "Goto Declaration";
+                      group = vim.api.nvim_create_augroup('lsp-attach', { clear = true }),
-                };
+                      callback = function(event)
-                gI = {
+                        local map = function(keys, func, desc)
-                  action = "implementation";
+                          vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
-                  desc = "Goto Implementation";
+                        end
-                };
+
-                gT = {
+                        map('gd', require('telescope.builtin').lsp_definitions, 'Go to definition')
-                  action = "type_definition";
+                        map('gr', require('telescope.builtin').lsp_references, 'Go to references')
-                  desc = "Type Definition";
+                        map('gI', require('telescope.builtin').lsp_implementations, 'Goto implementation')
-                };
+                        map('gD', vim.lsp.buf.declaration, 'Go to declaration')
-                K = {
+                        map('gT', require('telescope.builtin').lsp_type_definitions, 'Type definition')
-                  action = "hover";
+                        map('<leader>cD', require('telescope.builtin').lsp_document_symbols, 'Document symbols')
-                  desc = "Hover";
+                        map('<leader>cw', require('telescope.builtin').lsp_dynamic_workspace_symbols, 'Workspace symbols ')
-                };
+                        map('<leader>cd', vim.diagnostic.open_float, 'Line diagnostics')
-                "<leader>cw" = {
+                        map('<leader>c,', vim.diagnostic.goto_prev, 'Previous diagnostics')
-                  action = "workspace_symbol";
+                        map('<leader>c;', vim.diagnostic.goto_next, 'Next diagnostics')
-                  desc = "Workspace Symbol";
+                        map('<leader>cr', vim.lsp.buf.rename, 'Rename')
-                };
+                        map('<leader>ca', vim.lsp.buf.code_action, 'Code action')
-                "<leader>cr" = {
+                        map('K', vim.lsp.buf.hover, 'Hover Documentation')
-                  action = "rename";
+                      end
-                  desc = "Rename";
+                    })
-                };
+
-              };
+                    local has_cmp, cmp_nvim_lsp = pcall(require, "cmp_nvim_lsp")
-              diagnostic = {
+                    local capabilities = vim.tbl_deep_extend(
-                "<leader>cd" = {
+                      "force",
-                  action = "open_float";
+                      {},
-                  desc = "Line Diagnostics";
+                      vim.lsp.protocol.make_client_capabilities(),
-                };
+                      has_cmp and cmp_nvim_lsp.default_capabilities() or {}
-                "[d" = {
+                    )
-                  action = "goto_next";
+
-                  desc = "Next Diagnostic";
+                    local function setup(server, server_opts)
-                };
+                      local server_opts_with_caps = vim.tbl_deep_extend("force", {
-                "]d" = {
+                        capabilities = vim.deepcopy(capabilities),
-                  action = "goto_prev";
+                      }, server_opts)
-                  desc = "Previous Diagnostic";
+
-                };
+                      require("lspconfig")[server].setup(server_opts_with_caps)
-              };
+                    end
-            };
+
+                    setup("yamlls", {})
+                    setup("typos_lsp", {
+                      init_options = { diagnosticSeverity = "Hint" }
+                    })
+                    setup("tsserver", {})
+                    setup("terraformls", {})
+                    setup("sqls", {})
+                    setup("nixd", {})
+                    setup("marksman", {})
+                    setup("lua_ls", {})
+                    setup("jsonls", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-json-language-server", "--stdio" } })
+                    setup("html", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-html-language-server", "--stdio" } })
+                    setup("eslint", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-eslint-language-server", "--stdio" } })
+                    setup("dockerls", { cmd = { "${pkgs.dockerfile-language-server-nodejs}/bin/docker-langserver", "--stdio" } })
+                    setup("docker_compose_language_service", {})
+                    setup("cssls", { cmd = { "${pkgs.vscode-langservers-extracted}/bin/vscode-css-language-server", "--stdio" } })
+                    setup("bashls", {})
+                    setup("ansiblels", { cmd = { "${pkgs.ansible-language-server}/bin/ansible-language-server", "--stdio" } })
+                  end
+                '';
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.nvim-metals;
+                dependencies = [ pkgs.vimPlugins.plenary-nvim ];
+                ft = [ "scala" "sbt" ];
+                opts.__raw = /*lua*/ ''
+                  function()
+                    local metals_config = require("metals").bare_config()
+                    metals_config.on_attach = function(client, bufnr)
+                      vim.keymap.set(
+                        "n",
+                        "<leader>me",
+                        function() require("telescope").extensions.metals.commands() end,
+                        { noremap=true, silent=true, buffer = bufn, desc = "Metals commands"}
+                      )
+                      vim.keymap.set(
+                        "n",
+                        "<leader>co",
+                        "<CMD>MetalsOrganizeImports<CR>",
+                        { noremap=true, silent=true, buffer = bufn, desc = "Organize imports"}
+                      )
+                    end
+                    metals_config.init_options.statusBarProvider = "off"
+                    metals_config.settings = {
+                        showImplicitArguments = true,
+                    }
+                    return metals_config
+                  end
+                '';
+                config = /*lua*/ ''
+                  function (self, metals_config)
+                    local nvim_metals_group = vim.api.nvim_create_augroup("nvim-metals", { clear = true })
+                    vim.api.nvim_create_autocmd("FileType", {
+                      pattern = self.ft,
+                      callback = function()
+                        require("metals").initialize_or_attach(metals_config)
+                      end,
+                      group = nvim_metals_group,
+                    })
+                  end
+                '';
+              }
+              {
+                pkg = pkgs.unstable.vimPlugins.nvim-cmp;
+                event = "InsertEnter";
+                dependencies = [
+                  pkgs.unstable.vimPlugins.cmp-nvim-lsp
+                  pkgs.unstable.vimPlugins.cmp-path
+                  pkgs.unstable.vimPlugins.cmp-buffer
+                ];
+                opts.__raw = /*lua*/ ''
+                  function()
+                    local cmp = require("cmp")
+                    return {
+                      mapping = {
+                          ["<C-Space>"] = cmp.mapping.complete(),
+                          ["<C-b>"] = cmp.mapping.scroll_docs(-4),
+                          ["<C-e>"] = cmp.mapping.close(),
+                          ["<C-f>"] = cmp.mapping.scroll_docs(4),
+                          ["<CR>"] = cmp.mapping.confirm({ select = true }),
+                          ["<C-y>"] = cmp.mapping.confirm({ select = true }),
+                          ["<S-Tab>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "s" }),
+                          ["<Tab>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "s" }),
+                      },
+                      sources = {
+                        { name = "nvim_lsp" },
+                        { name = "path" },
+                        { name = "buffer" },
+                        { name = "orgmode" },
+                      },
+                    }
+                  end
+                '';
+              }
+
+              # Disabled for now as it tries to write org grammar to its own directory in the nix store
+              # https://github.com/nvim-orgmode/orgmode/blob/95fb795a422f0455e03d13a3f83525f1d00793ad/lua/orgmode/utils/treesitter/install.lua#L9
+              # {
+              #   pkg = pkgs.unstable.vimPlugins.orgmode;
+              #   event = "VeryLazy";
+              #   ft = [ "org" ];
+              #   config = /*lua*/ ''
+              #     function ()
+              #       require('orgmode').setup({
+              #         org_agend_files = '~/Nextcloud/Org/**/*',
+              #         org_default_notes_file = '~/Nextcloud/Org/refile.org',
+              #       })
+              #     end
+              #   '';
+              # }
+              # {
+              #   pkg = (pkgs.vimUtils.buildVimPlugin {
+              #     name = "org-roam.nvim";
+              #     src = inputs.vim-org-roam;
+              #   });
+              #   dependencies = [ pkgs.unstable.vimPlugins.orgmode ];
+              #   event = "VeryLazy";
+              #   ft = [ "org" ];
+              #   config = /*lua*/ ''
+              #     function ()
+              #       require('org-roam').setup({
+              #         directory = '~/Nextcloud/OrgRoam',
+              #       })
+              #     end
+              #   '';
+              # }
+            ];
           };
         };
-        extraPlugins = [
-          pkgs.unstable.vimPlugins.vim-airline-themes
-          pkgs.unstable.vimPlugins.nvim-metals
-          (pkgs.vimUtils.buildVimPlugin {
-            name = "yazi.nvim";
-            src = inputs.vim-yazi;
-          })
-          pkgs.unstable.vimPlugins.orgmode
-          (pkgs.vimUtils.buildVimPlugin {
-            name = "org-roam.nvim";
-            src = inputs.vim-org-roam;
-          })
-        ];
-        extraConfigLua = /*lua*/
-          ''
-            require('yazi').setup({
-              opts = {
-                open_for_directories = true,
-              },
-            })
-
-
-            require('orgmode').setup({
-              org_agend_files = '~/Nextcloud/Org/**/*',
-              org_default_notes_file = '~/Nextcloud/Org/refile.org',
-            })
-            require('org-roam').setup({
-              directory = '~/Nextcloud/OrgRoam',
-            })
-
-
-            local metals_config = require("metals").bare_config()
-
-            metals_config.init_options.statusBarProvider = "off"
-
-            metals_config.settings = {
-              showImplicitArguments = true,
-            }
-
-            metals_config.on_attach = function(client, bufnr)
-              vim.keymap.set(
-                "n",
-                "<leader>me",
-                function() require("telescope").extensions.metals.commands() end,
-                { noremap=true, silent=true, buffer = bufn, desc = "Metals commands"}
-              )
-              vim.keymap.set(
-                "n",
-                "<leader>co",
-                "<CMD>MetalsOrganizeImports<CR>",
-                { noremap=true, silent=true, buffer = bufn, desc = "Organize imports"}
-              )
-            end
-
-            local nvim_metals_group = vim.api.nvim_create_augroup("nvim-metals", { clear = true })
-            vim.api.nvim_create_autocmd("FileType", {
-              pattern = { "scala", "sbt", "java" },
-              callback = function()
-                require("metals").initialize_or_attach(metals_config)
-              end,
-              group = nvim_metals_group,
-            })
-          '';
         colorschemes.gruvbox = {
           enable = true;
           package = pkgs.unstable.vimPlugins.gruvbox-nvim;
@@ -481,7 +823,18 @@ in {
         nixfmt-rfc-style
         nixpkgs-fmt
         coursier
-        nil
+
+        # LSP
+        yaml-language-server
+        typos-lsp
+        nodePackages.typescript-language-server
+        terraform-ls
+        sqls
+        nixd
+        marksman
+        lua-language-server
+        docker-compose-language-service
+        bash-language-server
       ];
     };
   };