chore(main): release 8.4.0 (#1564)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

README-CN.md

@@ -54,9 +54,10 @@ LazyVim 提供了两全其美的方式 - 根据需要调整配置的灵活性，
 
 ## ⚡️ 要求
 
-- Neovim >= **0.8.0** (需要用 **LuaJIT** 构建)
+- Neovim >= **0.9.0** (需要用 **LuaJIT** 构建)
 - Git >= **2.19.0** (用于部分克隆支持)
 - 一个 [Nerd Font](https://www.nerdfonts.com/) 字体 **_(可选)_**
+- 一个用于 `nvim-treesitter` 的 **C** 编译器。看 [这里](https://github.com/nvim-treesitter/nvim-treesitter#requirements)
 
 ## 🚀 入门
 

README.md

@@ -56,9 +56,10 @@ to tweak your config as needed, along with the convenience of a pre-configured s
 
 ## ⚡️ Requirements
 
-- Neovim >= **0.8.0** (needs to be built with **LuaJIT**)
+- Neovim >= **0.9.0** (needs to be built with **LuaJIT**)
 - Git >= **2.19.0** (for partial clones support)
 - a [Nerd Font](https://www.nerdfonts.com/) **_(optional)_**
+- a **C** compiler for `nvim-treesitter`. See [here](https://github.com/nvim-treesitter/nvim-treesitter#requirements)
 
 ## 🚀 Getting Started
 

doc/LazyVim.txt

@@ -1,4 +1,4 @@
-*LazyVim.txt*           For Neovim >= 0.8.0           Last change: 2023 May 12
+*LazyVim.txt*         For Neovim >= 0.8.0         Last change: 2023 October 03
 
 ==============================================================================
 Table of Contents                                  *LazyVim-table-of-contents*
@@ -52,9 +52,10 @@ FEATURES                                                    *LazyVim-features*
 
 REQUIREMENTS                                            *LazyVim-requirements*
 
-- Neovim >= **0.8.0** (needs to be built with **LuaJIT**)
+- Neovim >= **0.9.0** (needs to be built with **LuaJIT**)
 - Git >= **2.19.0** (for partial clones support)
 - a Nerd Font <https://www.nerdfonts.com/> **(optional)**
+- a **C** compiler for `nvim-treesitter`. See here <https://github.com/nvim-treesitter/nvim-treesitter#requirements>
 
 
 GETTING STARTED                                      *LazyVim-getting-started*

lua/lazyvim/config/autocmds.lua

@@ -1,4 +1,4 @@
--- This file is automatically loaded by plugins.init
+-- This file is automatically loaded by lazyvim.config.init.
 
 local function augroup(name)
   return vim.api.nvim_create_augroup("lazyvim_" .. name, { clear = true })
@@ -22,7 +22,9 @@ vim.api.nvim_create_autocmd("TextYankPost", {
 vim.api.nvim_create_autocmd({ "VimResized" }, {
   group = augroup("resize_splits"),
   callback = function()
+    local current_tab = vim.fn.tabpagenr()
     vim.cmd("tabdo wincmd =")
+    vim.cmd("tabnext " .. current_tab)
   end,
 })
 
@@ -30,8 +32,13 @@ vim.api.nvim_create_autocmd({ "VimResized" }, {
 vim.api.nvim_create_autocmd("BufReadPost", {
   group = augroup("last_loc"),
   callback = function()
-    local mark = vim.api.nvim_buf_get_mark(0, '"')
-    local lcount = vim.api.nvim_buf_line_count(0)
+    local exclude = { "gitcommit" }
+    local buf = vim.api.nvim_get_current_buf()
+    if vim.tbl_contains(exclude, vim.bo[buf].filetype) then
+      return
+    end
+    local mark = vim.api.nvim_buf_get_mark(buf, '"')
+    local lcount = vim.api.nvim_buf_line_count(buf)
     if mark[1] > 0 and mark[1] <= lcount then
       pcall(vim.api.nvim_win_set_cursor, 0, mark)
     end
@@ -48,10 +55,14 @@ vim.api.nvim_create_autocmd("FileType", {
     "man",
     "notify",
     "qf",
+    "query",
     "spectre_panel",
     "startuptime",
     "tsplayground",
+    "neotest-output",
     "checkhealth",
+    "neotest-summary",
+    "neotest-output-panel",
   },
   callback = function(event)
     vim.bo[event.buf].buflisted = false

lua/lazyvim/config/init.lua

@@ -19,6 +19,9 @@ local defaults = {
   },
   -- icons used by other plugins
   icons = {
+    misc = {
+      dots = "󰇘",
+    },
     dap = {
       Stopped = { "󰁕 ", "DiagnosticWarn", "DapStoppedLine" },
       Breakpoint = " ",
@@ -44,7 +47,7 @@ local defaults = {
       Color = " ",
       Constant = " ",
       Constructor = " ",
-      Copilot = " ",
+      Copilot = " ",
       Enum = " ",
       EnumMember = " ",
       Event = " ",
@@ -79,6 +82,8 @@ local defaults = {
 
 M.renames = {
   ["windwp/nvim-spectre"] = "nvim-pack/nvim-spectre",
+  ["jose-elias-alvarez/null-ls.nvim"] = "nvimtools/none-ls.nvim",
+  ["null-ls.nvim"] = "none-ls.nvim",
 }
 
 ---@type LazyVimConfig
@@ -87,6 +92,21 @@ local options
 ---@param opts? LazyVimConfig
 function M.setup(opts)
   options = vim.tbl_deep_extend("force", defaults, opts or {})
+
+  if vim.fn.has("nvim-0.9.0") == 0 then
+    vim.api.nvim_echo({
+      {
+        "LazyVim requires Neovim >= 0.9.0\n",
+        "ErrorMsg",
+      },
+      { "Press any key to exit", "MoreMsg" },
+    }, true, {})
+
+    vim.fn.getchar()
+    vim.cmd([[quit]])
+    return
+  end
+
   if not M.has() then
     require("lazy.core.util").error(
       "**LazyVim** needs **lazy.nvim** version "
@@ -98,22 +118,23 @@ function M.setup(opts)
     error("Exiting")
   end
 
-  if vim.fn.argc(-1) == 0 then
-    -- autocmds and keymaps can wait to load
-    vim.api.nvim_create_autocmd("User", {
-      group = vim.api.nvim_create_augroup("LazyVim", { clear = true }),
-      pattern = "VeryLazy",
-      callback = function()
-        M.load("autocmds")
-        M.load("keymaps")
-      end,
-    })
-  else
-    -- load them now so they affect the opened buffers
+  -- autocmds can be loaded lazily when not opening a file
+  local lazy_autocmds = vim.fn.argc(-1) == 0
+  if not lazy_autocmds then
     M.load("autocmds")
-    M.load("keymaps")
   end
 
+  vim.api.nvim_create_autocmd("User", {
+    group = vim.api.nvim_create_augroup("LazyVim", { clear = true }),
+    pattern = "VeryLazy",
+    callback = function()
+      if lazy_autocmds then
+        M.load("autocmds")
+      end
+      M.load("keymaps")
+    end,
+  })
+
   require("lazy.core.util").try(function()
     if type(M.colorscheme) == "function" then
       M.colorscheme()
@@ -161,6 +182,8 @@ function M.load(name)
     -- HACK: LazyVim may have overwritten options of the Lazy ui, so reset this here
     vim.cmd([[do VimResized]])
   end
+  local pattern = "LazyVim" .. name:sub(1, 1):upper() .. name:sub(2)
+  vim.api.nvim_exec_autocmds("User", { pattern = pattern, modeline = false })
 end
 
 M.did_init = false
@@ -178,6 +201,14 @@ function M.init()
     local add = Plugin.Spec.add
     Plugin.Spec.add = function(self, plugin, ...)
       if type(plugin) == "table" and M.renames[plugin[1]] then
+        require("lazy.core.util").warn(
+          ("Plugin `%s` was renamed to `%s`.\nPlease update your config for `%s`"):format(
+            plugin[1],
+            M.renames[plugin[1]],
+            self.importing or "LazyVim"
+          ),
+          { title = "LazyVim" }
+        )
         plugin[1] = M.renames[plugin[1]]
       end
       return add(self, plugin, ...)

lua/lazyvim/config/keymaps.lua

@@ -1,5 +1,4 @@
--- This file is automatically loaded by lazyvim.plugins.config
-
+-- This file is automatically loaded by lazyvim.config.init
 local Util = require("lazyvim.util")
 
 local function map(mode, lhs, rhs, opts)
@@ -9,19 +8,22 @@ local function map(mode, lhs, rhs, opts)
   if not keys.active[keys.parse({ lhs, mode = mode }).id] then
     opts = opts or {}
     opts.silent = opts.silent ~= false
+    if opts.remap and not vim.g.vscode then
+      opts.remap = nil
+    end
     vim.keymap.set(mode, lhs, rhs, opts)
   end
 end
 
 -- better up/down
-map("n", "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
-map("n", "k", "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })
+map({ "n", "x" }, "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
+map({ "n", "x" }, "k", "v:count == 0 ? 'gk' : 'k'", { expr = true, silent = true })
 
 -- Move to window using the <ctrl> hjkl keys
-map("n", "<C-h>", "<C-w>h", { desc = "Go to left window" })
-map("n", "<C-j>", "<C-w>j", { desc = "Go to lower window" })
-map("n", "<C-k>", "<C-w>k", { desc = "Go to upper window" })
-map("n", "<C-l>", "<C-w>l", { desc = "Go to right window" })
+map("n", "<C-h>", "<C-w>h", { desc = "Go to left window", remap = true })
+map("n", "<C-j>", "<C-w>j", { desc = "Go to lower window", remap = true })
+map("n", "<C-k>", "<C-w>k", { desc = "Go to upper window", remap = true })
+map("n", "<C-l>", "<C-w>l", { desc = "Go to right window", remap = true })
 
 -- Resize window using <ctrl> arrow keys
 map("n", "<C-Up>", "<cmd>resize +2<cr>", { desc = "Increase window height" })
@@ -64,8 +66,6 @@ map(
   { desc = "Redraw / clear hlsearch / diff update" }
 )
 
-map({ "n", "x" }, "gw", "*N", { desc = "Search word under cursor" })
-
 -- https://github.com/mhinz/vim-galore#saner-behavior-of-n-and-n
 map("n", "n", "'Nn'[v:searchforward]", { expr = true, desc = "Next search result" })
 map("x", "n", "'Nn'[v:searchforward]", { expr = true, desc = "Next search result" })
@@ -80,14 +80,17 @@ map("i", ".", ".<c-g>u")
 map("i", ";", ";<c-g>u")
 
 -- save file
-map({ "i", "v", "n", "s" }, "<C-s>", "<cmd>w<cr><esc>", { desc = "Save file" })
+map({ "i", "x", "n", "s" }, "<C-s>", "<cmd>w<cr><esc>", { desc = "Save file" })
+
+--keywordprg
+map("n", "<leader>K", "<cmd>norm! K<cr>", { desc = "Keywordprg" })
 
 -- better indenting
 map("v", "<", "<gv")
 map("v", ">", ">gv")
 
 -- lazy
-map("n", "<leader>l", "<cmd>:Lazy<cr>", { desc = "Lazy" })
+map("n", "<leader>l", "<cmd>Lazy<cr>", { desc = "Lazy" })
 
 -- new file
 map("n", "<leader>fn", "<cmd>enew<cr>", { desc = "New File" })
@@ -100,41 +103,62 @@ if not Util.has("trouble.nvim") then
   map("n", "]q", vim.cmd.cnext, { desc = "Next quickfix" })
 end
 
+-- formatting
+map({ "n", "v" }, "<leader>cf", function()
+  require("lazyvim.plugins.lsp.format").format({ force = true })
+end, { desc = "Format" })
+
 -- stylua: ignore start
 
 -- toggle options
 map("n", "<leader>uf", require("lazyvim.plugins.lsp.format").toggle, { desc = "Toggle format on Save" })
 map("n", "<leader>us", function() Util.toggle("spell") end, { desc = "Toggle Spelling" })
 map("n", "<leader>uw", function() Util.toggle("wrap") end, { desc = "Toggle Word Wrap" })
-map("n", "<leader>ul", function() Util.toggle("relativenumber", true) Util.toggle("number") end, { desc = "Toggle Line Numbers" })
+map("n", "<leader>uL", function() Util.toggle("relativenumber") end, { desc = "Toggle Relative Line Numbers" })
+map("n", "<leader>ul", function() Util.toggle_number() end, { desc = "Toggle Line Numbers" })
 map("n", "<leader>ud", Util.toggle_diagnostics, { desc = "Toggle Diagnostics" })
 local conceallevel = vim.o.conceallevel > 0 and vim.o.conceallevel or 3
 map("n", "<leader>uc", function() Util.toggle("conceallevel", false, {0, conceallevel}) end, { desc = "Toggle Conceal" })
+if vim.lsp.inlay_hint then
+  map("n", "<leader>uh", function() vim.lsp.inlay_hint(0, nil) end, { desc = "Toggle Inlay Hints" })
+end
 
 -- lazygit
-map("n", "<leader>gg", function() Util.float_term({ "lazygit" }, { cwd = Util.get_root(), esc_esc = false }) end, { desc = "Lazygit (root dir)" })
-map("n", "<leader>gG", function() Util.float_term({ "lazygit" }, {esc_esc = false}) end, { desc = "Lazygit (cwd)" })
+map("n", "<leader>gg", function() Util.float_term({ "lazygit" }, { cwd = Util.get_root(), esc_esc = false, ctrl_hjkl = false }) end, { desc = "Lazygit (root dir)" })
+map("n", "<leader>gG", function() Util.float_term({ "lazygit" }, {esc_esc = false, ctrl_hjkl = false}) end, { desc = "Lazygit (cwd)" })
 
 -- quit
 map("n", "<leader>qq", "<cmd>qa<cr>", { desc = "Quit all" })
 
 -- highlights under cursor
-if vim.fn.has("nvim-0.9.0") == 1 then
-  map("n", "<leader>ui", vim.show_pos, { desc = "Inspect Pos" })
-end
+map("n", "<leader>ui", vim.show_pos, { desc = "Inspect Pos" })
+
+-- LazyVim Changelog
+map("n", "<leader>L", Util.changelog, {desc = "LazyVim Changelog"})
 
 -- floating terminal
-map("n", "<leader>ft", function() Util.float_term(nil, { cwd = Util.get_root() }) end, { desc = "Terminal (root dir)" })
+local lazyterm = function() Util.float_term(nil, { cwd = Util.get_root() }) end
+map("n", "<leader>ft", lazyterm, { desc = "Terminal (root dir)" })
 map("n", "<leader>fT", function() Util.float_term() end, { desc = "Terminal (cwd)" })
+map("n", "<c-/>", lazyterm, { desc = "Terminal (root dir)" })
+map("n", "<c-_>", lazyterm, { desc = "which_key_ignore" })
+
+-- Terminal Mappings
 map("t", "<esc><esc>", "<c-\\><c-n>", { desc = "Enter Normal Mode" })
+map("t", "<C-h>", "<cmd>wincmd h<cr>", { desc = "Go to left window" })
+map("t", "<C-j>", "<cmd>wincmd j<cr>", { desc = "Go to lower window" })
+map("t", "<C-k>", "<cmd>wincmd k<cr>", { desc = "Go to upper window" })
+map("t", "<C-l>", "<cmd>wincmd l<cr>", { desc = "Go to right window" })
+map("t", "<C-/>", "<cmd>close<cr>", { desc = "Hide Terminal" })
+map("t", "<c-_>", "<cmd>close<cr>", { desc = "which_key_ignore" })
 
 -- windows
-map("n", "<leader>ww", "<C-W>p", { desc = "Other window" })
-map("n", "<leader>wd", "<C-W>c", { desc = "Delete window" })
-map("n", "<leader>w-", "<C-W>s", { desc = "Split window below" })
-map("n", "<leader>w|", "<C-W>v", { desc = "Split window right" })
-map("n", "<leader>-", "<C-W>s", { desc = "Split window below" })
-map("n", "<leader>|", "<C-W>v", { desc = "Split window right" })
+map("n", "<leader>ww", "<C-W>p", { desc = "Other window", remap = true })
+map("n", "<leader>wd", "<C-W>c", { desc = "Delete window", remap = true })
+map("n", "<leader>w-", "<C-W>s", { desc = "Split window below", remap = true })
+map("n", "<leader>w|", "<C-W>v", { desc = "Split window right", remap = true })
+map("n", "<leader>-", "<C-W>s", { desc = "Split window below", remap = true })
+map("n", "<leader>|", "<C-W>v", { desc = "Split window right", remap = true })
 
 -- tabs
 map("n", "<leader><tab>l", "<cmd>tablast<cr>", { desc = "Last Tab" })

lua/lazyvim/config/options.lua

@@ -1,6 +1,6 @@
--- This file is automatically loaded by plugins.config
+-- This file is automatically loaded by plugins.core
 vim.g.mapleader = " "
-vim.g.maplocalleader = " "
+vim.g.maplocalleader = "\\"
 
 local opt = vim.opt
 
@@ -27,7 +27,7 @@ opt.scrolloff = 4 -- Lines of context
 opt.sessionoptions = { "buffers", "curdir", "tabpages", "winsize" }
 opt.shiftround = true -- Round indent
 opt.shiftwidth = 2 -- Size of an indent
-opt.shortmess:append({ W = true, I = true, c = true })
+opt.shortmess:append({ W = true, I = true, c = true, C = true })
 opt.showmode = false -- Dont show mode since we have a statusline
 opt.sidescrolloff = 8 -- Columns of context
 opt.signcolumn = "yes" -- Always show the signcolumn, otherwise it would shift the text each time
@@ -35,6 +35,7 @@ opt.smartcase = true -- Don't ignore case with capitals
 opt.smartindent = true -- Insert indents automatically
 opt.spelllang = { "en" }
 opt.splitbelow = true -- Put new windows below current
+opt.splitkeep = "screen"
 opt.splitright = true -- Put new windows right of current
 opt.tabstop = 2 -- Number of spaces tabs count for
 opt.termguicolors = true -- True color support
@@ -45,10 +46,34 @@ opt.updatetime = 200 -- Save swap file and trigger CursorHold
 opt.wildmode = "longest:full,full" -- Command-line completion mode
 opt.winminwidth = 5 -- Minimum window width
 opt.wrap = false -- Disable line wrap
+opt.fillchars = {
+  foldopen = "",
+  foldclose = "",
+  -- fold = "⸱",
+  fold = " ",
+  foldsep = " ",
+  diff = "╱",
+  eob = " ",
+}
+
+if vim.fn.has("nvim-0.10") == 1 then
+  opt.smoothscroll = true
+end
+
+-- Folding
+vim.opt.foldlevel = 99
+if vim.treesitter.foldexpr then
+  vim.opt.foldmethod = "expr"
+  vim.opt.foldexpr = "v:lua.vim.treesitter.foldexpr()"
+else
+  vim.opt.foldmethod = "indent"
+end
+if vim.treesitter.foldtext then
+  vim.opt.foldtext = "v:lua.require'lazyvim.util.ui'.foldtext()"
+end
 
 if vim.fn.has("nvim-0.9.0") == 1 then
-  opt.splitkeep = "screen"
-  opt.shortmess:append({ C = true })
+  vim.opt.statuscolumn = [[%!v:lua.require'lazyvim.util.ui'.statuscolumn()]]
 end
 
 -- Fix markdown indentation settings

lua/lazyvim/health.lua

@@ -8,10 +8,10 @@ local error = vim.health.error or vim.health.report_error
 function M.check()
   start("LazyVim")
 
-  if vim.fn.has("nvim-0.8.0") == 1 then
-    ok("Using Neovim >= 0.8.0")
+  if vim.fn.has("nvim-0.9.0") == 1 then
+    ok("Using Neovim >= 0.9.0")
   else
-    error("Neovim >= 0.8.0 is required")
+    error("Neovim >= 0.9.0 is required")
   end
 
   for _, cmd in ipairs({ "git", "rg", { "fd", "fdfind" }, "lazygit" }) do

lua/lazyvim/plugins/coding.lua

@@ -4,7 +4,7 @@ return {
   {
     "L3MON4D3/LuaSnip",
     build = (not jit.os:find("Windows"))
-        and "echo -e 'NOTE: jsregexp is optional, so not a big deal if it fails to build\n'; make install_jsregexp"
+        and "echo 'NOTE: jsregexp is optional, so not a big deal if it fails to build'; make install_jsregexp"
       or nil,
     dependencies = {
       "rafamadriz/friendly-snippets",
@@ -42,7 +42,9 @@ return {
       "saadparwaiz1/cmp_luasnip",
     },
     opts = function()
+      vim.api.nvim_set_hl(0, "CmpGhostText", { link = "Comment", default = true })
       local cmp = require("cmp")
+      local defaults = require("cmp.config.default")()
       return {
         completion = {
           completeopt = "menu,menuone,noinsert",
@@ -82,9 +84,10 @@ return {
         },
         experimental = {
           ghost_text = {
-            hl_group = "LspCodeLens",
+            hl_group = "CmpGhostText",
           },
         },
+        sorting = defaults.sorting,
       }
     end,
   },
@@ -93,12 +96,28 @@ return {
   {
     "echasnovski/mini.pairs",
     event = "VeryLazy",
-    config = function(_, opts)
-      require("mini.pairs").setup(opts)
-    end,
+    opts = {},
+    keys = {
+      {
+        "<leader>up",
+        function()
+          local Util = require("lazy.core.util")
+          vim.g.minipairs_disable = not vim.g.minipairs_disable
+          if vim.g.minipairs_disable then
+            Util.warn("Disabled auto pairs", { title = "Option" })
+          else
+            Util.info("Enabled auto pairs", { title = "Option" })
+          end
+        end,
+        desc = "Toggle auto pairs",
+      },
+    },
   },
 
-  -- surround
+  -- Fast and feature-rich surround actions. For text that includes
+  -- surrounding characters like brackets or quotes, this allows you
+  -- to select the text inside, change or modify the surrounding characters,
+  -- and more.
   {
     "echasnovski/mini.surround",
     keys = function(_, keys)
@@ -130,21 +149,29 @@ return {
         update_n_lines = "gzn", -- Update `n_lines`
       },
     },
-    config = function(_, opts)
-      -- use gz mappings instead of s to prevent conflict with leap
-      require("mini.surround").setup(opts)
-    end,
   },
 
   -- comments
+  {
+    "JoosepAlviste/nvim-ts-context-commentstring",
+    lazy = true,
+    opts = {
+      enable_autocmd = false,
+    },
+  },
   {
     "echasnovski/mini.comment",
     event = "VeryLazy",
-    opts = {},
-    main = "mini.comment",
+    opts = {
+      options = {
+        custom_commentstring = function()
+          return require("ts_context_commentstring.internal").calculate_commentstring() or vim.bo.commentstring
+        end,
+      },
+    },
   },
 
-  -- better text-objects
+  -- Better text-objects
   {
     "echasnovski/mini.ai",
     -- keys = {
@@ -164,13 +191,14 @@ return {
           }, {}),
           f = ai.gen_spec.treesitter({ a = "@function.outer", i = "@function.inner" }, {}),
           c = ai.gen_spec.treesitter({ a = "@class.outer", i = "@class.inner" }, {}),
+          t = { "<([%p%w]-)%f[^<%w][^<>]->.-</%1>", "^<.->().*()</[^/]->$" },
         },
       }
     end,
     config = function(_, opts)
       require("mini.ai").setup(opts)
       -- register all text objects with which-key
-      if require("lazyvim.util").has("which-key.nvim") then
+      require("lazyvim.util").on_load("which-key.nvim", function()
         ---@type table<string, string|table>
         local i = {
           [" "] = "Whitespace",
@@ -211,7 +239,7 @@ return {
           i = i,
           a = a,
         })
-      end
+      end)
     end,
   },
 }

lua/lazyvim/plugins/colorscheme.lua

@@ -12,5 +12,36 @@ return {
     "catppuccin/nvim",
     lazy = true,
     name = "catppuccin",
+    opts = {
+      integrations = {
+        alpha = true,
+        cmp = true,
+        flash = true,
+        gitsigns = true,
+        illuminate = true,
+        indent_blankline = { enabled = true },
+        lsp_trouble = true,
+        mason = true,
+        mini = true,
+        native_lsp = {
+          enabled = true,
+          underlines = {
+            errors = { "undercurl" },
+            hints = { "undercurl" },
+            warnings = { "undercurl" },
+            information = { "undercurl" },
+          },
+        },
+        navic = { enabled = true, custom_bg = "lualine" },
+        neotest = true,
+        noice = true,
+        notify = true,
+        neotree = true,
+        semantic_tokens = true,
+        telescope = true,
+        treesitter = true,
+        which_key = true,
+      },
+    },
   },
 }

lua/lazyvim/plugins/extras/coding/copilot.lua

@@ -8,10 +8,15 @@ return {
     opts = {
       suggestion = { enabled = false },
       panel = { enabled = false },
+      filetypes = {
+        markdown = true,
+        help = true,
+      },
     },
   },
   {
     "nvim-lualine/lualine.nvim",
+    optional = true,
     event = "VeryLazy",
     opts = function(_, opts)
       local Util = require("lazyvim.util")
@@ -32,6 +37,9 @@ return {
           return ok and #clients > 0
         end,
         color = function()
+          if not package.loaded["copilot"] then
+            return
+          end
           local status = require("copilot.api").status.data
           return colors[status.status] or colors[""]
         end,
@@ -62,28 +70,9 @@ return {
     },
     ---@param opts cmp.ConfigSchema
     opts = function(_, opts)
-      local cmp = require("cmp")
-
       table.insert(opts.sources, 1, { name = "copilot", group_index = 2 })
-
-      opts.sorting = {
-        priority_weight = 2,
-        comparators = {
-          require("copilot_cmp.comparators").prioritize,
-
-          -- Below is the default comparitor list and order for nvim-cmp
-          cmp.config.compare.offset,
-          -- cmp.config.compare.scopes, --this is commented in nvim-cmp too
-          cmp.config.compare.exact,
-          cmp.config.compare.score,
-          cmp.config.compare.recently_used,
-          cmp.config.compare.locality,
-          cmp.config.compare.kind,
-          cmp.config.compare.sort_text,
-          cmp.config.compare.length,
-          cmp.config.compare.order,
-        },
-      }
+      opts.sorting = opts.sorting or require("cmp.config.default")().sorting
+      table.insert(opts.sorting.comparators, 1, require("copilot_cmp.comparators").prioritize)
     end,
   },
 }

lua/lazyvim/plugins/extras/coding/yanky.lua

@@ -0,0 +1,32 @@
+return {
+  -- better yank/paste
+  {
+    "gbprod/yanky.nvim",
+    dependencies = { { "kkharji/sqlite.lua", enabled = not jit.os:find("Windows") } },
+    opts = {
+      highlight = { timer = 250 },
+      ring = { storage = jit.os:find("Windows") and "shada" or "sqlite" },
+    },
+    keys = {
+        -- stylua: ignore
+      { "<leader>p", function() require("telescope").extensions.yank_history.yank_history({ }) end, desc = "Open Yank History" },
+      { "y", "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank text" },
+      { "p", "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put yanked text after cursor" },
+      { "P", "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put yanked text before cursor" },
+      { "gp", "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put yanked text after selection" },
+      { "gP", "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put yanked text before selection" },
+      { "[y", "<Plug>(YankyCycleForward)", desc = "Cycle forward through yank history" },
+      { "]y", "<Plug>(YankyCycleBackward)", desc = "Cycle backward through yank history" },
+      { "]p", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
+      { "[p", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
+      { "]P", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
+      { "[P", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
+      { ">p", "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and indent right" },
+      { "<p", "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and indent left" },
+      { ">P", "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put before and indent right" },
+      { "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put before and indent left" },
+      { "=p", "<Plug>(YankyPutAfterFilter)", desc = "Put after applying a filter" },
+      { "=P", "<Plug>(YankyPutBeforeFilter)", desc = "Put before applying a filter" },
+    },
+  },
+}

lua/lazyvim/plugins/extras/dap/core.lua

@@ -13,6 +13,8 @@ return {
       },
       opts = {},
       config = function(_, opts)
+        -- setup dap config by VsCode launch.json file
+        -- require("dap.ext.vscode").load_launchjs()
         local dap = require("dap")
         local dapui = require("dapui")
         dapui.setup(opts)
@@ -37,6 +39,7 @@ return {
     -- which key integration
     {
       "folke/which-key.nvim",
+      optional = true,
       opts = {
         defaults = {
           ["<leader>d"] = { name = "+debug" },
@@ -53,7 +56,7 @@ return {
       opts = {
         -- Makes a best effort to setup the various debuggers with
         -- reasonable debug configurations
-        automatic_setup = true,
+        automatic_installation = true,
 
         -- You can provide additional configuration to the handlers,
         -- see mason-nvim-dap README for more information

lua/lazyvim/plugins/extras/editor/leap.lua

@@ -0,0 +1,40 @@
+return {
+  -- disable flash
+  { "folke/flash.nvim", enabled = false, optional = true },
+
+  -- easily jump to any location and enhanced f/t motions for Leap
+  {
+    "ggandor/flit.nvim",
+    enabled = true,
+    keys = function()
+      ---@type LazyKeys[]
+      local ret = {}
+      for _, key in ipairs({ "f", "F", "t", "T" }) do
+        ret[#ret + 1] = { key, mode = { "n", "x", "o" }, desc = key }
+      end
+      return ret
+    end,
+    opts = { labeled_modes = "nx" },
+  },
+  {
+    "ggandor/leap.nvim",
+    enabled = true,
+    keys = {
+      { "s", mode = { "n", "x", "o" }, desc = "Leap forward to" },
+      { "S", mode = { "n", "x", "o" }, desc = "Leap backward to" },
+      { "gs", mode = { "n", "x", "o" }, desc = "Leap from windows" },
+    },
+    config = function(_, opts)
+      local leap = require("leap")
+      for k, v in pairs(opts) do
+        leap.opts[k] = v
+      end
+      leap.add_default_mappings(true)
+      vim.keymap.del({ "x", "o" }, "x")
+      vim.keymap.del({ "x", "o" }, "X")
+    end,
+  },
+
+  -- makes some plugins dot-repeatable like leap
+  { "tpope/vim-repeat", event = "VeryLazy" },
+}

lua/lazyvim/plugins/extras/editor/mini-files.lua

@@ -0,0 +1,64 @@
+return {
+  "echasnovski/mini.files",
+  opts = {
+    windows = {
+      preview = true,
+      width_focus = 30,
+      width_preview = 30,
+    },
+    options = {
+      -- Whether to use for editing directories
+      -- Disabled by default in LazyVim because neo-tree is used for that
+      use_as_default_explorer = false,
+    },
+  },
+  keys = {
+    {
+      "<leader>fm",
+      function()
+        require("mini.files").open(vim.api.nvim_buf_get_name(0), true)
+      end,
+      desc = "Open mini.files (directory of current file)",
+    },
+    {
+      "<leader>fM",
+      function()
+        require("mini.files").open(vim.loop.cwd(), true)
+      end,
+      desc = "Open mini.files (cwd)",
+    },
+  },
+  config = function(_, opts)
+    require("mini.files").setup(opts)
+
+    local show_dotfiles = true
+    local filter_show = function(fs_entry)
+      return true
+    end
+    local filter_hide = function(fs_entry)
+      return not vim.startswith(fs_entry.name, ".")
+    end
+
+    local toggle_dotfiles = function()
+      show_dotfiles = not show_dotfiles
+      local new_filter = show_dotfiles and filter_show or filter_hide
+      require("mini.files").refresh({ content = { filter = new_filter } })
+    end
+
+    vim.api.nvim_create_autocmd("User", {
+      pattern = "MiniFilesBufferCreate",
+      callback = function(args)
+        local buf_id = args.data.buf_id
+        -- Tweak left-hand side of mapping to your liking
+        vim.keymap.set("n", "g.", toggle_dotfiles, { buffer = buf_id })
+      end,
+    })
+
+    vim.api.nvim_create_autocmd("User", {
+      pattern = "MiniFilesActionRename",
+      callback = function(event)
+        require("lazyvim.util").on_rename(event.data.from, event.data.to)
+      end,
+    })
+  end,
+}

lua/lazyvim/plugins/extras/formatting/conform.lua

@@ -0,0 +1,53 @@
+return {
+  {
+    "stevearc/conform.nvim",
+    dependencies = { "mason.nvim" },
+    lazy = true,
+    cmd = "ConformInfo",
+    keys = {
+      {
+        "<leader>cF",
+        function()
+          require("conform").format({ formatters = { "injected" } })
+        end,
+        mode = { "n", "v" },
+        desc = "Format Injected Langs",
+      },
+    },
+    init = function()
+      vim.o.formatexpr = "v:lua.require'conform'.formatexpr()"
+      -- Install the conform formatter on VeryLazy
+      require("lazyvim.util").on_very_lazy(function()
+        require("lazyvim.plugins.lsp.format").custom_format = function(buf)
+          return require("conform").format({ bufnr = buf })
+        end
+      end)
+    end,
+    opts = {
+      formatters_by_ft = {
+        lua = { "stylua" },
+        fish = { "fish_indent" },
+        sh = { "shfmt" },
+      },
+      -- LazyVim will merge the options you set here with builtin formatters.
+      -- You can also define any custom formatters here.
+      ---@type table<string,table>
+      formatters = {
+        -- -- Example of using dprint only when a dprint.json file is present
+        -- dprint = {
+        --   condition = function(ctx)
+        --     return vim.fs.find({ "dprint.json" }, { path = ctx.filename, upward = true })[1]
+        --   end,
+        -- },
+      },
+    },
+    config = function(_, opts)
+      opts.formatters = opts.formatters or {}
+      for f, o in pairs(opts.formatters) do
+        local ok, formatter = pcall(require, "conform.formatters." .. f)
+        opts.formatters[f] = vim.tbl_deep_extend("force", {}, ok and formatter or {}, o)
+      end
+      require("conform").setup(opts)
+    end,
+  },
+}

lua/lazyvim/plugins/extras/formatting/prettier.lua

@@ -6,10 +6,35 @@ return {
     end,
   },
   {
-    "jose-elias-alvarez/null-ls.nvim",
+    "nvimtools/none-ls.nvim",
+    optional = true,
     opts = function(_, opts)
       local nls = require("null-ls")
       table.insert(opts.sources, nls.builtins.formatting.prettierd)
     end,
   },
+  {
+    "stevearc/conform.nvim",
+    optional = true,
+    opts = {
+      formatters_by_ft = {
+        ["javascript"] = { { "prettierd", "prettier" } },
+        ["javascriptreact"] = { { "prettierd", "prettier" } },
+        ["typescript"] = { { "prettierd", "prettier" } },
+        ["typescriptreact"] = { { "prettierd", "prettier" } },
+        ["vue"] = { { "prettierd", "prettier" } },
+        ["css"] = { { "prettierd", "prettier" } },
+        ["scss"] = { { "prettierd", "prettier" } },
+        ["less"] = { { "prettierd", "prettier" } },
+        ["html"] = { { "prettierd", "prettier" } },
+        ["json"] = { { "prettierd", "prettier" } },
+        ["jsonc"] = { { "prettierd", "prettier" } },
+        ["yaml"] = { { "prettierd", "prettier" } },
+        ["markdown"] = { { "prettierd", "prettier" } },
+        ["markdown.mdx"] = { { "prettierd", "prettier" } },
+        ["graphql"] = { { "prettierd", "prettier" } },
+        ["handlebars"] = { { "prettierd", "prettier" } },
+      },
+    },
+  },
 }

lua/lazyvim/plugins/extras/lang/clangd.lua

@@ -0,0 +1,154 @@
+return {
+
+  -- Add C/C++ to treesitter
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      if type(opts.ensure_installed) == "table" then
+        vim.list_extend(opts.ensure_installed, { "c", "cpp" })
+      end
+    end,
+  },
+
+  {
+    "p00f/clangd_extensions.nvim",
+    lazy = true,
+    config = function() end,
+    opts = {
+      inlay_hints = {
+        inline = false,
+      },
+      ast = {
+        --These require codicons (https://github.com/microsoft/vscode-codicons)
+        role_icons = {
+          type = "",
+          declaration = "",
+          expression = "",
+          specifier = "",
+          statement = "",
+          ["template argument"] = "",
+        },
+        kind_icons = {
+          Compound = "",
+          Recovery = "",
+          TranslationUnit = "",
+          PackExpansion = "",
+          TemplateTypeParm = "",
+          TemplateTemplateParm = "",
+          TemplateParamObject = "",
+        },
+      },
+    },
+  },
+
+  -- Correctly setup lspconfig for clangd 🚀
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        -- Ensure mason installs the server
+        clangd = {
+          keys = {
+            { "<leader>cR", "<cmd>ClangdSwitchSourceHeader<cr>", desc = "Switch Source/Header (C/C++)" },
+          },
+          root_dir = function(fname)
+            return require("lspconfig.util").root_pattern(
+              "Makefile",
+              "configure.ac",
+              "configure.in",
+              "config.h.in",
+              "meson.build",
+              "meson_options.txt",
+              "build.ninja"
+            )(fname) or require("lspconfig.util").root_pattern("compile_commands.json", "compile_flags.txt")(
+              fname
+            ) or require("lspconfig.util").find_git_ancestor(fname)
+          end,
+          capabilities = {
+            offsetEncoding = { "utf-16" },
+          },
+          cmd = {
+            "clangd",
+            "--background-index",
+            "--clang-tidy",
+            "--header-insertion=iwyu",
+            "--completion-style=detailed",
+            "--function-arg-placeholders",
+            "--fallback-style=llvm",
+          },
+          init_options = {
+            usePlaceholders = true,
+            completeUnimported = true,
+            clangdFileStatus = true,
+          },
+        },
+      },
+      setup = {
+        clangd = function(_, opts)
+          local clangd_ext_opts = require("lazyvim.util").opts("clangd_extensions.nvim")
+          require("clangd_extensions").setup(vim.tbl_deep_extend("force", clangd_ext_opts or {}, { server = opts }))
+          return false
+        end,
+      },
+    },
+  },
+
+  {
+    "nvim-cmp",
+    opts = function(_, opts)
+      table.insert(opts.sorting.comparators, 1, require("clangd_extensions.cmp_scores"))
+    end,
+  },
+
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      -- Ensure C/C++ debugger is installed
+      "williamboman/mason.nvim",
+      optional = true,
+      opts = function(_, opts)
+        if type(opts.ensure_installed) == "table" then
+          vim.list_extend(opts.ensure_installed, { "codelldb" })
+        end
+      end,
+    },
+    opts = function()
+      local dap = require("dap")
+      if not dap.adapters["codelldb"] then
+        require("dap").adapters["codelldb"] = {
+          type = "server",
+          host = "localhost",
+          port = "${port}",
+          executable = {
+            command = "codelldb",
+            args = {
+              "--port",
+              "${port}",
+            },
+          },
+        }
+      end
+      for _, lang in ipairs({ "c", "cpp" }) do
+        dap.configurations[lang] = {
+          {
+            type = "codelldb",
+            request = "launch",
+            name = "Launch file",
+            program = function()
+              return vim.fn.input("Path to executable: ", vim.fn.getcwd() .. "/", "file")
+            end,
+            cwd = "${workspaceFolder}",
+          },
+          {
+            type = "codelldb",
+            request = "attach",
+            name = "Attach to process",
+            processId = require("dap.utils").pick_process,
+            cwd = "${workspaceFolder}",
+          },
+        }
+      end
+    end,
+  },
+}

lua/lazyvim/plugins/extras/lang/cmake.lua

@@ -0,0 +1,50 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      if type(opts.ensure_installed) == "table" then
+        vim.list_extend(opts.ensure_installed, { "cmake" })
+      end
+    end,
+  },
+  {
+    "nvimtools/none-ls.nvim",
+    optional = true,
+    opts = function(_, opts)
+      local nls = require("null-ls")
+      opts.sources = opts.sources or {}
+      vim.list_extend(opts.sources, {
+        nls.builtins.diagnostics.cmake_lint,
+      })
+    end,
+  },
+  {
+    "mfussenegger/nvim-lint",
+    optional = true,
+    opts = {
+      linters_by_ft = {
+        cmake = { "cmakelint" },
+      },
+    },
+  },
+  {
+    "mason.nvim",
+    opts = function(_, opts)
+      opts.ensure_installed = opts.ensure_installed or {}
+      vim.list_extend(opts.ensure_installed, { "cmakelang" })
+    end,
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        neocmake = {},
+      },
+    },
+  },
+  {
+    "Civitasv/cmake-tools.nvim",
+    opts = {},
+    event = "BufRead",
+  },
+}

lua/lazyvim/plugins/extras/lang/docker.lua

@@ -0,0 +1,46 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      if type(opts.ensure_installed) == "table" then
+        vim.list_extend(opts.ensure_installed, { "dockerfile" })
+      end
+    end,
+  },
+  {
+    "mason.nvim",
+    opts = function(_, opts)
+      opts.ensure_installed = opts.ensure_installed or {}
+      vim.list_extend(opts.ensure_installed, { "hadolint" })
+    end,
+  },
+  {
+    "nvimtools/none-ls.nvim",
+    optional = true,
+    opts = function(_, opts)
+      local nls = require("null-ls")
+      opts.sources = opts.sources or {}
+      vim.list_extend(opts.sources, {
+        nls.builtins.diagnostics.hadolint,
+      })
+    end,
+  },
+  {
+    "mfussenegger/nvim-lint",
+    optional = true,
+    opts = {
+      linters_by_ft = {
+        dockerfile = { "hadolint" },
+      },
+    },
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        dockerls = {},
+        docker_compose_language_service = {},
+      },
+    },
+  },
+}

lua/lazyvim/plugins/extras/lang/elixir.lua

@@ -0,0 +1,52 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      vim.list_extend(opts.ensure_installed, {
+        "elixir",
+        "heex",
+        "eex",
+      })
+    end,
+  },
+  {
+    "williamboman/mason.nvim",
+    opts = function(_, opts)
+      vim.list_extend(opts.ensure_installed, {
+        "elixir-ls",
+      })
+    end,
+  },
+  {
+    "nvim-neotest/neotest",
+    optional = true,
+    dependencies = {
+      "jfpedroza/neotest-elixir",
+    },
+    opts = {
+      adapters = {
+        ["neotest-elixir"] = {},
+      },
+    },
+  },
+  {
+    "nvimtools/none-ls.nvim",
+    optional = true,
+    opts = function(_, opts)
+      local nls = require("null-ls")
+      opts.sources = opts.sources or {}
+      vim.list_extend(opts.sources, {
+        nls.builtins.diagnostics.credo,
+      })
+    end,
+  },
+  {
+    "mfussenegger/nvim-lint",
+    optional = true,
+    opts = {
+      linters_by_ft = {
+        elixir = { "credo" },
+      },
+    },
+  },
+}

lua/lazyvim/plugins/extras/lang/go.lua

@@ -0,0 +1,140 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      vim.list_extend(opts.ensure_installed, {
+        "go",
+        "gomod",
+        "gowork",
+        "gosum",
+      })
+    end,
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        gopls = {
+          keys = {
+            -- Workaround for the lack of a DAP strategy in neotest-go: https://github.com/nvim-neotest/neotest-go/issues/12
+            { "<leader>td", "<cmd>lua require('dap-go').debug_test()<CR>", desc = "Debug Nearest (Go)" },
+          },
+          settings = {
+            gopls = {
+              gofumpt = true,
+              codelenses = {
+                gc_details = false,
+                generate = true,
+                regenerate_cgo = true,
+                run_govulncheck = true,
+                test = true,
+                tidy = true,
+                upgrade_dependency = true,
+                vendor = true,
+              },
+              hints = {
+                assignVariableTypes = true,
+                compositeLiteralFields = true,
+                compositeLiteralTypes = true,
+                constantValues = true,
+                functionTypeParameters = true,
+                parameterNames = true,
+                rangeVariableTypes = true,
+              },
+              analyses = {
+                fieldalignment = true,
+                nilness = true,
+                unusedparams = true,
+                unusedwrite = true,
+                useany = true,
+              },
+              usePlaceholders = true,
+              completeUnimported = true,
+              staticcheck = true,
+              directoryFilters = { "-.git", "-.vscode", "-.idea", "-.vscode-test", "-node_modules" },
+              semanticTokens = true,
+            },
+          },
+        },
+      },
+      setup = {
+        gopls = function(_, opts)
+          -- workaround for gopls not supporting semanticTokensProvider
+          -- https://github.com/golang/go/issues/54531#issuecomment-1464982242
+          require("lazyvim.util").on_attach(function(client, _)
+            if client.name == "gopls" then
+              if not client.server_capabilities.semanticTokensProvider then
+                local semantic = client.config.capabilities.textDocument.semanticTokens
+                client.server_capabilities.semanticTokensProvider = {
+                  full = true,
+                  legend = {
+                    tokenTypes = semantic.tokenTypes,
+                    tokenModifiers = semantic.tokenModifiers,
+                  },
+                  range = true,
+                }
+              end
+            end
+          end)
+          -- end workaround
+        end,
+      },
+    },
+  },
+  -- Ensure Go tools are installed
+  {
+    "nvimtools/none-ls.nvim",
+    optional = true,
+    opts = function(_, opts)
+      if type(opts.sources) == "table" then
+        local nls = require("null-ls")
+        vim.list_extend(opts.sources, {
+          nls.builtins.code_actions.gomodifytags,
+          nls.builtins.code_actions.impl,
+          nls.builtins.formatting.goimports,
+        })
+      end
+    end,
+  },
+  {
+    "stevearc/conform.nvim",
+    optional = true,
+    opts = {
+      formatters_by_ft = {
+        go = { "goimports" },
+      },
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      {
+        "mason.nvim",
+        opts = function(_, opts)
+          opts.ensure_installed = opts.ensure_installed or {}
+          vim.list_extend(opts.ensure_installed, { "gomodifytags", "impl", "goimports", "delve" })
+        end,
+      },
+      {
+        "leoluz/nvim-dap-go",
+        config = true,
+      },
+    },
+  },
+  {
+    "nvim-neotest/neotest",
+    optional = true,
+    dependencies = {
+      "nvim-neotest/neotest-go",
+    },
+    opts = {
+      adapters = {
+        ["neotest-go"] = {
+          -- Here we can set options for neotest-go, e.g.
+          -- args = { "-tags=integration" }
+        },
+      },
+    },
+  },
+}

lua/lazyvim/plugins/extras/lang/java.lua

@@ -0,0 +1,227 @@
+local Util = require("lazyvim.util")
+
+-- This is the same as in lspconfig.server_configurations.jdtls, but avoids
+-- needing to require that when this module loads.
+local java_filetypes = { "java" }
+
+-- Utility function to extend or override a config table, similar to the way
+-- that Plugin.opts works.
+---@param config table
+---@param custom function | table | nil
+local function extend_or_override(config, custom, ...)
+  if type(custom) == "function" then
+    config = custom(config, ...) or config
+  elseif custom then
+    config = vim.tbl_deep_extend("force", config, custom) --[[@as table]]
+  end
+  return config
+end
+
+return {
+  -- Add java to treesitter.
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      opts.ensure_installed = opts.ensure_installed or {}
+      vim.list_extend(opts.ensure_installed, { "java" })
+    end,
+  },
+
+  -- Ensure java debugger and test packages are installed.
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      {
+        "williamboman/mason.nvim",
+        opts = function(_, opts)
+          opts.ensure_installed = opts.ensure_installed or {}
+          vim.list_extend(opts.ensure_installed, { "java-test", "java-debug-adapter" })
+        end,
+      },
+    },
+  },
+
+  -- Configure nvim-lspconfig to install the server automatically via mason, but
+  -- defer actually starting it to our configuration of nvim-jtdls below.
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      -- make sure mason installs the server
+      servers = {
+        jdtls = {},
+      },
+      setup = {
+        jdtls = function()
+          return true -- avoid duplicate servers
+        end,
+      },
+    },
+  },
+
+  -- Set up nvim-jdtls to attach to java files.
+  {
+    "mfussenegger/nvim-jdtls",
+    dependencies = { "folke/which-key.nvim" },
+    ft = java_filetypes,
+    opts = function()
+      return {
+        -- How to find the root dir for a given filename. The default comes from
+        -- lspconfig which provides a function specifically for java projects.
+        root_dir = require("lspconfig.server_configurations.jdtls").default_config.root_dir,
+
+        -- How to find the project name for a given root dir.
+        project_name = function(root_dir)
+          return root_dir and vim.fs.basename(root_dir)
+        end,
+
+        -- Where are the config and workspace dirs for a project?
+        jdtls_config_dir = function(project_name)
+          return vim.fn.stdpath("cache") .. "/jdtls/" .. project_name .. "/config"
+        end,
+        jdtls_workspace_dir = function(project_name)
+          return vim.fn.stdpath("cache") .. "/jdtls/" .. project_name .. "/workspace"
+        end,
+
+        -- How to run jdtls. This can be overridden to a full java command-line
+        -- if the Python wrapper script doesn't suffice.
+        cmd = { "jdtls" },
+        full_cmd = function(opts)
+          local fname = vim.api.nvim_buf_get_name(0)
+          local root_dir = opts.root_dir(fname)
+          local project_name = opts.project_name(root_dir)
+          local cmd = vim.deepcopy(opts.cmd)
+          if project_name then
+            vim.list_extend(cmd, {
+              "-configuration",
+              opts.jdtls_config_dir(project_name),
+              "-data",
+              opts.jdtls_workspace_dir(project_name),
+            })
+          end
+          return cmd
+        end,
+
+        -- These depend on nvim-dap, but can additionally be disabled by setting false here.
+        dap = { hotcodereplace = "auto", config_overrides = {} },
+        test = true,
+      }
+    end,
+    config = function()
+      local opts = Util.opts("nvim-jdtls") or {}
+
+      -- Find the extra bundles that should be passed on the jdtls command-line
+      -- if nvim-dap is enabled with java debug/test.
+      local mason_registry = require("mason-registry")
+      local bundles = {} ---@type string[]
+      if opts.dap and Util.has("nvim-dap") and mason_registry.is_installed("java-debug-adapter") then
+        local java_dbg_pkg = mason_registry.get_package("java-debug-adapter")
+        local java_dbg_path = java_dbg_pkg:get_install_path()
+        local jar_patterns = {
+          java_dbg_path .. "/extension/server/com.microsoft.java.debug.plugin-*.jar",
+        }
+        -- java-test also depends on java-debug-adapter.
+        if opts.test and mason_registry.is_installed("java-test") then
+          local java_test_pkg = mason_registry.get_package("java-test")
+          local java_test_path = java_test_pkg:get_install_path()
+          vim.list_extend(jar_patterns, {
+            java_test_path .. "/extension/server/*.jar",
+          })
+        end
+        for _, jar_pattern in ipairs(jar_patterns) do
+          for _, bundle in ipairs(vim.split(vim.fn.glob(jar_pattern), "\n")) do
+            table.insert(bundles, bundle)
+          end
+        end
+      end
+
+      local function attach_jdtls()
+        local fname = vim.api.nvim_buf_get_name(0)
+
+        -- Configuration can be augmented and overridden by opts.jdtls
+        local config = extend_or_override({
+          cmd = opts.full_cmd(opts),
+          root_dir = opts.root_dir(fname),
+          init_options = {
+            bundles = bundles,
+          },
+          -- enable CMP capabilities
+          capabilities = require("cmp_nvim_lsp").default_capabilities(),
+        }, opts.jdtls)
+
+        -- Existing server will be reused if the root_dir matches.
+        require("jdtls").start_or_attach(config)
+        -- not need to require("jdtls.setup").add_commands(), start automatically adds commands
+      end
+
+      -- Attach the jdtls for each java buffer. HOWEVER, this plugin loads
+      -- depending on filetype, so this autocmd doesn't run for the first file.
+      -- For that, we call directly below.
+      vim.api.nvim_create_autocmd("FileType", {
+        pattern = java_filetypes,
+        callback = attach_jdtls,
+      })
+
+      -- Setup keymap and dap after the lsp is fully attached.
+      -- https://github.com/mfussenegger/nvim-jdtls#nvim-dap-configuration
+      -- https://neovim.io/doc/user/lsp.html#LspAttach
+      vim.api.nvim_create_autocmd("LspAttach", {
+        callback = function(args)
+          local client = vim.lsp.get_client_by_id(args.data.client_id)
+          if client and client.name == "jdtls" then
+            local wk = require("which-key")
+            wk.register({
+              ["<leader>cx"] = { name = "+extract" },
+              ["<leader>cxv"] = { require("jdtls").extract_variable_all, "Extract Variable" },
+              ["<leader>cxc"] = { require("jdtls").extract_constant, "Extract Constant" },
+              ["gs"] = { require("jdtls").super_implementation, "Goto Super" },
+              ["gS"] = { require("jdtls.tests").goto_subjects, "Goto Subjects" },
+              ["<leader>co"] = { require("jdtls").organize_imports, "Organize Imports" },
+            }, { mode = "n", buffer = args.buf })
+            wk.register({
+              ["<leader>c"] = { name = "+code" },
+              ["<leader>cx"] = { name = "+extract" },
+              ["<leader>cxm"] = {
+                [[<ESC><CMD>lua require('jdtls').extract_method(true)<CR>]],
+                "Extract Method",
+              },
+              ["<leader>cxv"] = {
+                [[<ESC><CMD>lua require('jdtls').extract_variable_all(true)<CR>]],
+                "Extract Variable",
+              },
+              ["<leader>cxc"] = {
+                [[<ESC><CMD>lua require('jdtls').extract_constant(true)<CR>]],
+                "Extract Constant",
+              },
+            }, { mode = "v", buffer = args.buf })
+
+            if opts.dap and Util.has("nvim-dap") and mason_registry.is_installed("java-debug-adapter") then
+              -- custom init for Java debugger
+              require("jdtls").setup_dap(opts.dap)
+              require("jdtls.dap").setup_dap_main_class_configs()
+
+              -- Java Test require Java debugger to work
+              if opts.test and mason_registry.is_installed("java-test") then
+                -- custom keymaps for Java test runner (not yet compatible with neotest)
+                wk.register({
+                  ["<leader>t"] = { name = "+test" },
+                  ["<leader>tt"] = { require("jdtls.dap").test_class, "Run All Test" },
+                  ["<leader>tr"] = { require("jdtls.dap").test_nearest_method, "Run Nearest Test" },
+                  ["<leader>tT"] = { require("jdtls.dap").pick_test, "Run Test" },
+                }, { mode = "n", buffer = args.buf })
+              end
+            end
+
+            -- User can set additional keymaps in opts.on_attach
+            if opts.on_attach then
+              opts.on_attach(args)
+            end
+          end
+        end,
+      })
+
+      -- Avoid race condition by calling attach the first time, since the autocmd won't fire.
+      attach_jdtls()
+    end,
+  },
+}

lua/lazyvim/plugins/extras/lang/json.lua

@@ -10,13 +10,16 @@ return {
     end,
   },
 
+  -- yaml schema support
+  {
+    "b0o/SchemaStore.nvim",
+    lazy = true,
+    version = false, -- last release is way too old
+  },
+
   -- correctly setup lspconfig
   {
     "neovim/nvim-lspconfig",
-    dependencies = {
-      "b0o/SchemaStore.nvim",
-      version = false, -- last release is way too old
-    },
     opts = {
       -- make sure mason installs the server
       servers = {

lua/lazyvim/plugins/extras/lang/omnisharp.lua

@@ -0,0 +1,67 @@
+return {
+  { "Hoffs/omnisharp-extended-lsp.nvim", lazy = true },
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      if type(opts.ensure_installed) == "table" then
+        vim.list_extend(opts.ensure_installed, { "c_sharp" })
+      end
+    end,
+  },
+  {
+    "nvimtools/none-ls.nvim",
+    optional = true,
+    opts = function(_, opts)
+      local nls = require("null-ls")
+      table.insert(opts.sources, nls.builtins.formatting.csharpier)
+    end,
+  },
+  {
+    "stevearc/conform.nvim",
+    optional = true,
+    opts = {
+      formatters_by_ft = {
+        cs = { "csharpier" },
+      },
+      formatters = {
+        csharpier = {
+          command = "dotnet-csharpier",
+          args = { "--write-stdout" },
+        },
+      },
+    },
+  },
+  {
+    "williamboman/mason.nvim",
+    opts = function(_, opts)
+      opts.ensure_installed = opts.ensure_installed or {}
+      table.insert(opts.ensure_installed, "csharpier")
+    end,
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        omnisharp = {
+          handlers = {
+            ["textDocument/definition"] = function(...)
+              return require("omnisharp_extended").handler(...)
+            end,
+          },
+          keys = {
+            {
+              "gd",
+              function()
+                require("omnisharp_extended").telescope_lsp_definitions()
+              end,
+              desc = "Goto Definition",
+            },
+          },
+          enable_roslyn_analyzers = true,
+          organize_imports_on_format = true,
+          enable_import_completion = true,
+        },
+      },
+    },
+  },
+}

lua/lazyvim/plugins/extras/lang/python-semshi.lua

@@ -0,0 +1,31 @@
+return {
+  -- "numiras/semshi",
+  "wookayin/semshi", -- use a maintained fork
+  ft = "python",
+  build = ":UpdateRemotePlugins",
+  init = function()
+    -- Disabled these features better provided by LSP or other more general plugins
+    vim.g["semshi#error_sign"] = false
+    vim.g["semshi#simplify_markup"] = false
+    vim.g["semshi#mark_selected_nodes"] = false
+    vim.g["semshi#update_delay_factor"] = 0.001
+
+    -- This autocmd must be defined in init to take effect
+    vim.api.nvim_create_autocmd({ "VimEnter", "ColorScheme" }, {
+      group = vim.api.nvim_create_augroup("SemanticHighlight", {}),
+      callback = function()
+        -- Only add style, inherit or link to the LSP's colors
+        vim.cmd([[
+            highlight! semshiGlobal gui=italic
+            highlight! semshiImported gui=bold
+            highlight! link semshiParameter @lsp.type.parameter
+            highlight! link semshiParameterUnused DiagnosticUnnecessary
+            highlight! link semshiBuiltin @function.builtin
+            highlight! link semshiAttribute @attribute
+            highlight! link semshiSelf @lsp.type.selfKeyword
+            highlight! link semshiUnresolved @lsp.type.unresolvedReference
+            ]])
+      end,
+    })
+  end,
+}

lua/lazyvim/plugins/extras/lang/python.lua

@@ -0,0 +1,79 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      if type(opts.ensure_installed) == "table" then
+        vim.list_extend(opts.ensure_installed, { "ninja", "python", "rst", "toml" })
+      end
+    end,
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        pyright = {},
+        ruff_lsp = {},
+      },
+      setup = {
+        ruff_lsp = function()
+          require("lazyvim.util").on_attach(function(client, _)
+            if client.name == "ruff_lsp" then
+              -- Disable hover in favor of Pyright
+              client.server_capabilities.hoverProvider = false
+            end
+          end)
+        end,
+      },
+    },
+  },
+  {
+    "nvim-neotest/neotest",
+    optional = true,
+    dependencies = {
+      "nvim-neotest/neotest-python",
+    },
+    opts = {
+      adapters = {
+        ["neotest-python"] = {
+          -- Here you can specify the settings for the adapter, i.e.
+          -- runner = "pytest",
+          -- python = ".venv/bin/python",
+        },
+      },
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      "mfussenegger/nvim-dap-python",
+      -- stylua: ignore
+      keys = {
+        { "<leader>dPt", function() require('dap-python').test_method() end, desc = "Debug Method" },
+        { "<leader>dPc", function() require('dap-python').test_class() end, desc = "Debug Class" },
+      },
+      config = function()
+        local path = require("mason-registry").get_package("debugpy"):get_install_path()
+        require("dap-python").setup(path .. "/venv/bin/python")
+      end,
+    },
+  },
+  {
+    "linux-cultist/venv-selector.nvim",
+    cmd = "VenvSelect",
+    opts = function(_, opts)
+      if require("lazyvim.util").has("nvim-dap-python") then
+        opts.dap_enabled = true
+      end
+      return vim.tbl_deep_extend("force", opts, {
+        name = {
+          "venv",
+          ".venv",
+          "env",
+          ".env",
+        },
+      })
+    end,
+    keys = { { "<leader>cv", "<cmd>:VenvSelect<cr>", desc = "Select VirtualEnv" } },
+  },
+}

lua/lazyvim/plugins/extras/lang/ruby.lua

@@ -0,0 +1,57 @@
+return {
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = function(_, opts)
+      vim.list_extend(opts.ensure_installed, {
+        "ruby",
+      })
+    end,
+  },
+  {
+    "williamboman/mason.nvim",
+    opts = function(_, opts)
+      vim.list_extend(opts.ensure_installed, {
+        "solargraph",
+      })
+    end,
+  },
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        solargraph = {},
+      },
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      "suketa/nvim-dap-ruby",
+      config = function()
+        require("dap-ruby").setup()
+      end,
+    },
+  },
+  {
+    "nvim-neotest/neotest",
+    optional = true,
+    dependencies = {
+      "olimorris/neotest-rspec",
+    },
+    opts = {
+      adapters = {
+        ["neotest-rspec"] = {
+          -- NOTE: By default neotest-rspec uses the system wide rspec gem instead of the one through bundler
+          -- rspec_cmd = function()
+          --   return vim.tbl_flatten({
+          --     "bundle",
+          --     "exec",
+          --     "rspec",
+          --   })
+          -- end,
+        },
+      },
+    },
+  },
+}