Big commit biiiig commit

lua/custom/mappings/init.lua

@@ -9,3 +9,13 @@ vim.keymap.set('n', '<C-S-a>', 'ggVG')
 -- Stop deselecting after indenting
 vim.keymap.set('v', '<', '<gv')
 vim.keymap.set('v', '>', '>gv')
+
+-- Move stuff up and down
+vim.keymap.set('v', 'J', ":m '>+1<CR>gv=gv")
+vim.keymap.set('v', 'K', ":m '>-2<CR>gv=gv")
+
+-- Move down/up lines but recenter
+vim.keymap.set('n', '<C-d>', '<C-d>zz', { noremap = true, silent = true })
+vim.keymap.set('n', '<C-u>', '<C-u>zz', { noremap = true, silent = true })
+vim.keymap.set('n', 'j', 'jzz', { noremap = true, silent = true })
+vim.keymap.set('n', 'k', 'kzz', { noremap = true, silent = true })

lua/custom/plugins/autocomplete.lua

@@ -0,0 +1,110 @@
+-- Autocompletion
+return {
+  'hrsh7th/nvim-cmp',
+  event = 'InsertEnter',
+  dependencies = {
+    -- Snippet Engine & its associated nvim-cmp source
+    {
+      'L3MON4D3/LuaSnip',
+      build = (function()
+        -- Build Step is needed for regex support in snippets.
+        -- This step is not supported in many windows environments.
+        -- Remove the below condition to re-enable on windows.
+        if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then
+          return
+        end
+        return 'make install_jsregexp'
+      end)(),
+      dependencies = {
+        -- `friendly-snippets` contains a variety of premade snippets.
+        --    See the README about individual language/framework/plugin snippets:
+        --    https://github.com/rafamadriz/friendly-snippets
+        -- {
+        --   'rafamadriz/friendly-snippets',
+        --   config = function()
+        --     require('luasnip.loaders.from_vscode').lazy_load()
+        --   end,
+        -- },
+      },
+    },
+    'saadparwaiz1/cmp_luasnip',
+
+    -- Adds other completion capabilities.
+    --  nvim-cmp does not ship with all sources by default. They are split
+    --  into multiple repos for maintenance purposes.
+    'hrsh7th/cmp-nvim-lsp',
+    'hrsh7th/cmp-path',
+  },
+  config = function()
+    -- See `:help cmp`
+    local cmp = require 'cmp'
+    local luasnip = require 'luasnip'
+    luasnip.config.setup {}
+
+    cmp.setup {
+      snippet = {
+        expand = function(args)
+          luasnip.lsp_expand(args.body)
+        end,
+      },
+      completion = { completeopt = 'menu,menuone,noinsert' },
+
+      -- For an understanding of why these mappings were
+      -- chosen, you will need to read `:help ins-completion`
+      --
+      -- No, but seriously. Please read `:help ins-completion`, it is really good!
+      mapping = cmp.mapping.preset.insert {
+        -- Select the [n]ext item
+        ['<C-n>'] = cmp.mapping.select_next_item(),
+        -- Select the [p]revious item
+        ['<C-p>'] = cmp.mapping.select_prev_item(),
+
+        -- Scroll the documentation window [b]ack / [f]orward
+        ['<C-b>'] = cmp.mapping.scroll_docs(-4),
+        ['<C-f>'] = cmp.mapping.scroll_docs(4),
+        -- Accept ([y]es) the completion.
+        --  This will auto-import if your LSP supports it.
+        --  This will expand snippets if the LSP sent a snippet.
+        ['<C-y>'] = cmp.mapping.confirm { select = true },
+
+        -- If you prefer more traditional completion keymaps,
+        -- you can uncomment the following lines
+        --['<CR>'] = cmp.mapping.confirm { select = true },
+        --['<Tab>'] = cmp.mapping.select_next_item(),
+        --['<S-Tab>'] = cmp.mapping.select_prev_item(),
+
+        -- Manually trigger a completion from nvim-cmp.
+        --  Generally you don't need this, because nvim-cmp will display
+        --  completions whenever it has completion options available.
+        ['<C-Space>'] = cmp.mapping.complete {},
+
+        -- Think of <c-l> as moving to the right of your snippet expansion.
+        --  So if you have a snippet that's like:
+        --  function $name($args)
+        --    $body
+        --  end
+        --
+        -- <c-l> will move you to the right of each of the expansion locations.
+        -- <c-h> is similar, except moving you backwards.
+        ['<C-l>'] = cmp.mapping(function()
+          if luasnip.expand_or_locally_jumpable() then
+            luasnip.expand_or_jump()
+          end
+        end, { 'i', 's' }),
+        ['<C-h>'] = cmp.mapping(function()
+          if luasnip.locally_jumpable(-1) then
+            luasnip.jump(-1)
+          end
+        end, { 'i', 's' }),
+
+        -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
+        --    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
+      },
+      sources = {
+        { name = 'nvim_lsp' },
+        { name = 'luasnip' },
+        { name = 'path' },
+      },
+    }
+  end,
+}

lua/custom/plugins/autoformat.lua

@@ -0,0 +1,45 @@
+-- Autoformat
+return {
+  'stevearc/conform.nvim',
+  lazy = false,
+  keys = {
+    {
+      '<leader>F',
+      function()
+        require('conform').format { async = true, lsp_fallback = true }
+      end,
+      mode = '',
+      desc = '[F]ormat buffer',
+    },
+  },
+  opts = {
+    notify_on_error = false,
+    format_on_save = function(bufnr)
+      -- Disable "format_on_save lsp_fallback" for languages that don't
+      -- have a well standardized coding style. You can add additional
+      -- languages here or re-enable it for the disabled ones.
+      local disable_filetypes = { c = true, cpp = true }
+      return {
+        timeout_ms = 500,
+        lsp_fallback = not disable_filetypes[vim.bo[bufnr].filetype],
+      }
+    end,
+    formatters_by_ft = {
+      lua = { 'stylua' },
+      python = { 'autopep8' },
+      javascript = { { 'prettierd', 'prettier' } },
+      c = { 'clang-format' },
+      cpp = { 'clang-format' },
+      yaml = { 'yamlfmt' },
+      html = { 'djlint' },
+      css = { { 'prettierd', 'prettier' } },
+      json = { 'deno_fmt' },
+      -- Conform can also run multiple formatters sequentially
+      -- python = { "isort", "black" },
+      --
+      -- You can use a sub-list to tell conform to run *until* a formatter
+      -- is found.
+      -- javascript = { { "prettierd", "prettier" } },
+    },
+  },
+}

lua/custom/plugins/barbar.lua

@@ -11,7 +11,7 @@ return {
       local map = vim.api.nvim_set_keymap
       local opts = { noremap = true, silent = true }
 
-      map('n', '<tab>', '<Cmd>BufferPrevious<CR>', opts)
+      map('n', '<tab>', '<Cmd>BufferNext<CR>', opts)
       map('n', '<S-tab>', '<Cmd>BufferPrevious<CR>', opts)
       map('n', '<leader>xx', '<Cmd>BufferClose<CR>', vim.tbl_extend('force', opts, { desc = '[X] Close buffer' }))
       map('n', '<leader>xl', '<Cmd>BufferCloseBuffersLeft<CR>', vim.tbl_extend('force', opts, { desc = '[L] Close all buffers left' }))

lua/custom/plugins/harpoon.lua

@@ -0,0 +1,14 @@
+return {
+  'ThePrimeagen/harpoon',
+  lazy = false,
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+  },
+  config = true,
+  keys = {
+    { '<leader>hm', "<cmd>lua require('harpoon.mark').add_file()<cr>", desc = 'Mark file with harpoon' },
+    { '<leader>hn', "<cmd>lua require('harpoon.ui').nav_next()<cr>", desc = 'Go to next harpoon mark' },
+    { '<leader>hp', "<cmd>lua require('harpoon.ui').nav_prev()<cr>", desc = 'Go to previous harpoon mark' },
+    { '<leader>ha', "<cmd>lua require('harpoon.ui').toggle_quick_menu()<cr>", desc = 'Show harpoon marks' },
+  },
+}

lua/custom/plugins/lsp.lua

@@ -0,0 +1,230 @@
+return { -- LSP Configuration & Plugins
+  'neovim/nvim-lspconfig',
+  dependencies = {
+    -- Automatically install LSPs and related tools to stdpath for Neovim
+    { 'williamboman/mason.nvim', config = true }, -- NOTE: Must be loaded before dependants
+    'williamboman/mason-lspconfig.nvim',
+    'WhoIsSethDaniel/mason-tool-installer.nvim',
+
+    -- Useful status updates for LSP.
+    -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
+    { 'j-hui/fidget.nvim', opts = {} },
+
+    -- `neodev` configures Lua LSP for your Neovim config, runtime and plugins
+    -- used for completion, annotations and signatures of Neovim apis
+    { 'folke/neodev.nvim', opts = {} },
+  },
+  config = function()
+    -- Brief aside: **What is LSP?**
+    --
+    -- LSP is an initialism you've probably heard, but might not understand what it is.
+    --
+    -- LSP stands for Language Server Protocol. It's a protocol that helps editors
+    -- and language tooling communicate in a standardized fashion.
+    --
+    -- In general, you have a "server" which is some tool built to understand a particular
+    -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers
+    -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone
+    -- processes that communicate with some "client" - in this case, Neovim!
+    --
+    -- LSP provides Neovim with features like:
+    --  - Go to definition
+    --  - Find references
+    --  - Autocompletion
+    --  - Symbol Search
+    --  - and more!
+    --
+    -- Thus, Language Servers are external tools that must be installed separately from
+    -- Neovim. This is where `mason` and related plugins come into play.
+    --
+    -- If you're wondering about lsp vs treesitter, you can check out the wonderfully
+    -- and elegantly composed help section, `:help lsp-vs-treesitter`
+
+    --  This function gets run when an LSP attaches to a particular buffer.
+    --    That is to say, every time a new file is opened that is associated with
+    --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
+    --    function will be executed to configure the current buffer
+    vim.api.nvim_create_autocmd('LspAttach', {
+      group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
+      callback = function(event)
+        -- NOTE: Remember that Lua is a real programming language, and as such it is possible
+        -- to define small helper and utility functions so you don't have to repeat yourself.
+        --
+        -- In this case, we create a function that lets us more easily define mappings specific
+        -- for LSP related items. It sets the mode, buffer and description for us each time.
+        local map = function(keys, func, desc)
+          vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
+        end
+
+        -- Jump to the definition of the word under your cursor.
+        --  This is where a variable was first declared, or where a function is defined, etc.
+        --  To jump back, press <C-t>.
+        map('gd', require('telescope.builtin').lsp_definitions, '[g]oto [d]efinition')
+
+        -- Find references for the word under your cursor.
+        map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
+
+        -- Jump to the implementation of the word under your cursor.
+        --  Useful when your language has ways of declaring types without an actual implementation.
+        map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
+
+        -- Jump to the type of the word under your cursor.
+        --  Useful when you're not sure what type a variable is and you want to see
+        --  the definition of its *type*, not where it was *defined*.
+        map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')
+
+        -- Fuzzy find all the symbols in your current document.
+        --  Symbols are things like variables, functions, types, etc.
+        map('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')
+
+        -- Fuzzy find all the symbols in your current workspace.
+        --  Similar to document symbols, except searches over your entire project.
+        map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')
+
+        -- Rename the variable under your cursor.
+        --  Most Language Servers support renaming across files, etc.
+        map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
+
+        -- Execute a code action, usually your cursor needs to be on top of an error
+        -- or a suggestion from your LSP for this to activate.
+        map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')
+
+        -- Opens a popup that displays documentation about the word under your cursor
+        --  See `:help K` for why this keymap.
+        map('K', vim.lsp.buf.hover, 'Hover Documentation')
+
+        -- WARN: This is not Goto Definition, this is Goto Declaration.
+        --  For example, in C this would take you to the header.
+        map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+
+        -- The following two autocommands are used to highlight references of the
+        -- word under your cursor when your cursor rests there for a little while.
+        --    See `:help CursorHold` for information about when this is executed
+        --
+        -- When you move your cursor, the highlights will be cleared (the second autocommand).
+        local client = vim.lsp.get_client_by_id(event.data.client_id)
+        if client and client.server_capabilities.documentHighlightProvider then
+          vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
+            buffer = event.buf,
+            callback = vim.lsp.buf.document_highlight,
+          })
+
+          vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
+            buffer = event.buf,
+            callback = vim.lsp.buf.clear_references,
+          })
+        end
+
+        -- The following autocommand is used to enable inlay hints in your
+        -- code, if the language server you are using supports them
+        --
+        -- This may be unwanted, since they displace some of your code
+        if client and client.server_capabilities.inlayHintProvider and vim.lsp.inlay_hint then
+          map('<leader>th', function()
+            vim.lsp.inlay_hint.enable(0, not vim.lsp.inlay_hint.is_enabled())
+          end, '[T]oggle Inlay [H]ints')
+        end
+      end,
+    })
+
+    -- LSP servers and clients are able to communicate to each other what features they support.
+    --  By default, Neovim doesn't support everything that is in the LSP specification.
+    --  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
+    --  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
+    local capabilities = vim.lsp.protocol.make_client_capabilities()
+    capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())
+
+    -- Enable the following language servers
+    --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
+    --
+    --  Add any additional override configuration in the following tables. Available keys are:
+    --  - cmd (table): Override the default command used to start the server
+    --  - filetypes (table): Override the default list of associated filetypes for the server
+    --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
+    --  - settings (table): Override the default settings passed when initializing the server.
+    --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
+    local servers = {
+      clangd = {
+        cmd = {
+          'clangd',
+          '--offset-encoding=UTF-8',
+          '--style=file ~/.config/nvim/clang-format',
+        },
+      },
+      -- gopls = {},
+      pyright = {},
+      deno = {},
+      -- rust_analyzer = {},
+      -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
+      --
+      -- Some languages (like typescript) have entire language plugins that can be useful:
+      --    https://github.com/pmizio/typescript-tools.nvim
+      --
+      -- But for many setups, the LSP (`tsserver`) will work just fine
+      tsserver = {
+        init_options = {
+          preferences = {
+            disableSuggestions = true,
+          },
+        },
+      },
+      --
+
+      lua_ls = {
+        -- cmd = {...},
+        -- filetypes = { ...},
+        -- capabilities = {},
+        settings = {
+          Lua = {
+            completion = {
+              callSnippet = 'Replace',
+            },
+            -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings
+            -- diagnostics = { disable = { 'missing-fields' } },
+          },
+        },
+      },
+    }
+
+    -- Ensure the servers and tools above are installed
+    --  To check the current status of installed tools and/or manually install
+    --  other tools, you can run
+    --    :Mason
+    --
+    --  You can press `g?` for help in this menu.
+    require('mason').setup()
+
+    -- You can add other tools here that you want Mason to install
+    -- for you, so that they are available from within Neovim.
+    local ensure_installed = vim.tbl_keys(servers or {})
+    vim.list_extend(ensure_installed, {
+      'stylua', -- Used to format Lua code
+      'clangd',
+      'clang-format',
+      'codelldb',
+      'cmake-language-server',
+      'mypy',
+      'ruff',
+      'pyright',
+      'prettier',
+      'autopep8',
+      'djlint',
+      'typescript-language-server',
+      'deno',
+    })
+    require('mason-tool-installer').setup { ensure_installed = ensure_installed }
+
+    require('mason-lspconfig').setup {
+      handlers = {
+        function(server_name)
+          local server = servers[server_name] or {}
+          -- This handles overriding only values explicitly passed
+          -- by the server configuration above. Useful when disabling
+          -- certain features of an LSP (for example, turning off formatting for tsserver)
+          server.capabilities = vim.tbl_deep_extend('force', {}, capabilities, server.capabilities or {})
+          require('lspconfig')[server_name].setup(server)
+        end,
+      },
+    }
+  end,
+}

lua/custom/plugins/refactoring.lua

@@ -0,0 +1,24 @@
+return {
+
+  'ThePrimeagen/refactoring.nvim',
+  dependencies = {
+    'nvim-lua/plenary.nvim',
+    'nvim-treesitter/nvim-treesitter',
+  },
+  init = function()
+    local map = vim.api.nvim_set_keymap
+    opts = { noremap = true, silent = true }
+
+    map('x', '<leader>Re', ':Refactor extract ', vim.tbl_extend('force', opts, { desc = '[E]xtract buffer' }))
+    map('x', '<leader>Rf', ':Refactor extract_to_file ', vim.tbl_extend('force', opts, { desc = 'Extract to [F]ile' }))
+    map('x', '<leader>Rv', ':Refactor extract_var ', vim.tbl_extend('force', opts, { desc = 'Extract [V]ariable' }))
+    map('n', '<leader>Ri', ':Refactor inline_var', vim.tbl_extend('force', opts, { desc = '[I]nline variable' }))
+    map('x', '<leader>Ri', ':Refactor inline_var', vim.tbl_extend('force', opts, { desc = '[I]nline variable' }))
+    map('n', '<leader>RI', ':Refactor inline_func', vim.tbl_extend('force', opts, { desc = 'Inline [F]unction' }))
+    map('n', '<leader>Rb', ':Refactor extract_block', vim.tbl_extend('force', opts, { desc = 'Extract [B]lock' }))
+    map('n', '<leader>Rbf', ':Refactor extract_block_to_file', vim.tbl_extend('force', opts, { desc = 'Extract block to [F]ile' }))
+  end,
+  config = function()
+    require('refactoring').setup()
+  end,
+}

lua/custom/plugins/toggleterm.lua

@@ -0,0 +1,21 @@
+return {
+  'akinsho/toggleterm.nvim',
+  version = '*',
+  config = true,
+  keys = {
+    {
+      '<leader>to',
+      '<Cmd>ToggleTerm<CR>',
+      desc = '[O]pen a horizontal terminal',
+    },
+    {
+      '<A-i>',
+      '<Cmd>ToggleTermToggle<CR>',
+    },
+    {
+      '<leader>tt',
+      '<Cmd>ToggleTermToggle<CR>',
+      desc = '[T]oggle terminals',
+    },
+  },
+}

lua/custom/plugins/trouble.lua

@@ -0,0 +1,36 @@
+return {
+  'folke/trouble.nvim',
+  dependencies = { 'nvim-tree/nvim-web-devicons' },
+  init = function()
+    local opts = { noremap = true, silent = true }
+    -- Lua
+    vim.keymap.set('n', '<leader>Xx', function()
+      require('trouble').toggle()
+    end, vim.tbl_extend('force', opts, { desc = '[X] Toggle trouble' }))
+
+    vim.keymap.set('n', '<leader>Xw', function()
+      require('trouble').toggle 'workspace_diagnostics'
+    end, vim.tbl_extend('force', opts, { desc = '[W]orkspace diagnostics' }))
+
+    vim.keymap.set('n', '<leader>Xd', function()
+      require('trouble').toggle 'document_diagnostics'
+    end, vim.tbl_extend('force', opts, { desc = '[D]ocument diagnostics' }))
+
+    vim.keymap.set('n', '<leader>Xq', function()
+      require('trouble').toggle 'quickfix'
+    end, vim.tbl_extend('force', opts, { desc = '[Q]uickfix' }))
+
+    vim.keymap.set('n', '<leader>Xl', function()
+      require('trouble').toggle 'loclist'
+    end, vim.tbl_extend('force', opts, { desc = '[L]oclist' }))
+
+    vim.keymap.set('n', 'gR', function()
+      require('trouble').toggle 'lsp_references'
+    end, vim.tbl_extend('force', opts, { desc = '[R]eferences' }))
+  end,
+  opts = {
+    -- your configuration comes here
+    -- or leave it empty to use the default settings
+    -- refer to the configuration section below
+  },
+}

lua/kickstart/plugins/debug.lua

@@ -23,6 +23,7 @@ return {
 
     -- Add your own debuggers here
     'leoluz/nvim-dap-go',
+    'mfussenegger/nvim-dap-python',
   },
   config = function()
     local dap = require 'dap'
@@ -42,16 +43,19 @@ return {
       ensure_installed = {
         -- Update this to ensure that you have the debuggers for the langs you want
         'delve',
+        'debugpy',
       },
     }
 
     -- Basic debugging keymaps, feel free to change to your liking!
     vim.keymap.set('n', '<F5>', dap.continue, { desc = 'Debug: Start/Continue' })
+    vim.keymap.set('n', '<leader>P', dap.continue, { desc = 'Debug: Start/Continue' })
     vim.keymap.set('n', '<F1>', dap.step_into, { desc = 'Debug: Step Into' })
     vim.keymap.set('n', '<F2>', dap.step_over, { desc = 'Debug: Step Over' })
     vim.keymap.set('n', '<F3>', dap.step_out, { desc = 'Debug: Step Out' })
-    vim.keymap.set('n', '<leader>b', dap.toggle_breakpoint, { desc = 'Debug: Toggle Breakpoint' })
-    vim.keymap.set('n', '<leader>B', function()
+    vim.keymap.set('n', '<C-F5>', dap.stop, { desc = 'Debug: Stop' })
+    vim.keymap.set('n', '<C-b>', dap.toggle_breakpoint, { desc = 'Debug: Toggle Breakpoint' })
+    vim.keymap.set('n', '<C-S-b>', function()
       dap.set_breakpoint(vim.fn.input 'Breakpoint condition: ')
     end, { desc = 'Debug: Set Breakpoint' })
 
@@ -86,5 +90,6 @@ return {
 
     -- Install golang specific config
     require('dap-go').setup()
+    require('dap-python').setup()
   end,
 }

lua/kickstart/plugins/gitsigns.lua

@@ -41,15 +41,15 @@ return {
           gitsigns.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }
         end, { desc = 'reset git hunk' })
         -- normal mode
-        map('n', '<leader>hs', gitsigns.stage_hunk, { desc = 'git [s]tage hunk' })
-        map('n', '<leader>hr', gitsigns.reset_hunk, { desc = 'git [r]eset hunk' })
-        map('n', '<leader>hS', gitsigns.stage_buffer, { desc = 'git [S]tage buffer' })
-        map('n', '<leader>hu', gitsigns.undo_stage_hunk, { desc = 'git [u]ndo stage hunk' })
-        map('n', '<leader>hR', gitsigns.reset_buffer, { desc = 'git [R]eset buffer' })
-        map('n', '<leader>hp', gitsigns.preview_hunk, { desc = 'git [p]review hunk' })
-        map('n', '<leader>hb', gitsigns.blame_line, { desc = 'git [b]lame line' })
-        map('n', '<leader>hd', gitsigns.diffthis, { desc = 'git [d]iff against index' })
-        map('n', '<leader>hD', function()
+        map('n', '<leader>Hs', gitsigns.stage_hunk, { desc = 'git [s]tage hunk' })
+        map('n', '<leader>Hr', gitsigns.reset_hunk, { desc = 'git [r]eset hunk' })
+        map('n', '<leader>HS', gitsigns.stage_buffer, { desc = 'git [S]tage buffer' })
+        map('n', '<leader>Hu', gitsigns.undo_stage_hunk, { desc = 'git [u]ndo stage hunk' })
+        map('n', '<leader>HR', gitsigns.reset_buffer, { desc = 'git [R]eset buffer' })
+        map('n', '<leader>Hp', gitsigns.preview_hunk, { desc = 'git [p]review hunk' })
+        map('n', '<leader>Hb', gitsigns.blame_line, { desc = 'git [b]lame line' })
+        map('n', '<leader>Hd', gitsigns.diffthis, { desc = 'git [d]iff against index' })
+        map('n', '<leader>HD', function()
           gitsigns.diffthis '@'
         end, { desc = 'git [D]iff against last commit' })
         -- Toggles

lua/kickstart/plugins/lint.lua

@@ -7,6 +7,15 @@ return {
       local lint = require 'lint'
       lint.linters_by_ft = {
         markdown = { 'markdownlint' },
+        python = { 'mypy', 'ruff' },
+        yaml = { 'yamllint' },
+        cmake = { 'cmakelint' },
+        cpp = { 'cppcheck' },
+        c = { 'cppcheck' },
+        json = { 'jsonlint' },
+        javascript = { 'eslint' },
+        css = { 'stylelint' },
+        html = { 'tidy' },
       }
 
       -- To allow other plugins to add linters to require('lint').linters_by_ft,

lua/kickstart/plugins/neo-tree.lua

@@ -11,16 +11,13 @@ return {
   },
   cmd = 'Neotree',
   keys = {
-    { '<C-n>', ':Neotree toggle<CR>', { desc = 'NeoTree toggle' } },
+    { '<C-e>', ':Neotree toggle<CR>', { desc = 'NeoTree toggle' } },
     { '<leader>e', ':Neotree reveal<CR>', mode = '', desc = '[E]xplore files' },
   },
   opts = {
     filesystem = {
       window = {
-        mappings = {
-          ['<C-n>'] = 'toggle',
-          ['<leader>e'] = 'close_window',
-        },
+        mappings = {},
       },
     },
   },