Initial commit

nvim/plugin/autocommands.lua

@@ -0,0 +1,154 @@
+if vim.g.did_load_autocommands_plugin then
+  return
+end
+vim.g.did_load_autocommands_plugin = true
+
+local api = vim.api
+
+local tempdirgroup = api.nvim_create_augroup('tempdir', { clear = true })
+-- Do not set undofile for files in /tmp
+api.nvim_create_autocmd('BufWritePre', {
+  pattern = '/tmp/*',
+  group = tempdirgroup,
+  callback = function()
+    vim.cmd.setlocal('noundofile')
+  end,
+})
+
+-- Disable spell checking in terminal buffers
+local nospell_group = api.nvim_create_augroup('nospell', { clear = true })
+api.nvim_create_autocmd('TermOpen', {
+  group = nospell_group,
+  callback = function()
+    vim.wo[0].spell = false
+  end,
+})
+
+-- LSP
+local keymap = vim.keymap
+
+local function preview_location_callback(_, result)
+  if result == nil or vim.tbl_isempty(result) then
+    return nil
+  end
+  local buf, _ = vim.lsp.util.preview_location(result[1])
+  if buf then
+    local cur_buf = vim.api.nvim_get_current_buf()
+    vim.bo[buf].filetype = vim.bo[cur_buf].filetype
+  end
+end
+
+local function peek_definition()
+  local params = vim.lsp.util.make_position_params()
+  return vim.lsp.buf_request(0, 'textDocument/definition', params, preview_location_callback)
+end
+
+local function peek_type_definition()
+  local params = vim.lsp.util.make_position_params()
+  return vim.lsp.buf_request(0, 'textDocument/typeDefinition', params, preview_location_callback)
+end
+
+--- Don't create a comment string when hitting <Enter> on a comment line
+vim.api.nvim_create_autocmd('BufEnter', {
+  group = vim.api.nvim_create_augroup('DisableNewLineAutoCommentString', {}),
+  callback = function()
+    vim.opt.formatoptions = vim.opt.formatoptions - { 'c', 'r', 'o' }
+  end,
+})
+
+vim.api.nvim_create_autocmd('LspAttach', {
+  group = vim.api.nvim_create_augroup('UserLspConfig', {}),
+  callback = function(ev)
+    local bufnr = ev.buf
+    local client = vim.lsp.get_client_by_id(ev.data.client_id)
+
+    -- Attach plugins
+    require('nvim-navic').attach(client, bufnr)
+
+    vim.cmd.setlocal('signcolumn=yes')
+    vim.bo[bufnr].bufhidden = 'hide'
+
+    -- Enable completion triggered by <c-x><c-o>
+    vim.bo[bufnr].omnifunc = 'v:lua.vim.lsp.omnifunc'
+    local function desc(description)
+      return { noremap = true, silent = true, buffer = bufnr, desc = description }
+    end
+    keymap.set('n', 'gD', vim.lsp.buf.declaration, desc('lsp [g]o to [D]eclaration'))
+    keymap.set('n', 'gd', vim.lsp.buf.definition, desc('lsp [g]o to [d]efinition'))
+    keymap.set('n', '<space>gt', vim.lsp.buf.type_definition, desc('lsp [g]o to [t]ype definition'))
+    keymap.set('n', 'K', vim.lsp.buf.hover, desc('[lsp] hover'))
+    keymap.set('n', '<space>pd', peek_definition, desc('lsp [p]eek [d]efinition'))
+    keymap.set('n', '<space>pt', peek_type_definition, desc('lsp [p]eek [t]ype definition'))
+    keymap.set('n', 'gi', vim.lsp.buf.implementation, desc('lsp [g]o to [i]mplementation'))
+    keymap.set('n', '<C-k>', vim.lsp.buf.signature_help, desc('[lsp] signature help'))
+    keymap.set('n', '<space>wa', vim.lsp.buf.add_workspace_folder, desc('lsp add [w]orksp[a]ce folder'))
+    keymap.set('n', '<space>wr', vim.lsp.buf.remove_workspace_folder, desc('lsp [w]orkspace folder [r]emove'))
+    keymap.set('n', '<space>wl', function()
+      vim.print(vim.lsp.buf.list_workspace_folders())
+    end, desc('[lsp] [w]orkspace folders [l]ist'))
+    keymap.set('n', '<space>rn', vim.lsp.buf.rename, desc('lsp [r]e[n]ame'))
+    keymap.set('n', '<space>wq', vim.lsp.buf.workspace_symbol, desc('lsp [w]orkspace symbol [q]'))
+    keymap.set('n', '<space>dd', vim.lsp.buf.document_symbol, desc('lsp [dd]ocument symbol'))
+    keymap.set('n', '<M-CR>', vim.lsp.buf.code_action, desc('[lsp] code action'))
+    keymap.set('n', '<M-l>', vim.lsp.codelens.run, desc('[lsp] run code lens'))
+    keymap.set('n', '<space>cr', vim.lsp.codelens.refresh, desc('lsp [c]ode lenses [r]efresh'))
+    keymap.set('n', 'gr', vim.lsp.buf.references, desc('lsp [g]et [r]eferences'))
+    keymap.set('n', '<space>f', function()
+      vim.lsp.buf.format { async = true }
+    end, desc('[lsp] [f]ormat buffer'))
+    if client.server_capabilities.inlayHintProvider then
+      keymap.set('n', '<space>h', function()
+        local current_setting = vim.lsp.inlay_hint.is_enabled(bufnr)
+        vim.lsp.inlay_hint.enable(bufnr, not current_setting)
+      end, desc('[lsp] toggle inlay hints'))
+    end
+
+    -- Auto-refresh code lenses
+    if not client then
+      return
+    end
+    local function buf_refresh_codeLens()
+      vim.schedule(function()
+        if client.server_capabilities.codeLensProvider then
+          vim.lsp.codelens.refresh()
+          return
+        end
+      end)
+    end
+    local group = api.nvim_create_augroup(string.format('lsp-%s-%s', bufnr, client.id), {})
+    if client.server_capabilities.codeLensProvider then
+      vim.api.nvim_create_autocmd({ 'InsertLeave', 'BufWritePost', 'TextChanged' }, {
+        group = group,
+        callback = buf_refresh_codeLens,
+        buffer = bufnr,
+      })
+      buf_refresh_codeLens()
+    end
+  end,
+})
+
+-- More examples, disabled by default
+
+-- Toggle between relative/absolute line numbers
+-- Show relative line numbers in the current buffer,
+-- absolute line numbers in inactive buffers
+-- local numbertoggle = api.nvim_create_augroup('numbertoggle', { clear = true })
+-- api.nvim_create_autocmd({ 'BufEnter', 'FocusGained', 'InsertLeave', 'CmdlineLeave', 'WinEnter' }, {
+--   pattern = '*',
+--   group = numbertoggle,
+--   callback = function()
+--     if vim.o.nu and vim.api.nvim_get_mode().mode ~= 'i' then
+--       vim.opt.relativenumber = true
+--     end
+--   end,
+-- })
+-- api.nvim_create_autocmd({ 'BufLeave', 'FocusLost', 'InsertEnter', 'CmdlineEnter', 'WinLeave' }, {
+--   pattern = '*',
+--   group = numbertoggle,
+--   callback = function()
+--     if vim.o.nu then
+--       vim.opt.relativenumber = false
+--       vim.cmd.redraw()
+--     end
+--   end,
+-- })

nvim/plugin/commands.lua

@@ -0,0 +1,9 @@
+if vim.g.did_load_commands_plugin then
+  return
+end
+vim.g.did_load_commands_plugin = true
+
+local api = vim.api
+
+-- delete current buffer
+api.nvim_create_user_command('Q', 'bd % <CR>', {})

nvim/plugin/completion.lua

@@ -0,0 +1,163 @@
+if vim.g.did_load_completion_plugin then
+  return
+end
+vim.g.did_load_completion_plugin = true
+
+local cmp = require('cmp')
+local lspkind = require('lspkind')
+local luasnip = require('luasnip')
+
+vim.opt.completeopt = { 'menu', 'menuone', 'noselect' }
+
+local function has_words_before()
+  local unpack_ = unpack or table.unpack
+  local line, col = unpack_(vim.api.nvim_win_get_cursor(0))
+  return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match('%s') == nil
+end
+
+---@param source string|table
+local function complete_with_source(source)
+  if type(source) == 'string' then
+    cmp.complete { config = { sources = { { name = source } } } }
+  elseif type(source) == 'table' then
+    cmp.complete { config = { sources = { source } } }
+  end
+end
+
+cmp.setup {
+  completion = {
+    completeopt = 'menu,menuone,noinsert',
+    -- autocomplete = false,
+  },
+  formatting = {
+    format = lspkind.cmp_format {
+      mode = 'symbol_text',
+      with_text = true,
+      maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters)
+      ellipsis_char = '...', -- when popup menu exceed maxwidth, the truncated part would show ellipsis_char instead (must define maxwidth first)
+
+      menu = {
+        buffer = '[BUF]',
+        nvim_lsp = '[LSP]',
+        nvim_lsp_signature_help = '[LSP]',
+        nvim_lsp_document_symbol = '[LSP]',
+        nvim_lua = '[API]',
+        path = '[PATH]',
+        luasnip = '[SNIP]',
+      },
+    },
+  },
+  snippet = {
+    expand = function(args)
+      require('luasnip').lsp_expand(args.body) -- For `luasnip` users.
+    end,
+  },
+  mapping = {
+    ['<C-b>'] = cmp.mapping(function(_)
+      if cmp.visible() then
+        cmp.scroll_docs(-4)
+      else
+        complete_with_source('buffer')
+      end
+    end, { 'i', 'c', 's' }),
+    ['<C-f>'] = cmp.mapping(function(_)
+      if cmp.visible() then
+        cmp.scroll_docs(4)
+      else
+        complete_with_source('path')
+      end
+    end, { 'i', 'c', 's' }),
+    ['<C-n>'] = cmp.mapping(function(fallback)
+      if cmp.visible() then
+        cmp.select_next_item()
+      -- expand_or_jumpable(): Jump outside the snippet region
+      -- expand_or_locally_jumpable(): Only jump inside the snippet region
+      elseif luasnip.expand_or_locally_jumpable() then
+        luasnip.expand_or_jump()
+      elseif has_words_before() then
+        cmp.complete()
+      else
+        fallback()
+      end
+    end, { 'i', 'c', 's' }),
+    ['<C-p>'] = cmp.mapping(function(fallback)
+      if cmp.visible() then
+        cmp.select_prev_item()
+      elseif luasnip.jumpable(-1) then
+        luasnip.jump(-1)
+      else
+        fallback()
+      end
+    end, { 'i', 'c', 's' }),
+    -- toggle completion
+    ['<C-e>'] = cmp.mapping(function(_)
+      if cmp.visible() then
+        cmp.close()
+      else
+        cmp.complete()
+      end
+    end, { 'i', 'c', 's' }),
+    ['<C-y>'] = cmp.mapping.confirm {
+      select = true,
+    },
+  },
+  sources = cmp.config.sources {
+    -- The insertion order influences the priority of the sources
+    { name = 'nvim_lsp', keyword_length = 3 },
+    { name = 'nvim_lsp_signature_help', keyword_length = 3 },
+    { name = 'buffer' },
+    { name = 'path' },
+  },
+  enabled = function()
+    return vim.bo[0].buftype ~= 'prompt'
+  end,
+  experimental = {
+    native_menu = false,
+    ghost_text = true,
+  },
+}
+
+cmp.setup.filetype('lua', {
+  sources = cmp.config.sources {
+    { name = 'nvim_lua' },
+    { name = 'nvim_lsp', keyword_length = 3 },
+    { name = 'path' },
+  },
+})
+
+-- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore).
+cmp.setup.cmdline({ '/', '?' }, {
+  mapping = cmp.mapping.preset.cmdline(),
+  sources = {
+    { name = 'nvim_lsp_document_symbol', keyword_length = 3 },
+    { name = 'buffer' },
+    { name = 'cmdline_history' },
+  },
+  view = {
+    entries = { name = 'wildmenu', separator = '|' },
+  },
+})
+
+-- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore).
+cmp.setup.cmdline(':', {
+  mapping = cmp.mapping.preset.cmdline(),
+  sources = cmp.config.sources {
+    { name = 'cmdline' },
+    { name = 'cmdline_history' },
+    { name = 'path' },
+  },
+})
+
+vim.keymap.set({ 'i', 'c', 's' }, '<C-n>', cmp.complete, { noremap = false, desc = '[cmp] complete' })
+vim.keymap.set({ 'i', 'c', 's' }, '<C-f>', function()
+  complete_with_source('path')
+end, { noremap = false, desc = '[cmp] path' })
+vim.keymap.set({ 'i', 'c', 's' }, '<C-o>', function()
+  complete_with_source('nvim_lsp')
+end, { noremap = false, desc = '[cmp] lsp' })
+vim.keymap.set({ 'c' }, '<C-h>', function()
+  complete_with_source('cmdline_history')
+end, { noremap = false, desc = '[cmp] cmdline history' })
+vim.keymap.set({ 'c' }, '<C-c>', function()
+  complete_with_source('cmdline')
+end, { noremap = false, desc = '[cmp] cmdline' })

nvim/plugin/diffview.lua

@@ -0,0 +1,11 @@
+if vim.g.did_load_diffview_plugin then
+  return
+end
+vim.g.did_load_diffview_plugin = true
+
+vim.keymap.set('n', '<leader>gfb', function()
+  vim.cmd.DiffviewFileHistory(vim.api.nvim_buf_get_name(0))
+end, { desc = 'diffview [g]it [f]ile history (current [b]uffer)' })
+vim.keymap.set('n', '<leader>gfc', vim.cmd.DiffviewFileHistory, { desc = 'diffview [g]it [f]ile history ([c]wd)' })
+vim.keymap.set('n', '<leader>gd', vim.cmd.DiffviewOpen, { desc = '[g]it [d]iffview open' })
+vim.keymap.set('n', '<leader>gft', vim.cmd.DiffviewToggleFiles, { desc = '[g]it [d]iffview [f]iles [t]oggle' })

nvim/plugin/eyeliner.lua

@@ -0,0 +1,10 @@
+if vim.g.did_load_eyeliner_plugin then
+  return
+end
+vim.g.did_load_eyeliner_plugin = true
+
+-- Highlights unique characters for f/F and t/T motions
+require('eyeliner').setup {
+  highlight_on_key = true, -- show highlights only after key press
+  dim = true, -- dim all other characters
+}

nvim/plugin/gitsigns.lua

@@ -0,0 +1,66 @@
+if vim.g.did_load_gitsigns_plugin then
+  return
+end
+vim.g.did_load_gitsigns_plugin = true
+
+vim.schedule(function()
+  require('gitsigns').setup {
+    current_line_blame = false,
+    current_line_blame_opts = {
+      ignore_whitespace = true,
+    },
+    on_attach = function(bufnr)
+      local gs = package.loaded.gitsigns
+
+      local function map(mode, l, r, opts)
+        opts = opts or {}
+        opts.buffer = bufnr
+        vim.keymap.set(mode, l, r, opts)
+      end
+
+      -- Navigation
+      map('n', ']g', function()
+        if vim.wo.diff then
+          return ']g'
+        end
+        vim.schedule(function()
+          gs.next_hunk()
+        end)
+        return '<Ignore>'
+      end, { expr = true, desc = '[g]it next hunk' })
+
+      map('n', '[g', function()
+        if vim.wo.diff then
+          return '[g'
+        end
+        vim.schedule(function()
+          gs.prev_hunk()
+        end)
+        return '<Ignore>'
+      end, { expr = true, desc = '[g]it previous hunk' })
+
+      -- Actions
+      map({ 'n', 'v' }, '<leader>hs', function()
+        vim.cmd.Gitsigns('stage_hunk')
+      end, { desc = 'git [h]unk [s]tage' })
+      map({ 'n', 'v' }, '<leader>hr', function()
+        vim.cmd.Gitsigns('reset_hunk')
+      end, { desc = 'git [h]unk [r]eset' })
+      map('n', '<leader>hS', gs.stage_buffer, { desc = 'git stage buffer' })
+      map('n', '<leader>hu', gs.undo_stage_hunk, { desc = 'git [h]unk [u]ndo stage' })
+      map('n', '<leader>hR', gs.reset_buffer, { desc = 'git [h] buffer [R]eset' })
+      map('n', '<leader>hp', gs.preview_hunk, { desc = 'git [h]unk [p]review' })
+      map('n', '<leader>hb', function()
+        gs.blame_line { full = true }
+      end, { desc = 'git [h] [b]lame line (full)' })
+      map('n', '<leader>glb', gs.toggle_current_line_blame, { desc = '[g]it toggle current [l]ine [b]lame' })
+      map('n', '<leader>hd', gs.diffthis, { desc = 'git [h] [d]iff this' })
+      map('n', '<leader>hD', function()
+        gs.diffthis('~')
+      end, { desc = 'git [h] [D]iff ~' })
+      map('n', '<leader>td', gs.toggle_deleted, { desc = 'git [t]oggle [d]eleted' })
+      -- Text object
+      map({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>', { desc = 'git stage buffer' })
+    end,
+  }
+end)

nvim/plugin/keymaps.lua

@@ -0,0 +1,200 @@
+if vim.g.did_load_keymaps_plugin then
+  return
+end
+vim.g.did_load_keymaps_plugin = true
+
+local api = vim.api
+local fn = vim.fn
+local keymap = vim.keymap
+local diagnostic = vim.diagnostic
+
+-- Yank from current position till end of current line
+keymap.set('n', 'Y', 'y$', { silent = true, desc = '[Y]ank to end of line' })
+
+-- Buffer list navigation
+keymap.set('n', '[b', vim.cmd.bprevious, { silent = true, desc = 'previous [b]uffer' })
+keymap.set('n', ']b', vim.cmd.bnext, { silent = true, desc = 'next [b]uffer' })
+keymap.set('n', '[B', vim.cmd.bfirst, { silent = true, desc = 'first [B]uffer' })
+keymap.set('n', ']B', vim.cmd.blast, { silent = true, desc = 'last [B]uffer' })
+
+-- Toggle the quickfix list (only opens if it is populated)
+local function toggle_qf_list()
+  local qf_exists = false
+  for _, win in pairs(fn.getwininfo() or {}) do
+    if win['quickfix'] == 1 then
+      qf_exists = true
+    end
+  end
+  if qf_exists == true then
+    vim.cmd.cclose()
+    return
+  end
+  if not vim.tbl_isempty(vim.fn.getqflist()) then
+    vim.cmd.copen()
+  end
+end
+
+keymap.set('n', '<C-c>', toggle_qf_list, { desc = 'toggle quickfix list' })
+
+local function try_fallback_notify(opts)
+  local success, _ = pcall(opts.try)
+  if success then
+    return
+  end
+  success, _ = pcall(opts.fallback)
+  if success then
+    return
+  end
+  vim.notify(opts.notify, vim.log.levels.INFO)
+end
+
+-- Cycle the quickfix and location lists
+local function cleft()
+  try_fallback_notify {
+    try = vim.cmd.cprev,
+    fallback = vim.cmd.clast,
+    notify = 'Quickfix list is empty!',
+  }
+end
+
+local function cright()
+  try_fallback_notify {
+    try = vim.cmd.cnext,
+    fallback = vim.cmd.cfirst,
+    notify = 'Quickfix list is empty!',
+  }
+end
+
+keymap.set('n', '[c', cleft, { silent = true, desc = '[c]ycle quickfix left' })
+keymap.set('n', ']c', cright, { silent = true, desc = '[c]ycle quickfix right' })
+keymap.set('n', '[C', vim.cmd.cfirst, { silent = true, desc = 'first quickfix entry' })
+keymap.set('n', ']C', vim.cmd.clast, { silent = true, desc = 'last quickfix entry' })
+
+local function lleft()
+  try_fallback_notify {
+    try = vim.cmd.lprev,
+    fallback = vim.cmd.llast,
+    notify = 'Location list is empty!',
+  }
+end
+
+local function lright()
+  try_fallback_notify {
+    try = vim.cmd.lnext,
+    fallback = vim.cmd.lfirst,
+    notify = 'Location list is empty!',
+  }
+end
+
+keymap.set('n', '[l', lleft, { silent = true, desc = 'cycle [l]oclist left' })
+keymap.set('n', ']l', lright, { silent = true, desc = 'cycle [l]oclist right' })
+keymap.set('n', '[L', vim.cmd.lfirst, { silent = true, desc = 'first [L]oclist entry' })
+keymap.set('n', ']L', vim.cmd.llast, { silent = true, desc = 'last [L]oclist entry' })
+
+-- Resize vertical splits
+local toIntegral = math.ceil
+keymap.set('n', '<leader>w+', function()
+  local curWinWidth = api.nvim_win_get_width(0)
+  api.nvim_win_set_width(0, toIntegral(curWinWidth * 3 / 2))
+end, { silent = true, desc = 'inc window [w]idth' })
+keymap.set('n', '<leader>w-', function()
+  local curWinWidth = api.nvim_win_get_width(0)
+  api.nvim_win_set_width(0, toIntegral(curWinWidth * 2 / 3))
+end, { silent = true, desc = 'dec window [w]idth' })
+keymap.set('n', '<leader>h+', function()
+  local curWinHeight = api.nvim_win_get_height(0)
+  api.nvim_win_set_height(0, toIntegral(curWinHeight * 3 / 2))
+end, { silent = true, desc = 'inc window [h]eight' })
+keymap.set('n', '<leader>h-', function()
+  local curWinHeight = api.nvim_win_get_height(0)
+  api.nvim_win_set_height(0, toIntegral(curWinHeight * 2 / 3))
+end, { silent = true, desc = 'dec window [h]eight' })
+
+-- Close floating windows [Neovim 0.10 and above]
+keymap.set('n', '<leader>fq', function()
+  vim.cmd('fclose!')
+end, { silent = true, desc = '[f]loating windows: [q]uit/close all' })
+
+-- Remap Esc to switch to normal mode and Ctrl-Esc to pass Esc to terminal
+keymap.set('t', '<Esc>', '<C-\\><C-n>', { desc = 'switch to normal mode' })
+keymap.set('t', '<C-Esc>', '<Esc>', { desc = 'send Esc to terminal' })
+
+-- Shortcut for expanding to current buffer's directory in command mode
+keymap.set('c', '%%', function()
+  if fn.getcmdtype() == ':' then
+    return fn.expand('%:h') .. '/'
+  else
+    return '%%'
+  end
+end, { expr = true, desc = "expand to current buffer's directory" })
+
+keymap.set('n', '<space>tn', vim.cmd.tabnew, { desc = '[t]ab: [n]ew' })
+keymap.set('n', '<space>tq', vim.cmd.tabclose, { desc = '[t]ab: [q]uit/close' })
+
+local severity = diagnostic.severity
+
+keymap.set('n', '<space>e', function()
+  local _, winid = diagnostic.open_float(nil, { scope = 'line' })
+  if not winid then
+    vim.notify('no diagnostics found', vim.log.levels.INFO)
+    return
+  end
+  vim.api.nvim_win_set_config(winid or 0, { focusable = true })
+end, { noremap = true, silent = true, desc = 'diagnostics floating window' })
+keymap.set('n', '[d', diagnostic.goto_prev, { noremap = true, silent = true, desc = 'previous [d]iagnostic' })
+keymap.set('n', ']d', diagnostic.goto_next, { noremap = true, silent = true, desc = 'next [d]iagnostic' })
+keymap.set('n', '[e', function()
+  diagnostic.goto_prev {
+    severity = severity.ERROR,
+  }
+end, { noremap = true, silent = true, desc = 'previous [e]rror diagnostic' })
+keymap.set('n', ']e', function()
+  diagnostic.goto_next {
+    severity = severity.ERROR,
+  }
+end, { noremap = true, silent = true, desc = 'next [e]rror diagnostic' })
+keymap.set('n', '[w', function()
+  diagnostic.goto_prev {
+    severity = severity.WARN,
+  }
+end, { noremap = true, silent = true, desc = 'previous [w]arning diagnostic' })
+keymap.set('n', ']w', function()
+  diagnostic.goto_next {
+    severity = severity.WARN,
+  }
+end, { noremap = true, silent = true, desc = 'next [w]arning diagnostic' })
+keymap.set('n', '[h', function()
+  diagnostic.goto_prev {
+    severity = severity.HINT,
+  }
+end, { noremap = true, silent = true, desc = 'previous [h]int diagnostic' })
+keymap.set('n', ']h', function()
+  diagnostic.goto_next {
+    severity = severity.HINT,
+  }
+end, { noremap = true, silent = true, desc = 'next [h]int diagnostic' })
+
+local function toggle_spell_check()
+  ---@diagnostic disable-next-line: param-type-mismatch
+  vim.opt.spell = not (vim.opt.spell:get())
+end
+
+keymap.set('n', '<leader>S', toggle_spell_check, { noremap = true, silent = true, desc = 'toggle [S]pell' })
+
+keymap.set('n', '<C-d>', '<C-d>zz', { desc = 'move [d]own half-page and center' })
+keymap.set('n', '<C-u>', '<C-u>zz', { desc = 'move [u]p half-page and center' })
+keymap.set('n', '<C-f>', '<C-f>zz', { desc = 'move DOWN [f]ull-page and center' })
+keymap.set('n', '<C-b>', '<C-b>zz', { desc = 'move UP full-page and center' })
+
+--- Disabled keymaps [enable at your own risk]
+
+-- Automatic management of search highlight
+-- XXX: This is not so nice if you use j/k for navigation
+-- (you should be using <C-d>/<C-u> and relative line numbers instead ;)
+--
+-- local auto_hlsearch_namespace = vim.api.nvim_create_namespace('auto_hlsearch')
+-- vim.on_key(function(char)
+--   if vim.fn.mode() == 'n' then
+--     vim.opt.hlsearch = vim.tbl_contains({ '<CR>', 'n', 'N', '*', '#', '?', '/' }, vim.fn.keytrans(char))
+--   end
+-- end, auto_hlsearch_namespace)

nvim/plugin/lualine.lua

@@ -0,0 +1,87 @@
+if vim.g.did_load_lualine_plugin then
+  return
+end
+vim.g.did_load_lualine_plugin = true
+
+local navic = require('nvim-navic')
+navic.setup {}
+
+---Indicators for special modes,
+---@return string status
+local function extra_mode_status()
+  -- recording macros
+  local reg_recording = vim.fn.reg_recording()
+  if reg_recording ~= '' then
+    return ' @' .. reg_recording
+  end
+  -- executing macros
+  local reg_executing = vim.fn.reg_executing()
+  if reg_executing ~= '' then
+    return ' @' .. reg_executing
+  end
+  -- ix mode (<C-x> in insert mode to trigger different builtin completion sources)
+  local mode = vim.api.nvim_get_mode().mode
+  if mode == 'ix' then
+    return '^X: (^]^D^E^F^I^K^L^N^O^Ps^U^V^Y)'
+  end
+  return ''
+end
+
+require('lualine').setup {
+  globalstatus = true,
+  sections = {
+    lualine_c = {
+      -- nvim-navic
+      { navic.get_location, cond = navic.is_available },
+    },
+    lualine_z = {
+      -- (see above)
+      { extra_mode_status },
+    },
+  },
+  options = {
+    theme = 'auto',
+  },
+  -- Example top tabline configuration (this may clash with other plugins)
+  -- tabline = {
+  --   lualine_a = {
+  --     {
+  --       'tabs',
+  --       mode = 1,
+  --     },
+  --   },
+  --   lualine_b = {
+  --     {
+  --       'buffers',
+  --       show_filename_only = true,
+  --       show_bufnr = true,
+  --       mode = 4,
+  --       filetype_names = {
+  --         TelescopePrompt = 'Telescope',
+  --         dashboard = 'Dashboard',
+  --         fzf = 'FZF',
+  --       },
+  --       buffers_color = {
+  --         -- Same values as the general color option can be used here.
+  --         active = 'lualine_b_normal', -- Color for active buffer.
+  --         inactive = 'lualine_b_inactive', -- Color for inactive buffer.
+  --       },
+  --     },
+  --   },
+  --   lualine_c = {},
+  --   lualine_x = {},
+  --   lualine_y = {},
+  --   lualine_z = {},
+  -- },
+  winbar = {
+    lualine_z = {
+      {
+        'filename',
+        path = 1,
+        file_status = true,
+        newfile_status = true,
+      },
+    },
+  },
+  extensions = { 'fugitive', 'fzf', 'toggleterm', 'quickfix' },
+}

nvim/plugin/neogit.lua

@@ -0,0 +1,29 @@
+if vim.g.did_load_neogit_plugin then
+  return
+end
+vim.g.did_load_neogit_plugin = true
+
+local neogit = require('neogit')
+
+neogit.setup {
+  disable_builtin_notifications = true,
+  disable_insert_on_commit = 'auto',
+  integrations = {
+    diffview = true,
+    telescope = true,
+    fzf_lua = true,
+  },
+  sections = {
+    ---@diagnostic disable-next-line: missing-fields
+    recent = {
+      folded = false,
+    },
+  },
+}
+vim.keymap.set('n', '<leader>go', neogit.open, { noremap = true, silent = true, desc = 'neo[g]it [o]pen' })
+vim.keymap.set('n', '<leader>gs', function()
+  neogit.open { kind = 'auto' }
+end, { noremap = true, silent = true, desc = 'neo[g]it open [s]plit' })
+vim.keymap.set('n', '<leader>gc', function()
+  neogit.open { 'commit' }
+end, { noremap = true, silent = true, desc = 'neo[g]it [c]ommit' })

nvim/plugin/plugins.lua

@@ -0,0 +1,10 @@
+if vim.g.did_load_plugins_plugin then
+  return
+end
+vim.g.did_load_plugins_plugin = true
+
+-- many plugins annoyingly require a call to a 'setup' function to be loaded,
+-- even with default configs
+
+require('nvim-surround').setup()
+require('which-key').setup()

nvim/plugin/statuscol.lua

@@ -0,0 +1,18 @@
+if vim.g.did_load_statuscol_plugin then
+  return
+end
+vim.g.did_load_statuscol_plugin = true
+
+local builtin = require('statuscol.builtin')
+require('statuscol').setup {
+  setopt = true,
+  relculright = true,
+  segments = {
+    { text = { '%s' }, click = 'v:lua.ScSa' },
+    {
+      text = { builtin.lnumfunc, ' ' },
+      condition = { true, builtin.not_empty },
+      click = 'v:lua.ScLa',
+    },
+  },
+}

nvim/plugin/telescope.lua

@@ -0,0 +1,159 @@
+if vim.g.did_load_telescope_plugin then
+  return
+end
+vim.g.did_load_telescope_plugin = true
+
+local telescope = require('telescope')
+local actions = require('telescope.actions')
+
+local builtin = require('telescope.builtin')
+
+local layout_config = {
+  vertical = {
+    width = function(_, max_columns)
+      return math.floor(max_columns * 0.99)
+    end,
+    height = function(_, _, max_lines)
+      return math.floor(max_lines * 0.99)
+    end,
+    prompt_position = 'bottom',
+    preview_cutoff = 0,
+  },
+}
+
+-- Fall back to find_files if not in a git repo
+local project_files = function()
+  local opts = {} -- define here if you want to define something
+  local ok = pcall(builtin.git_files, opts)
+  if not ok then
+    builtin.find_files(opts)
+  end
+end
+
+---@param picker function the telescope picker to use
+local function grep_current_file_type(picker)
+  local current_file_ext = vim.fn.expand('%:e')
+  local additional_vimgrep_arguments = {}
+  if current_file_ext ~= '' then
+    additional_vimgrep_arguments = {
+      '--type',
+      current_file_ext,
+    }
+  end
+  local conf = require('telescope.config').values
+  picker {
+    vimgrep_arguments = vim.tbl_flatten {
+      conf.vimgrep_arguments,
+      additional_vimgrep_arguments,
+    },
+  }
+end
+
+--- Grep the string under the cursor, filtering for the current file type
+local function grep_string_current_file_type()
+  grep_current_file_type(builtin.grep_string)
+end
+
+--- Live grep, filtering for the current file type
+local function live_grep_current_file_type()
+  grep_current_file_type(builtin.live_grep)
+end
+
+--- Like live_grep, but fuzzy (and slower)
+local function fuzzy_grep(opts)
+  opts = vim.tbl_extend('error', opts or {}, { search = '', prompt_title = 'Fuzzy grep' })
+  builtin.grep_string(opts)
+end
+
+local function fuzzy_grep_current_file_type()
+  grep_current_file_type(fuzzy_grep)
+end
+
+vim.keymap.set('n', '<leader>tp', function()
+  builtin.find_files()
+end, { desc = '[t]elescope find files - ctrl[p] style' })
+vim.keymap.set('n', '<M-p>', builtin.oldfiles, { desc = '[telescope] old files' })
+vim.keymap.set('n', '<C-g>', builtin.live_grep, { desc = '[telescope] live grep' })
+vim.keymap.set('n', '<leader>tf', fuzzy_grep, { desc = '[t]elescope [f]uzzy grep' })
+vim.keymap.set('n', '<M-f>', fuzzy_grep_current_file_type, { desc = '[telescope] fuzzy grep filetype' })
+vim.keymap.set('n', '<M-g>', live_grep_current_file_type, { desc = '[telescope] live grep filetype' })
+vim.keymap.set(
+  'n',
+  '<leader>t*',
+  grep_string_current_file_type,
+  { desc = '[t]elescope grep current string [*] in current filetype' }
+)
+vim.keymap.set('n', '<leader>*', builtin.grep_string, { desc = '[telescope] grep current string [*]' })
+vim.keymap.set('n', '<leader>tg', project_files, { desc = '[t]elescope project files [g]' })
+vim.keymap.set('n', '<leader>tc', builtin.quickfix, { desc = '[t]elescope quickfix list [c]' })
+vim.keymap.set('n', '<leader>tq', builtin.command_history, { desc = '[t]elescope command history [q]' })
+vim.keymap.set('n', '<leader>tl', builtin.loclist, { desc = '[t]elescope [l]oclist' })
+vim.keymap.set('n', '<leader>tr', builtin.registers, { desc = '[t]elescope [r]egisters' })
+vim.keymap.set('n', '<leader>tbb', builtin.buffers, { desc = '[t]elescope [b]uffers [b]' })
+vim.keymap.set(
+  'n',
+  '<leader>tbf',
+  builtin.current_buffer_fuzzy_find,
+  { desc = '[t]elescope current [b]uffer [f]uzzy find' }
+)
+vim.keymap.set('n', '<leader>td', builtin.lsp_document_symbols, { desc = '[t]elescope lsp [d]ocument symbols' })
+vim.keymap.set(
+  'n',
+  '<leader>to',
+  builtin.lsp_dynamic_workspace_symbols,
+  { desc = '[t]elescope lsp dynamic w[o]rkspace symbols' }
+)
+
+telescope.setup {
+  defaults = {
+    path_display = {
+      'truncate',
+    },
+    layout_strategy = 'vertical',
+    layout_config = layout_config,
+    mappings = {
+      i = {
+        ['<C-q>'] = actions.send_to_qflist,
+        ['<C-l>'] = actions.send_to_loclist,
+        -- ['<esc>'] = actions.close,
+        ['<C-s>'] = actions.cycle_previewers_next,
+        ['<C-a>'] = actions.cycle_previewers_prev,
+      },
+      n = {
+        q = actions.close,
+      },
+    },
+    preview = {
+      treesitter = true,
+    },
+    history = {
+      path = vim.fn.stdpath('data') .. '/telescope_history.sqlite3',
+      limit = 1000,
+    },
+    color_devicons = true,
+    set_env = { ['COLORTERM'] = 'truecolor' },
+    prompt_prefix = '   ',
+    selection_caret = '  ',
+    entry_prefix = '  ',
+    initial_mode = 'insert',
+    vimgrep_arguments = {
+      'rg',
+      '-L',
+      '--color=never',
+      '--no-heading',
+      '--with-filename',
+      '--line-number',
+      '--column',
+      '--smart-case',
+    },
+  },
+  extensions = {
+    fzy_native = {
+      override_generic_sorter = false,
+      override_file_sorter = true,
+    },
+  },
+}
+
+telescope.load_extension('fzy_native')
+-- telescope.load_extension('smart_history')

nvim/plugin/treesitter.lua

@@ -0,0 +1,97 @@
+if vim.g.did_load_treesitter_plugin then
+  return
+end
+vim.g.did_load_treesitter_plugin = true
+
+local configs = require('nvim-treesitter.configs')
+vim.g.skip_ts_context_comment_string_module = true
+
+---@diagnostic disable-next-line: missing-fields
+configs.setup {
+  -- ensure_installed = 'all',
+  -- auto_install = false, -- Do not automatically install missing parsers when entering buffer
+  highlight = {
+    enable = true,
+    disable = function(_, buf)
+      local max_filesize = 100 * 1024 -- 100 KiB
+      local ok, stats = pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf))
+      if ok and stats and stats.size > max_filesize then
+        return true
+      end
+    end,
+  },
+  textobjects = {
+    select = {
+      enable = true,
+      -- Automatically jump forward to textobject, similar to targets.vim
+      lookahead = true,
+      keymaps = {
+        ['af'] = '@function.outer',
+        ['if'] = '@function.inner',
+        ['ac'] = '@class.outer',
+        ['ic'] = '@class.inner',
+        ['aC'] = '@call.outer',
+        ['iC'] = '@call.inner',
+        ['a#'] = '@comment.outer',
+        ['i#'] = '@comment.outer',
+        ['ai'] = '@conditional.outer',
+        ['ii'] = '@conditional.outer',
+        ['al'] = '@loop.outer',
+        ['il'] = '@loop.inner',
+        ['aP'] = '@parameter.outer',
+        ['iP'] = '@parameter.inner',
+      },
+      selection_modes = {
+        ['@parameter.outer'] = 'v', -- charwise
+        ['@function.outer'] = 'V', -- linewise
+        ['@class.outer'] = '<c-v>', -- blockwise
+      },
+    },
+    swap = {
+      enable = true,
+      swap_next = {
+        ['<leader>a'] = '@parameter.inner',
+      },
+      swap_previous = {
+        ['<leader>A'] = '@parameter.inner',
+      },
+    },
+    move = {
+      enable = true,
+      set_jumps = true, -- whether to set jumps in the jumplist
+      goto_next_start = {
+        [']m'] = '@function.outer',
+        [']P'] = '@parameter.outer',
+      },
+      goto_next_end = {
+        [']m'] = '@function.outer',
+        [']P'] = '@parameter.outer',
+      },
+      goto_previous_start = {
+        ['[m'] = '@function.outer',
+        ['[P'] = '@parameter.outer',
+      },
+      goto_previous_end = {
+        ['[m'] = '@function.outer',
+        ['[P'] = '@parameter.outer',
+      },
+    },
+    nsp_interop = {
+      enable = true,
+      peek_definition_code = {
+        ['df'] = '@function.outer',
+        ['dF'] = '@class.outer',
+      },
+    },
+  },
+}
+
+require('treesitter-context').setup {
+  max_lines = 3,
+}
+
+require('ts_context_commentstring').setup()
+
+-- Tree-sitter based folding
+-- vim.opt.foldmethod = 'expr'
+vim.opt.foldexpr = 'nvim_treesitter#foldexpr()'