chore(main): release 4.7.0 (#891)

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

doc/LazyVim.txt

@@ -1,4 +1,4 @@
-*LazyVim.txt*          For Neovim >= 0.8.0          Last change: 2023 April 24
+*LazyVim.txt*           For Neovim >= 0.8.0          Last change: 2023 June 08
 
 ==============================================================================
 Table of Contents                                  *LazyVim-table-of-contents*
@@ -43,7 +43,6 @@ pre-configured setup.
 
 FEATURES                                                    *LazyVim-features*
 
-
 - Transform your Neovim into a full-fledged IDE
 - Easily customize and extend your config with lazy.nvim <https://github.com/folke/lazy.nvim>
 - Blazingly fast
@@ -53,7 +52,6 @@ FEATURES                                                    *LazyVim-features*
 
 REQUIREMENTS                                            *LazyVim-requirements*
 
-
 - Neovim >= **0.8.0** (needs to be built with **LuaJIT**)
 - Git >= **2.19.0** (for partial clones support)
 - a Nerd Font <https://www.nerdfonts.com/> **(optional)**
@@ -77,7 +75,6 @@ Try it with Docker ~
 
 Install the LazyVim Starter ~
 
-
 - Make a backup of your current Neovim files:
     >sh
         mv ~/.config/nvim ~/.config/nvim.bak

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 })
@@ -51,7 +51,10 @@ vim.api.nvim_create_autocmd("FileType", {
     "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

@@ -20,7 +20,7 @@ local defaults = {
   -- icons used by other plugins
   icons = {
     dap = {
-      Stopped = { " ", "DiagnosticWarn", "DapStoppedLine" },
+      Stopped = { "󰁕 ", "DiagnosticWarn", "DapStoppedLine" },
       Breakpoint = " ",
       BreakpointCondition = " ",
       BreakpointRejected = { " ", "DiagnosticError" },
@@ -161,6 +161,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

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,6 +8,9 @@ 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
@@ -18,10 +20,10 @@ map("n", "j", "v:count == 0 ? 'gj' : 'j'", { expr = true, silent = true })
 map("n", "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" })
@@ -124,17 +126,28 @@ if vim.fn.has("nvim-0.9.0") == 1 then
 end
 
 -- 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/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",
@@ -93,9 +93,7 @@ return {
   {
     "echasnovski/mini.pairs",
     event = "VeryLazy",
-    config = function(_, opts)
-      require("mini.pairs").setup(opts)
-    end,
+    opts = {},
   },
 
   -- surround
@@ -130,10 +128,6 @@ 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
@@ -142,15 +136,12 @@ return {
     "echasnovski/mini.comment",
     event = "VeryLazy",
     opts = {
-      hooks = {
-        pre = function()
-          require("ts_context_commentstring.internal").update_commentstring({})
+      options = {
+        custom_commentstring = function()
+          return require("ts_context_commentstring.internal").calculate_commentstring() or vim.bo.commentstring
         end,
       },
     },
-    config = function(_, opts)
-      require("mini.comment").setup(opts)
-    end,
   },
 
   -- better text-objects

lua/lazyvim/plugins/colorscheme.lua

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

lua/lazyvim/plugins/editor.lua

@@ -37,6 +37,8 @@ return {
       end
     end,
     opts = {
+      sources = { "filesystem", "buffers", "git_status", "document_symbols" },
+      open_files_do_not_replace_types = { "terminal", "Trouble", "qf", "Outline" },
       filesystem = {
         bind_to_cwd = false,
         follow_current_file = true,
@@ -72,6 +74,8 @@ return {
   -- search/replace in multiple files
   {
     "nvim-pack/nvim-spectre",
+    cmd = "Spectre",
+    opts = { open_cmd = "noswapfile vnew" },
     -- stylua: ignore
     keys = {
       { "<leader>sr", function() require("spectre").open() end, desc = "Replace in files (Spectre)" },
@@ -81,6 +85,7 @@ return {
   -- fuzzy finder
   {
     "nvim-telescope/telescope.nvim",
+    commit = vim.fn.has("nvim-0.9.0") == 0 and "057ee0f8783" or nil,
     cmd = "Telescope",
     version = false, -- telescope did only one release, so use HEAD for now
     keys = {
@@ -166,10 +171,14 @@ return {
               return require("trouble.providers.telescope").open_selected_with_trouble(...)
             end,
             ["<a-i>"] = function()
-              Util.telescope("find_files", { no_ignore = true })()
+              local action_state = require("telescope.actions.state")
+              local line = action_state.get_current_line()
+              Util.telescope("find_files", { no_ignore = true, default_text = line })()
             end,
             ["<a-h>"] = function()
-              Util.telescope("find_files", { hidden = true })()
+              local action_state = require("telescope.actions.state")
+              local line = action_state.get_current_line()
+              Util.telescope("find_files", { hidden = true, default_text = line })()
             end,
             ["<C-Down>"] = function(...)
               return require("telescope.actions").cycle_history_next(...)
@@ -298,7 +307,13 @@ return {
   {
     "RRethy/vim-illuminate",
     event = { "BufReadPost", "BufNewFile" },
-    opts = { delay = 200 },
+    opts = {
+      delay = 200,
+      large_file_cutoff = 2000,
+      large_file_overrides = {
+        providers = { "lsp" },
+      },
+    },
     config = function(_, opts)
       require("illuminate").configure(opts)
 
@@ -352,7 +367,10 @@ return {
           if require("trouble").is_open() then
             require("trouble").previous({ skip_groups = true, jump = true })
           else
-            vim.cmd.cprev()
+            local ok, err = pcall(vim.cmd.cprev)
+            if not ok then
+              vim.notify(err, vim.log.levels.ERROR)
+            end
           end
         end,
         desc = "Previous trouble/quickfix item",
@@ -363,7 +381,10 @@ return {
           if require("trouble").is_open() then
             require("trouble").next({ skip_groups = true, jump = true })
           else
-            vim.cmd.cnext()
+            local ok, err = pcall(vim.cmd.cnext)
+            if not ok then
+              vim.notify(err, vim.log.levels.ERROR)
+            end
           end
         end,
         desc = "Next trouble/quickfix item",

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,
@@ -54,7 +62,7 @@ return {
           -- fixes lazy-loading issues with the copilot cmp source
           require("lazyvim.util").on_attach(function(client)
             if client.name == "copilot" then
-              copilot_cmp._on_insert_enter()
+              copilot_cmp._on_insert_enter({})
             end
           end)
         end,
@@ -66,21 +74,6 @@ return {
 
       table.insert(opts.sources, 1, { name = "copilot", group_index = 2 })
 
-      local confirm = opts.mapping["<CR>"]
-      local confirm_copilot = cmp.mapping.confirm({
-        select = true,
-        behavior = cmp.ConfirmBehavior.Replace,
-      })
-
-      opts.mapping = vim.tbl_extend("force", opts.mapping, {
-        ["<CR>"] = function(...)
-          local entry = cmp.get_selected_entry()
-          if entry and entry.source.name == "copilot" then
-            return confirm_copilot(...)
-          end
-          return confirm(...)
-        end,
-      })
       opts.sorting = {
         priority_weight = 2,
         comparators = {

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

@@ -37,6 +37,7 @@ return {
     -- which key integration
     {
       "folke/which-key.nvim",
+      optional = true,
       opts = {
         defaults = {
           ["<leader>d"] = { name = "+debug" },
@@ -53,7 +54,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/lang/go.lua

@@ -0,0 +1,77 @@
+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 = {
+          settings = {
+            gopls = {
+              semanticTokens = true,
+            },
+          },
+        },
+      },
+      setup = {
+        gopls = function()
+          -- 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,
+      },
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      {
+        "mason.nvim",
+        opts = function(_, opts)
+          opts.ensure_installed = opts.ensure_installed or {}
+          table.insert(opts.ensure_installed, "delve")
+        end,
+      },
+    },
+  },
+  {
+    "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/tailwind.lua

@@ -0,0 +1,35 @@
+return {
+  {
+    "neovim/nvim-lspconfig",
+    opts = {
+      servers = {
+        tailwindcss = {
+          filetypes_exclude = { "markdown" },
+        },
+      },
+      setup = {
+        tailwindcss = function(_, opts)
+          local tw = require("lspconfig.server_configurations.tailwindcss")
+          --- @param ft string
+          opts.filetypes = vim.tbl_filter(function(ft)
+            return not vim.tbl_contains(opts.filetypes_exclude or {}, ft)
+          end, tw.default_config.filetypes)
+        end,
+      },
+    },
+  },
+  {
+    "hrsh7th/nvim-cmp",
+    dependencies = {
+      { "roobert/tailwindcss-colorizer-cmp.nvim", config = true },
+    },
+    opts = function(_, opts)
+      -- original LazyVim kind icon formatter
+      local format_kinds = opts.formatting.format
+      opts.formatting.format = function(entry, item)
+        format_kinds(entry, item) -- add icons
+        return require("tailwindcss-colorizer-cmp").formatter(entry, item)
+      end
+    end,
+  },
+}

lua/lazyvim/plugins/extras/lang/typescript.lua

@@ -62,4 +62,56 @@ return {
       table.insert(opts.sources, require("typescript.extensions.null-ls.code-actions"))
     end,
   },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    dependencies = {
+      {
+        "williamboman/mason.nvim",
+        opts = function(_, opts)
+          opts.ensure_installed = opts.ensure_installed or {}
+          table.insert(opts.ensure_installed, "js-debug-adapter")
+        end,
+      },
+    },
+    opts = function()
+      local dap = require("dap")
+      if not dap.adapters["pwa-node"] then
+        require("dap").adapters["pwa-node"] = {
+          type = "server",
+          host = "localhost",
+          port = "${port}",
+          executable = {
+            command = "node",
+            -- 💀 Make sure to update this path to point to your installation
+            args = {
+              require("mason-registry").get_package("js-debug-adapter"):get_install_path()
+                .. "/js-debug/src/dapDebugServer.js",
+              "${port}",
+            },
+          },
+        }
+      end
+      for _, language in ipairs({ "typescript", "javascript" }) do
+        if not dap.configurations[language] then
+          dap.configurations[language] = {
+            {
+              type = "pwa-node",
+              request = "launch",
+              name = "Launch file",
+              program = "${file}",
+              cwd = "${workspaceFolder}",
+            },
+            {
+              type = "pwa-node",
+              request = "attach",
+              name = "Attach",
+              processId = require("dap.utils").pick_process,
+              cwd = "${workspaceFolder}",
+            },
+          }
+        end
+      end
+    end,
+  },
 }

lua/lazyvim/plugins/extras/linting/eslint.lua

@@ -3,6 +3,7 @@ return {
     "neovim/nvim-lspconfig",
     -- other settings removed for brevity
     opts = {
+      ---@type lspconfig.options
       servers = {
         eslint = {
           settings = {
@@ -15,8 +16,17 @@ return {
         eslint = function()
           vim.api.nvim_create_autocmd("BufWritePre", {
             callback = function(event)
-              if require("lspconfig.util").get_active_client_by_name(event.buf, "eslint") then
-                vim.cmd("EslintFixAll")
+              if not require("lazyvim.plugins.lsp.format").enabled() then
+                -- exit early if autoformat is not enabled
+                return
+              end
+
+              local client = vim.lsp.get_active_clients({ bufnr = event.buf, name = "eslint" })[1]
+              if client then
+                local diag = vim.diagnostic.get(event.buf, { namespace = vim.lsp.diagnostic.get_namespace(client.id) })
+                if #diag > 0 then
+                  vim.cmd("EslintFixAll")
+                end
               end
             end,
           })

lua/lazyvim/plugins/extras/test/core.lua

@@ -0,0 +1,96 @@
+return {
+  {
+    "folke/which-key.nvim",
+    optional = true,
+    opts = {
+      defaults = {
+        ["<leader>t"] = { name = "+test" },
+      },
+    },
+  },
+  {
+    "nvim-neotest/neotest",
+    opts = {
+      -- Can be a list of adapters like what neotest expects,
+      -- or a list of adapter names,
+      -- or a table of adapter names, mapped to adapter configs.
+      -- The adapter will then be automatically loaded with the config.
+      adapters = {},
+      -- Example for loading neotest-go with a custom config
+      -- adapters = {
+      --   ["neotest-go"] = {
+      --     args = { "-tags=integration" },
+      --   },
+      -- },
+      status = { virtual_text = true },
+      output = { open_on_run = true },
+      quickfix = {
+        open = function()
+          if require("lazyvim.util").has("trouble.nvim") then
+            vim.cmd("Trouble quickfix")
+          else
+            vim.cmd("copen")
+          end
+        end,
+      },
+    },
+    config = function(_, opts)
+      local neotest_ns = vim.api.nvim_create_namespace("neotest")
+      vim.diagnostic.config({
+        virtual_text = {
+          format = function(diagnostic)
+            -- Replace newline and tab characters with space for more compact diagnostics
+            local message = diagnostic.message:gsub("\n", " "):gsub("\t", " "):gsub("%s+", " "):gsub("^%s+", "")
+            return message
+          end,
+        },
+      }, neotest_ns)
+
+      if opts.adapters then
+        local adapters = {}
+        for name, config in pairs(opts.adapters or {}) do
+          if type(name) == "number" then
+            if type(config) == "string" then
+              config = require(config)
+            end
+            adapters[#adapters + 1] = config
+          elseif config ~= false then
+            local adapter = require(name)
+            if type(config) == "table" and not vim.tbl_isempty(config) then
+              local meta = getmetatable(adapter)
+              if adapter.setup then
+                adapter.setup(config)
+              elseif meta and meta.__call then
+                adapter(config)
+              else
+                error("Adapter " .. name .. " does not support setup")
+              end
+            end
+            adapters[#adapters + 1] = adapter
+          end
+        end
+        opts.adapters = adapters
+      end
+
+      require("neotest").setup(opts)
+    end,
+    -- stylua: ignore
+    keys = {
+      { "<leader>tt", function() require("neotest").run.run(vim.fn.expand("%")) end, desc = "Run File" },
+      { "<leader>tT", function() require("neotest").run.run(vim.loop.cwd()) end, desc = "Run All Test Files" },
+      { "<leader>tr", function() require("neotest").run.run() end, desc = "Run Nearest" },
+      { "<leader>ts", function() require("neotest").summary.toggle() end, desc = "Toggle Summary" },
+      { "<leader>to", function() require("neotest").output.open({ enter = true, auto_close = true }) end, desc = "Show Output" },
+      { "<leader>tO", function() require("neotest").output_panel.toggle() end, desc = "Toggle Output Panel" },
+      { "<leader>tS", function() require("neotest").run.stop() end, desc = "Stop" },
+    },
+  },
+  {
+    "mfussenegger/nvim-dap",
+    optional = true,
+    -- stylua: ignore
+    keys = {
+      { "<leader>td", function() require("neotest").run.run({strategy = "dap"}) end, desc = "Debug Nearest" },
+    },
+  },
+}

lua/lazyvim/plugins/extras/ui/edgy.lua

@@ -0,0 +1,125 @@
+return {
+  -- edgy
+  {
+    "folke/edgy.nvim",
+    event = "VeryLazy",
+    keys = {
+      -- stylua: ignore
+      { "<leader>ue", function() require("edgy").select() end, desc = "Edgy Select Window" },
+    },
+    opts = {
+      bottom = {
+        {
+          ft = "toggleterm",
+          size = { height = 0.4 },
+          filter = function(buf, win)
+            return vim.api.nvim_win_get_config(win).relative == ""
+          end,
+        },
+        {
+          ft = "noice",
+          -- size = { height = 0.4 },
+          filter = function(buf, win)
+            return vim.api.nvim_win_get_config(win).relative == ""
+          end,
+        },
+        {
+          ft = "lazyterm",
+          title = "LazyTerm",
+          size = { height = 0.4 },
+          filter = function(buf)
+            return not vim.b[buf].lazyterm_cmd
+          end,
+        },
+        "Trouble",
+        { ft = "qf", title = "QuickFix" },
+        {
+          ft = "help",
+          size = { height = 20 },
+          -- don't open help files in edgy that we're editing
+          filter = function(buf)
+            return vim.bo[buf].buftype == "help"
+          end,
+        },
+        { ft = "spectre_panel", size = { height = 0.4 } },
+      },
+      left = {
+        {
+          title = "Neo-Tree",
+          ft = "neo-tree",
+          filter = function(buf)
+            return vim.b[buf].neo_tree_source == "filesystem"
+          end,
+          size = { height = 0.5 },
+        },
+        {
+          title = "Neo-Tree Git",
+          ft = "neo-tree",
+          filter = function(buf)
+            return vim.b[buf].neo_tree_source == "git_status"
+          end,
+          pinned = true,
+          open = "Neotree position=right git_status",
+        },
+        {
+          title = "Neo-Tree Buffers",
+          ft = "neo-tree",
+          filter = function(buf)
+            return vim.b[buf].neo_tree_source == "buffers"
+          end,
+          pinned = true,
+          open = "Neotree position=top buffers",
+        },
+        {
+          ft = "Outline",
+          pinned = true,
+          open = "SymbolsOutline",
+        },
+        "neo-tree",
+      },
+    },
+  },
+
+  -- prevent neo-tree from opening files in edgy windows
+  {
+    "nvim-neo-tree/neo-tree.nvim",
+    optional = true,
+    opts = function(_, opts)
+      opts.open_files_do_not_replace_types = opts.open_files_do_not_replace_types
+        or { "terminal", "Trouble", "qf", "Outline" }
+      table.insert(opts.open_files_do_not_replace_types, "edgy")
+    end,
+  },
+
+  -- Fix bufferline offsets when edgy is loaded
+  {
+    "akinsho/bufferline.nvim",
+    optional = true,
+    opts = function()
+      local Offset = require("bufferline.offset")
+      if not Offset.edgy then
+        local get = Offset.get
+        Offset.get = function()
+          if package.loaded.edgy then
+            local layout = require("edgy.config").layout
+            local ret = { left = "", left_size = 0, right = "", right_size = 0 }
+            for _, pos in ipairs({ "left", "right" }) do
+              local sb = layout[pos]
+              if sb and #sb.wins > 0 then
+                local title = " Sidebar" .. string.rep(" ", sb.bounds.width - 8)
+                ret[pos] = "%#EdgyTitle#" .. title .. "%*" .. "%#WinSeparator#│%*"
+                ret[pos .. "_size"] = sb.bounds.width
+              end
+            end
+            ret.total_size = ret.left_size + ret.right_size
+            if ret.total_size > 0 then
+              return ret
+            end
+          end
+          return get()
+        end
+        Offset.edgy = true
+      end
+    end,
+  },
+}

lua/lazyvim/plugins/extras/ui/mini-animate.lua

@@ -33,8 +33,5 @@ return {
         },
       }
     end,
-    config = function(_, opts)
-      require("mini.animate").setup(opts)
-    end,
   },
 }

lua/lazyvim/plugins/extras/ui/mini-starter.lua

@@ -10,12 +10,12 @@ return {
     event = "VimEnter",
     opts = function()
       local logo = table.concat({
-        "██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z",
-        "██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z",
-        "██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z",
-        "██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z",
-        "███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║",
-        "╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝",
+        "            ██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z",
+        "            ██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z    ",
+        "            ██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z       ",
+        "            ██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z         ",
+        "            ███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║           ",
+        "            ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝           ",
       }, "\n")
       local pad = string.rep(" ", 22)
       local new_section = function(name, action, section)

lua/lazyvim/plugins/extras/util/project.lua

@@ -20,6 +20,7 @@ return {
 
   {
     "goolord/alpha-nvim",
+    optional = true,
     opts = function(_, dashboard)
       local button = dashboard.button("p", " " .. " Projects", ":Telescope projects <CR>")
       button.opts.hl = "AlphaButtons"
@@ -27,4 +28,18 @@ return {
       table.insert(dashboard.section.buttons.val, 4, button)
     end,
   },
+  {
+    "echasnovski/mini.starter",
+    optional = true,
+    opts = function(_, opts)
+      local items = {
+        {
+          name = "Projects",
+          action = "Telescope projects",
+          section = string.rep(" ", 22) .. "Telescope",
+        },
+      }
+      vim.list_extend(opts.items, items)
+    end,
+  },
 }

lua/lazyvim/plugins/extras/vscode.lua

@@ -0,0 +1,67 @@
+if not vim.g.vscode then
+  return {}
+end
+
+local enabled = {
+  "flit.nvim",
+  "lazy.nvim",
+  "leap.nvim",
+  "mini.ai",
+  "mini.comment",
+  "mini.pairs",
+  "mini.surround",
+  "nvim-treesitter",
+  "nvim-treesitter-textobjects",
+  "nvim-ts-context-commentstring",
+  "vim-repeat",
+  "LazyVim",
+}
+
+local Config = require("lazy.core.config")
+local Plugin = require("lazy.core.plugin")
+Config.options.checker.enabled = false
+Config.options.change_detection.enabled = false
+
+-- HACK: disable all plugins except the ones we want
+local fix_disabled = Plugin.Spec.fix_disabled
+function Plugin.Spec.fix_disabled(self)
+  for _, plugin in pairs(self.plugins) do
+    if not (vim.tbl_contains(enabled, plugin.name) or plugin.vscode) then
+      plugin.enabled = false
+    end
+  end
+  fix_disabled(self)
+end
+
+-- HACK: don't clean plugins in vscode
+local update_state = Plugin.update_state
+function Plugin.update_state()
+  update_state()
+  Config.to_clean = {}
+end
+
+-- Add some vscode specific keymaps
+vim.api.nvim_create_autocmd("User", {
+  pattern = "LazyVimKeymaps",
+  callback = function()
+    vim.keymap.set("n", "<leader><space>", "<cmd>Find<cr>")
+    vim.keymap.set("n", "<leader>/", [[<cmd>call VSCodeNotify('workbench.action.findInFiles')<cr>]])
+    vim.keymap.set("n", "<leader>ss", [[<cmd>call VSCodeNotify('workbench.action.gotoSymbol')<cr>]])
+  end,
+})
+
+return {
+  {
+    "LazyVim/LazyVim",
+    config = function(_, opts)
+      opts = opts or {}
+      -- disable the colorscheme
+      opts.colorscheme = function() end
+      require("lazyvim").setup(opts)
+    end,
+  },
+  {
+    "nvim-treesitter/nvim-treesitter",
+    opts = { highlight = { enable = false } },
+  },
+}

lua/lazyvim/plugins/lsp/format.lua

@@ -2,16 +2,21 @@ local Util = require("lazy.core.util")
 
 local M = {}
 
-M.autoformat = true
+---@type PluginLspOpts
+M.opts = nil
+
+function M.enabled()
+  return M.opts.autoformat
+end
 
 function M.toggle()
   if vim.b.autoformat == false then
     vim.b.autoformat = nil
-    M.autoformat = true
+    M.opts.autoformat = true
   else
-    M.autoformat = not M.autoformat
+    M.opts.autoformat = not M.opts.autoformat
   end
-  if M.autoformat then
+  if M.opts.autoformat then
     Util.info("Enabled format on save", { title = "Format" })
   else
     Util.warn("Disabled format on save", { title = "Format" })
@@ -24,41 +29,124 @@ function M.format(opts)
   if vim.b.autoformat == false and not (opts and opts.force) then
     return
   end
-  local ft = vim.bo[buf].filetype
-  local have_nls = #require("null-ls.sources").get_available(ft, "NULL_LS_FORMATTING") > 0
+
+  local formatters = M.get_formatters(buf)
+  local client_ids = vim.tbl_map(function(client)
+    return client.id
+  end, formatters.active)
+
+  if #client_ids == 0 then
+    return
+  end
+
+  if M.opts.format_notify then
+    M.notify(formatters)
+  end
 
   vim.lsp.buf.format(vim.tbl_deep_extend("force", {
     bufnr = buf,
     filter = function(client)
-      if have_nls then
-        return client.name == "null-ls"
-      end
-      return client.name ~= "null-ls"
+      return vim.tbl_contains(client_ids, client.id)
     end,
   }, require("lazyvim.util").opts("nvim-lspconfig").format or {}))
 end
 
-function M.on_attach(client, buf)
-  -- dont format if client disabled it
+---@param formatters LazyVimFormatters
+function M.notify(formatters)
+  local lines = { "# Active:" }
+
+  for _, client in ipairs(formatters.active) do
+    local line = "- **" .. client.name .. "**"
+    if client.name == "null-ls" then
+      line = line
+        .. " ("
+        .. table.concat(
+          vim.tbl_map(function(f)
+            return "`" .. f.name .. "`"
+          end, formatters.null_ls),
+          ", "
+        )
+        .. ")"
+    end
+    table.insert(lines, line)
+  end
+
+  if #formatters.available > 0 then
+    table.insert(lines, "")
+    table.insert(lines, "# Disabled:")
+    for _, client in ipairs(formatters.available) do
+      table.insert(lines, "- **" .. client.name .. "**")
+    end
+  end
+
+  vim.notify(table.concat(lines, "\n"), vim.log.levels.INFO, {
+    title = "Formatting",
+    on_open = function(win)
+      vim.api.nvim_win_set_option(win, "conceallevel", 3)
+      vim.api.nvim_win_set_option(win, "spell", false)
+      local buf = vim.api.nvim_win_get_buf(win)
+      vim.treesitter.start(buf, "markdown")
+    end,
+  })
+end
+
+-- Gets all lsp clients that support formatting.
+-- When a null-ls formatter is available for the current filetype,
+-- only null-ls formatters are returned.
+function M.get_formatters(bufnr)
+  local ft = vim.bo[bufnr].filetype
+  -- check if we have any null-ls formatters for the current filetype
+  local null_ls = package.loaded["null-ls"] and require("null-ls.sources").get_available(ft, "NULL_LS_FORMATTING") or {}
+
+  ---@class LazyVimFormatters
+  local ret = {
+    ---@type lsp.Client[]
+    active = {},
+    ---@type lsp.Client[]
+    available = {},
+    null_ls = null_ls,
+  }
+
+  ---@type lsp.Client[]
+  local clients = vim.lsp.get_active_clients({ bufnr = bufnr })
+  for _, client in ipairs(clients) do
+    if M.supports_format(client) then
+      if (#null_ls > 0 and client.name == "null-ls") or #null_ls == 0 then
+        table.insert(ret.active, client)
+      else
+        table.insert(ret.available, client)
+      end
+    end
+  end
+
+  return ret
+end
+
+-- Gets all lsp clients that support formatting
+-- and have not disabled it in their client config
+---@param client lsp.Client
+function M.supports_format(client)
   if
     client.config
     and client.config.capabilities
     and client.config.capabilities.documentFormattingProvider == false
   then
-    return
+    return false
   end
+  return client.supports_method("textDocument/formatting") or client.supports_method("textDocument/rangeFormatting")
+end
 
-  if client.supports_method("textDocument/formatting") then
-    vim.api.nvim_create_autocmd("BufWritePre", {
-      group = vim.api.nvim_create_augroup("LspFormat." .. buf, {}),
-      buffer = buf,
-      callback = function()
-        if M.autoformat then
-          M.format()
-        end
-      end,
-    })
-  end
+---@param opts PluginLspOpts
+function M.setup(opts)
+  M.opts = opts
+  vim.api.nvim_create_autocmd("BufWritePre", {
+    group = vim.api.nvim_create_augroup("LazyVimFormat", {}),
+    callback = function()
+      if M.opts.autoformat then
+        M.format()
+      end
+    end,
+  })
 end
 
 return M

lua/lazyvim/plugins/lsp/init.lua

@@ -5,7 +5,7 @@ return {
     event = { "BufReadPre", "BufNewFile" },
     dependencies = {
       { "folke/neoconf.nvim", cmd = "Neoconf", config = true },
-      { "folke/neodev.nvim", opts = { experimental = { pathStrict = true } } },
+      { "folke/neodev.nvim", opts = {} },
       "mason.nvim",
       "williamboman/mason-lspconfig.nvim",
       {
@@ -35,6 +35,9 @@ return {
       capabilities = {},
       -- Automatically format on save
       autoformat = true,
+      -- Enable this to show formatters used in a notification
+      -- Useful for debugging formatter issues
+      format_notify = false,
       -- options for vim.lsp.buf.format
       -- `bufnr` and `filter` is handled by the LazyVim formatter,
       -- but can be also overridden when specified
@@ -77,10 +80,9 @@ return {
     config = function(_, opts)
       local Util = require("lazyvim.util")
       -- setup autoformat
-      require("lazyvim.plugins.lsp.format").autoformat = opts.autoformat
+      require("lazyvim.plugins.lsp.format").setup(opts)
       -- setup formatting and keymaps
       Util.on_attach(function(client, buffer)
-        require("lazyvim.plugins.lsp.format").on_attach(client, buffer)
         require("lazyvim.plugins.lsp.keymaps").on_attach(client, buffer)
       end)
 
@@ -151,8 +153,7 @@ return {
       end
 
       if have_mason then
-        mlsp.setup({ ensure_installed = ensure_installed })
-        mlsp.setup_handlers({ setup })
+        mlsp.setup({ ensure_installed = ensure_installed, handlers = { setup } })
       end
 
       if Util.lsp_get_config("denols") and Util.lsp_get_config("tsserver") then

lua/lazyvim/plugins/treesitter.lua

@@ -34,7 +34,6 @@ return {
     opts = {
       highlight = { enable = true },
       indent = { enable = true },
-      context_commentstring = { enable = true, enable_autocmd = false },
       ensure_installed = {
         "bash",
         "c",

lua/lazyvim/plugins/ui.lua

@@ -8,7 +8,7 @@ return {
         function()
           require("notify").dismiss({ silent = true, pending = true })
         end,
-        desc = "Delete all Notifications",
+        desc = "Dismiss all Notifications",
       },
     },
     opts = {
@@ -169,7 +169,18 @@ return {
     opts = {
       -- char = "▏",
       char = "│",
-      filetype_exclude = { "help", "alpha", "dashboard", "neo-tree", "Trouble", "lazy" },
+      filetype_exclude = {
+        "help",
+        "alpha",
+        "dashboard",
+        "neo-tree",
+        "Trouble",
+        "lazy",
+        "mason",
+        "notify",
+        "toggleterm",
+        "lazyterm",
+      },
       show_trailing_blankline_indent = false,
       show_current_context = false,
     },
@@ -187,15 +198,23 @@ return {
     },
     init = function()
       vim.api.nvim_create_autocmd("FileType", {
-        pattern = { "help", "alpha", "dashboard", "neo-tree", "Trouble", "lazy", "mason" },
+        pattern = {
+          "help",
+          "alpha",
+          "dashboard",
+          "neo-tree",
+          "Trouble",
+          "lazy",
+          "mason",
+          "notify",
+          "toggleterm",
+          "lazyterm",
+        },
         callback = function()
           vim.b.miniindentscope_disable = true
         end,
       })
     end,
-    config = function(_, opts)
-      require("mini.indentscope").setup(opts)
-    end,
   },
 
   -- noicer ui
@@ -218,12 +237,27 @@ return {
         override = {
           ["vim.lsp.util.convert_input_to_markdown_lines"] = true,
           ["vim.lsp.util.stylize_markdown"] = true,
+          ["cmp.entry.get_documentation"] = true,
+        },
+      },
+      routes = {
+        {
+          filter = {
+            event = "msg_show",
+            any = {
+              { find = "%d+L, %d+B" },
+              { find = "; after #%d+" },
+              { find = "; before #%d+" },
+            },
+          },
+          view = "mini",
         },
       },
       presets = {
         bottom_search = true,
         command_palette = true,
         long_message_to_split = true,
+        inc_rename = true,
       },
     },
     -- stylua: ignore
@@ -245,12 +279,12 @@ return {
     opts = function()
       local dashboard = require("alpha.themes.dashboard")
       local logo = [[
-      ██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z
-      ██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z    
-      ██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z       
-      ██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z         
-      ███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║
-      ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝
+           ██╗      █████╗ ███████╗██╗   ██╗██╗   ██╗██╗███╗   ███╗          Z
+           ██║     ██╔══██╗╚══███╔╝╚██╗ ██╔╝██║   ██║██║████╗ ████║      Z    
+           ██║     ███████║  ███╔╝  ╚████╔╝ ██║   ██║██║██╔████╔██║   z       
+           ██║     ██╔══██║ ███╔╝    ╚██╔╝  ╚██╗ ██╔╝██║██║╚██╔╝██║ z         
+           ███████╗██║  ██║███████╗   ██║    ╚████╔╝ ██║██║ ╚═╝ ██║
+           ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝     ╚═══╝  ╚═╝╚═╝     ╚═╝
       ]]
 
       dashboard.section.header.val = vim.split(logo, "\n")

lua/lazyvim/plugins/util.lua

@@ -13,7 +13,7 @@ return {
   {
     "folke/persistence.nvim",
     event = "BufReadPre",
-    opts = { options = { "buffers", "curdir", "tabpages", "winsize", "help", "globals" } },
+    opts = { options = { "buffers", "curdir", "tabpages", "winsize", "help", "globals", "skiprtp" } },
     -- stylua: ignore
     keys = {
       { "<leader>qs", function() require("persistence").load() end, desc = "Restore Session" },

lua/lazyvim/util/init.lua

@@ -105,21 +105,57 @@ function M.telescope(builtin, opts)
         builtin = "find_files"
       end
     end
+    if opts.cwd and opts.cwd ~= vim.loop.cwd() then
+      opts.attach_mappings = function(_, map)
+        map("i", "<a-c>", function()
+          local action_state = require("telescope.actions.state")
+          local line = action_state.get_current_line()
+          M.telescope(
+            params.builtin,
+            vim.tbl_deep_extend("force", {}, params.opts or {}, { cwd = false, default_text = line })
+          )()
+        end)
+        return true
+      end
+    end
+
     require("telescope.builtin")[builtin](opts)
   end
 end
 
+---@type table<string,LazyFloat>
+local terminals = {}
+
 -- Opens a floating terminal (interactive by default)
 ---@param cmd? string[]|string
 ---@param opts? LazyCmdOptions|{interactive?:boolean, esc_esc?:false}
 function M.float_term(cmd, opts)
   opts = vim.tbl_deep_extend("force", {
+    ft = "lazyterm",
     size = { width = 0.9, height = 0.9 },
-  }, opts or {})
-  local float = require("lazy.util").float_term(cmd, opts)
-  if opts.esc_esc == false then
-    vim.keymap.set("t", "<esc>", "<esc>", { buffer = float.buf, nowait = true })
+  }, opts or {}, { persistent = true })
+  ---@cast opts LazyCmdOptions|{interactive?:boolean, esc_esc?:false}
+
+  local termkey = vim.inspect({ cmd = cmd or "shell", cwd = opts.cwd, env = opts.env })
+
+  if terminals[termkey] and terminals[termkey]:buf_valid() then
+    terminals[termkey]:toggle()
+  else
+    terminals[termkey] = require("lazy.util").float_term(cmd, opts)
+    local buf = terminals[termkey].buf
+    vim.b[buf].lazyterm_cmd = cmd
+    if opts.esc_esc == false then
+      vim.keymap.set("t", "<esc>", "<esc>", { buffer = buf, nowait = true })
+    end
+    vim.api.nvim_create_autocmd("BufEnter", {
+      buffer = buf,
+      callback = function()
+        vim.cmd.startinsert()
+      end,
+    })
   end
+
+  return terminals[termkey]
 end
 
 ---@param silent boolean?