init.lua

--[[

=====================================================================
==================== READ THIS BEFORE CONTINUING ====================
=====================================================================
========                                    .-----.          ========
========         .----------------------.   | === |          ========
========         |.-""""""""""""""""""-.|   |-----|          ========
========         ||                    ||   | === |          ========
========         ||   KICKSTART.NVIM   ||   |-----|          ========
========         ||                    ||   | === |          ========
========         ||                    ||   |-----|          ========
========         ||:Tutor              ||   |:::::|          ========
========         |'-..................-'|   |____o|          ========
========         `"")----------------(""`   ___________      ========
========        /::::::::::|  |::::::::::\  \ no mouse \     ========
========       /:::========|  |==hjkl==:::\  \ required \    ========
========      '""""""""""""'  '""""""""""""'  '""""""""""'   ========
========                                                     ========
=====================================================================
=====================================================================

What is Kickstart?

  Kickstart.nvim is *not* a distribution.

  Kickstart.nvim is a starting point for your own configuration.
    The goal is that you can read every line of code, top-to-bottom, understand
    what your configuration is doing, and modify it to suit your needs.

    Once you've done that, you can start exploring, configuring and tinkering to
    make Neovim your own! That might mean leaving Kickstart just the way it is for a while
    or immediately breaking it into modular pieces. It's up to you!

    If you don't know anything about Lua, I recommend taking some time to read through
    a guide. One possible example which will only take 10-15 minutes:
      - https://learnxinyminutes.com/docs/lua/

    After understanding a bit more about Lua, you can use `:help lua-guide` as a
    reference for how Neovim integrates Lua.
    - :help lua-guide
    - (or HTML version): https://neovim.io/doc/user/lua-guide.html

Kickstart Guide:

  TODO: The very first thing you should do is to run the command `:Tutor` in Neovim.

    If you don't know what this means, type the following:
      - <escape key>
      - :
      - Tutor
      - <enter key>

    (If you already know the Neovim basics, you can skip this step.)

  Once you've completed that, you can continue working through **AND READING** the rest
  of the kickstart init.lua.

  Next, run AND READ `:help`.
    This will open up a help window with some basic information
    about reading, navigating and searching the builtin help documentation.

    This should be the first place you go to look when you're stuck or confused
    with something. It's one of my favorite Neovim features.

    MOST IMPORTANTLY, we provide a keymap "<space>sh" to [s]earch the [h]elp documentation,
    which is very useful when you're not exactly sure of what you're looking for.

  I have left several `:help X` comments throughout the init.lua
    These are hints about where to find more information about the relevant settings,
    plugins or Neovim features used in Kickstart.

   NOTE: Look for lines like this

    Throughout the file. These are for you, the reader, to help you understand what is happening.
    Feel free to delete them once you know what you're doing, but they should serve as a guide
    for when you are first encountering a few different constructs in your Neovim config.

If you experience any errors while trying to install kickstart, run `:checkhealth` for more info.

I hope you enjoy your Neovim journey,
- TJ

P.S. You can delete this when you're done too. It's your config now! :)
--]]

-- ============================================================
-- SECTION 1: OPTIONS
-- Core Neovim settings, leaders, options
-- ============================================================
do
  -- Enable faster startup by caching compiled Lua modules
  -- See `:help vim.loader`
  vim.loader.enable()

  -- Set <space> as the leader key
  -- See `:help mapleader`
  --  NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used)
  vim.g.mapleader = ' '
  vim.g.maplocalleader = ' '

  -- Set to true if you have a Nerd Font installed and selected in the terminal
  vim.g.have_nerd_font = true

  -- [[ Setting options ]]
  -- See `:help vim.o`
  -- NOTE: You can change these options as you wish!
  --  For more options, you can see `:help option-list`

  -- if performing an operation that would fail due to unsaved changes in the buffer (like `:q`),
  -- instead raise a dialog asking if you wish to save the current file(s)
  -- See `:help 'confirm'`
  vim.o.confirm = true

  -- Enable mouse mode, can be useful for resizing splits for example!
  vim.o.mouse = 'a'
  vim.o.mousescroll = 'ver:25,hor:6'

  -- Disable swap files
  vim.o.swapfile = false

  -- Use already opened buffers when switching
  vim.o.switchbuf = 'usetab'

  -- Save undo history
  vim.o.undofile = true

  -- Limit ShaDa file (for startup)
  vim.o.shada = "'100,<50,s10,:1000,/100,@100,h"

  -- Enable all filetype plugins and syntax (if not enabled, for better startup)
  vim.cmd 'filetype plugin indent on'
  if vim.fn.exists 'syntax_on' ~= 1 then vim.cmd 'syntax enable' end

  -- Decrease mapped sequence wait time
  vim.o.timeoutlen = 300

  -- Decrease update time
  vim.o.updatetime = 250

  -- [[ UI options ]]
  -- Indent wrapped lines to match line start
  vim.o.breakindent = true

  -- with padding for lists if 'wrap' is set
  vim.o.breakindentopt = 'list:-1'

  -- Draw column on the right of maximum width
  vim.o.colorcolumn = '+1'

  -- Show which line your cursor is on
  vim.o.cursorline = true

  -- Show cursor line per screen line
  vim.o.cursorlineopt = 'screenline,number'

  -- Keep window sizes when closing others
  vim.o.equalalways = false

  -- Preview substitutions live, as you type!
  vim.o.inccommand = 'split'

  -- Wrap lines at 'breakat' (if 'wrap' is set)
  vim.o.linebreak = true

  -- Sets how neovim will display certain whitespace characters in the editor.
  --  See `:help 'list'`
  --  and `:help 'listchars'`
  vim.o.list = false
  vim.opt.listchars = { tab = '⇥ ', trail = '·', nbsp = '␣', eol = '¬', extends = '❯', precedes = '❮' }

  -- Show line numbers
  vim.o.number = true

  -- Make popup menu smaller
  vim.o.pumheight = 10

  -- Show relative line numbers
  vim.o.relativenumber = true

  -- Don't show cursor coordinates
  vim.o.ruler = false

  -- Minimal number of screen lines to keep above and below the cursor.
  vim.o.scrolloff = 10
  vim.o.sidescrolloff = 5

  -- Disable some built-in completion messages
  vim.o.shortmess = 'CFOSWaco'

  -- Don't show the mode, since it's already in the status line
  vim.o.showmode = false

  -- Keep signcolumn on by default
  vim.o.signcolumn = 'yes'

  -- Configure how new splits should be opened
  vim.o.splitbelow = true -- Horizontal splits will be below
  vim.o.splitkeep = 'screen' -- Reduce scroll during window split
  vim.o.splitright = true -- Vertical splits will be to the right

  -- Set rounded window borders
  vim.o.winborder = 'single'

  -- Do not wrap by default
  vim.o.wrap = false

  -- Less busy diff views
  vim.opt.diffopt:append { vertical = true, algorithm = 'histogram', ['indent-heuristic'] = true }
  vim.opt.fillchars:append { diff = ' ' }

  -- [[ Editing options ]]

  -- Use auto indent
  vim.o.autoindent = true

  -- Built-in completion
  vim.o.complete = '.,w,b,kspell' -- Use less sources
  vim.o.completeopt = 'menuone,noselect,fuzzy,nosort' -- Use custom behavior

  -- Convert tabs to spaces
  vim.o.expandtab = true

  -- From the Vim docs:
  -- t   Auto-wrap text using textwidth
  --
  -- c   Auto-wrap comments using textwidth, inserting the current comment
  --     leader automatically.
  --
  -- r   Automatically insert the current comment leader after hitting
  --     <Enter> in Insert mode.
  --
  -- o   Automatically insert the current comment leader after hitting 'o' or
  --     'O' in Normal mode.
  --
  -- q	 Allow formatting of comments with "gq".
  --  	 Note that formatting will not change blank lines or lines containing
  --  	 only the comment leader.  A new paragraph starts after such a line,
  --  	 or when the comment leader changes.
  --
  -- n   When formatting text, recognize numbered lists.  This actually uses
  --     the 'formatlistpat' option, thus any kind of list can be used.  The
  --     indent of the text after the number is used for the next line.  The
  --     default is to find a number, optionally followed by '.', ':', ')',
  --     ']' or '}'.  Note that 'autoindent' must be set too.  Doesn't work
  --     well together with --2--.
  --     Example:
  --         1. the first item
  --            wraps
  --
  -- l   Long lines are not broken in insert mode: When a line was longer than
  -- 	   'textwidth' when the insert command started, Vim does not
  -- 	   automatically format it.
  --
  -- 1	 Don't break a line after a one-letter word.  It's broken before it
  --	   instead (if possible).
  --
  -- j   Where it makes sense, remove a comment leader when joining lines.  For
  --    	example, joining:
  --    		int i;   // the index ~
  --    		         // in the list ~
  --    	Becomes:
  --    		int i;   // the index in the list ~
  vim.o.formatoptions = 'tcroqnl1j'

  -- Case-insensitive searching by default
  vim.o.ignorecase = true

  -- Show search matches while typing
  vim.o.incsearch = true

  -- Infer case in built-in completion
  vim.o.infercase = true

  -- Show matching parens
  vim.o.showmatch = true

  -- Respect case in search if \C or one or more capital letters in the search term
  vim.o.smartcase = true

  -- Make indenting smart
  vim.o.smartindent = true

  -- Configure but disable spell checking by default because of Harper
  vim.o.spell = false
  vim.o.spelllang = 'en_us'
  vim.o.spelloptions = 'camel' -- Treat camelCase word parts as separate words

  -- Set text width
  vim.o.textwidth = 100
end

-- ============================================================
-- SECTION 2: KEYMAPS & AUTOCMDS
-- basic keymaps, basic autocmds
-- ============================================================
do
  -- [[ Basic Keymaps ]]
  --  See `:help vim.keymap.set()`

  -- Diagnostic Config
  -- See :help vim.diagnostic.Opts
  local virtual_lines_config = {
    current_line = true,
    severity = {
      min = vim.diagnostic.severity.ERROR,
    },
  }

  local diagnostic_config = {
    update_in_insert = false,
    severity_sort = true,
    float = { border = 'rounded', source = 'if_many' },
    underline = { severity = { min = vim.diagnostic.severity.WARN } },
    signs = vim.g.have_nerd_font and {
      text = {
        [vim.diagnostic.severity.ERROR] = '󰅚 ',
        [vim.diagnostic.severity.WARN] = '󰀪 ',
        [vim.diagnostic.severity.INFO] = '󰋽 ',
        [vim.diagnostic.severity.HINT] = '󰌶 ',
      },
    } or {},
    virtual_text = {
      current_line = true,
      source = 'if_many',
      spacing = 2,
      severity = {
        min = vim.diagnostic.severity.HINT,
      },
    },
    virtual_lines = false,
  }

  vim.diagnostic.config(diagnostic_config)

  -- Function to toggle virtual_lines
  local function toggle_virtual_lines()
    if diagnostic_config.virtual_lines == false then
      diagnostic_config.virtual_lines = virtual_lines_config
    else
      diagnostic_config.virtual_lines = false
    end
    vim.diagnostic.config(diagnostic_config)
  end

  vim.keymap.set('n', '<leader>xv', toggle_virtual_lines, { desc = 'Toggle diagnostic [V]irtual lines' })

  -- Diagnostic keymaps
  vim.keymap.set('n', '<leader>xq', vim.diagnostic.setqflist, { desc = 'Open diagnostic [Q]uickfix list' })
  vim.keymap.set('n', '<leader>xl', vim.diagnostic.setloclist, { desc = 'Open diagnostic [L]ocation list' })
  vim.keymap.set('n', '<leader>xd', vim.diagnostic.open_float, { desc = 'Open diagnostic [D]etails in floating window' })

  -- Scroll more lines at a time
  vim.keymap.set('n', '<C-e>', '5<C-e>')
  vim.keymap.set('n', '<C-y>', '5<C-y>')

  -- [[ Basic Autocommands ]]
  --  See `:help lua-guide-autocommands`
  vim.api.nvim_create_autocmd('BufReadPost', {
    desc = 'Jump to last cursor position',
    group = vim.api.nvim_create_augroup('last-cursor-position', { clear = true }),
    callback = function()
      if vim.bo.filetype:sub(1, 3) ~= 'git' and vim.fn.line '\'"' > 0 and vim.fn.line '\'"' <= vim.fn.line '$' then vim.cmd 'normal! g`"' end
    end,
  })

  vim.api.nvim_create_autocmd('FileType', {
    desc = 'Prose formatting and wrapped line display',
    group = vim.api.nvim_create_augroup('text-formatting', { clear = true }),
    pattern = { 'markdown', 'ghmarkdown', 'git*', 'text' },
    callback = function()
      vim.bo.textwidth = 0
      vim.bo.wrapmargin = 0

      vim.wo.wrap = true
      vim.wo.linebreak = true
      vim.wo.breakindent = true
      vim.wo.showbreak = '» '
      -- 2 to hide conceal text
      vim.wo.conceallevel = 2
    end,
  })

  -- [[ User commands ]]
  vim.api.nvim_create_user_command('E', 'e', { bang = true, desc = 'Reload current buffer' })
  vim.api.nvim_create_user_command('W', 'w', { bang = true, desc = 'Write current buffer' })
  vim.api.nvim_create_user_command('Q', 'q', { bang = true, desc = 'Quit current buffer' })
  vim.api.nvim_create_user_command('WQ', 'wq', { bang = true, desc = 'Write and quit current buffer' })
  vim.api.nvim_create_user_command('Wq', 'wq', { bang = true, desc = 'Write and quit current buffer' })
  vim.api.nvim_create_user_command('WA', 'wa', { bang = true, desc = 'Write all buffers' })
  vim.api.nvim_create_user_command('Wa', 'wa', { bang = true, desc = 'Write all buffers' })
  vim.api.nvim_create_user_command('QA', 'qa', { bang = true, desc = 'Quit all buffers' })
  vim.api.nvim_create_user_command('Qa', 'qa', { bang = true, desc = 'Quit all buffers' })
  vim.api.nvim_create_user_command('Wqa', 'wqa', { bang = true, desc = 'Write and quit all buffers' })
  vim.api.nvim_create_user_command('PackUpdate', function(opts)
    local args = opts.fargs
    if #args == 0 then
      vim.pack.update()
    else
      vim.pack.update(args)
    end
  end, { nargs = '*', desc = 'Update vim.pack plugins', complete = 'packadd' })
end

-- ============================================================
-- SECTION 3: PLUGIN MANAGER INTRO
-- vim.pack intro, build hooks
-- ============================================================
do
  -- [[ Intro to `vim.pack` ]]
  -- `vim.pack` is a new plugin manager built into Neovim,
  --  which provides a Lua interface for installing and managing plugins.
  --
  --  See `:help vim.pack`, `:help vim.pack-examples` or the
  --  excellent blog post from the creator of vim.pack and mini.nvim:
  --  https://echasnovski.com/blog/2026-03-13-a-guide-to-vim-pack
  --
  --  To inspect plugin state and pending updates, run
  --    :lua vim.pack.update(nil, { offline = true })
  --
  --  To update plugins, run
  --    :lua vim.pack.update()
  --
  --
  --  Throughout the rest of the config there will be examples
  --  of how to install and configure plugins using `vim.pack`.
  --
  --  In this section we set up some autocommands to run build
  --  steps for certain plugins after they are installed or updated.

  -- This autocommand runs after a plugin is installed or updated and
  --  runs the appropriate build command for that plugin if necessary.
  --
  -- See `:help vim.pack-events`
  vim.api.nvim_create_autocmd('PackChanged', {
    callback = function(ev)
      local name = ev.data.spec.name
      local kind = ev.data.kind
      if kind ~= 'install' and kind ~= 'update' then return end

      if name == 'nvim-treesitter' then
        if not ev.data.active then vim.cmd.packadd 'nvim-treesitter' end
        vim.cmd 'TSUpdate'
        return
      end
    end,
  })
end

--- Because most plugins are hosted on GitHub, you can use the helper
--- function to have less repetition in the following sections.
---@param repo string
---@return string
local function gh(repo) return 'https://github.com/' .. repo end

-- ============================================================
-- SECTION 4: PLUGINS
-- ============================================================
do
  -- [[ Installing and Configuring Plugins ]]
  --
  -- To install a plugin simply call `vim.pack.add` with its git url.
  -- This will download the default branch of the plugin, which will usually be `main` or `master`
  -- You can also have more advanced specs, which we will talk about later.
  --
  -- For most plugins its not enough to install them, you also need to call their `.setup()` to start them.
  --
  --  To check plugin status or fetch updates:
  --    :lua vim.pack.update(nil, { offline = true }) -- inspect state
  --    :lua vim.pack.update()                        -- fetch updates
  --
  -- Colorscheme (added first so it loads before everything else)
  vim.pack.add { gh 'shaunsingh/nord.nvim' }
  vim.o.termguicolors = true
  vim.o.background = 'dark'
  vim.g.nord_contrast = true
  vim.g.nord_borders = true
  vim.g.nord_uniform_diff_background = true
  vim.cmd.colorscheme 'nord'

  -- Detect tabstop and shiftwidth automatically
  vim.pack.add { gh 'NMAC427/guess-indent.nvim' }
  require('guess-indent').setup {}

  -- :Gdiff, :Gcommit, etc. and :GBrowse with Github
  vim.pack.add {
    gh 'tpope/vim-fugitive',
    gh 'tpope/vim-rhubarb',
  }

  -- Prefer two-way merge with conflicts pre-resolved
  -- Requires gitconfig changes to use as git mergetool
  vim.pack.add { gh 'samoshkin/vim-mergetool' }

  -- Netrw improvements
  vim.pack.add { gh 'tpope/vim-vinegar' }
  vim.cmd [[ nnoremap - -]]

  -- JSON syntax, concealment, and formatting with gqaj
  vim.pack.add {
    gh 'tpope/vim-jdaddy',
  }

  -- Markdown preview
  vim.g.marked_filetypes = { 'markdown', 'mkd', 'ghmarkdown', 'vimwiki' }
  vim.g.marked_auto_quit = 0
  vim.pack.add { gh 'itspriddle/vim-marked' }

  -- Rainbow parens, brackets, etc. Also affects JSX/HTML nesting
  vim.pack.add { gh 'hiphish/rainbow-delimiters.nvim' }
  require('rainbow-delimiters.setup').setup {
    highlight = {
      'RainbowDelimiterBlue',
      'RainbowDelimiterYellow',
      'RainbowDelimiterGreen',
      'RainbowDelimiterOrange',
      'RainbowDelimiterCyan',
      'RainbowDelimiterRed',
    },
  }

  -- Navigate between vim and tmux panes with the same keys
  vim.pack.add { gh 'alexghergh/nvim-tmux-navigation' }
  require('nvim-tmux-navigation').setup {
    keybindings = {
      left = '<C-h>',
      down = '<C-j>',
      up = '<C-k>',
      right = '<C-l>',
      last_active = '<C-\\>',
      next = '<C-Space>',
    },
  }

  -- FZF-powered pickers for many lists: files, buffers, git, keymaps, etc.
  vim.pack.add { gh 'ibhagwan/fzf-lua' }
  local fzf = require 'fzf-lua'
  fzf.setup {
    { 'fzf-tmux' },
    fzf_colors = true,
    winopts = {
      preview = {
        default = 'bat',
        hidden = false,
        horizontal = 'right:40%',
        winopts = { -- builtin previewer window options
          number = true,
          relativenumber = false,
          cursorline = true,
          cursorlineopt = 'both',
          cursorcolumn = false,
          signcolumn = 'yes',
          list = false,
          foldenable = false,
          foldmethod = 'manual',
          scrolloff = 0,
          winblend = 0,
        },
      },
    },
    keymap = {
      fzf = {
        -- inherits the default keymaps
        true,
        -- use C-q to select all items and convert to quickfix list
        ['ctrl-q'] = 'select-all+accept',
      },
    },
  }

  vim.keymap.set('n', '<leader><leader>', fzf.files, { desc = '[ ] Pick files' })
  vim.keymap.set('n', "<leader>'", fzf.buffers, { desc = "['] Pick buffers" })
  vim.keymap.set('n', '<leader><', fzf.git_files, { desc = '[<] Pick git files' })
  vim.keymap.set('n', '<leader>,', fzf.git_status, { desc = '[,] Pick git files with status' })
  vim.keymap.set('n', '<leader>.', fzf.grep_cword, { desc = 'Search word under cursor' })
  vim.keymap.set('n', '<leader>>', fzf.grep_cWORD, { desc = 'Search WORD under cursor' })
  vim.keymap.set('n', '<leader>p', fzf.grep_project, { desc = 'Search [p]roject' })
  vim.keymap.set('n', 'z=', fzf.spell_suggest, { desc = 'Select suggested spelling' })

  -- Inline line-wise git blame
  vim.pack.add { gh 'f-person/git-blame.nvim' }
  require('gitblame').setup {
    enabled = false,
    date_format = '%r',
    virtual_text_column = 100,
    use_blame_commit_file_urls = true,
  }
  vim.keymap.set('n', '<leader>gb', function() vim.cmd.GitBlameToggle() end, { desc = '[G]it [B]lame' })

  -- Useful plugin to show you pending key bindings
  vim.pack.add { gh 'folke/which-key.nvim' }
  require('which-key').setup {
    -- delay between pressing a key and opening which-key (milliseconds)
    -- this setting is independent of vim.o.timeoutlen
    delay = 100,
    icons = { mappings = vim.g.have_nerd_font },

    -- Document existing key chains
    spec = {
      { '<leader>c', group = '[C]ode', mode = { 'n', 'x' } },
      { '<leader>d', group = '[D]iff' },
      { '<leader>g', group = '[G]it' },
      { '<leader>x', group = 'Diagnostics' },
      { '<leader>a', group = 'Sidekick', mode = { 'n', 'x' } },
      { 'C-w', group = '[W]indow', mode = { 'n' } },
      { 'gr', group = 'LSP Actions', mode = { 'n' } },
    },
  }

  -- LSP Plugins

  -- Main LSP Configuration

  -- 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, mode)
        mode = mode or 'n'
        vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
      end

      local lsp_fzf = require 'fzf-lua'

      -- Rename the variable under your cursor.
      --  Most Language Servers support renaming across files, etc.
      map('grn', 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('gra', lsp_fzf.lsp_code_actions, 'Code [A]ction', { 'n', 'x' })

      -- Find references for the word under your cursor.
      map('grr', lsp_fzf.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('gri', lsp_fzf.lsp_implementations, '[G]oto [I]mplementation')

      -- 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('grd', function() lsp_fzf.lsp_definitions { jump1 = true } end, '[G]oto [D]efinition')

      -- WARN: This is not Goto Definition, this is Goto Declaration.
      --  For example, in C this would take you to the header.
      map('grD', function() lsp_fzf.lsp_declarations { jump1 = true } end, '[G]oto [D]eclaration')

      -- Fuzzy find all the symbols in your current document.
      --  Symbols are things like variables, functions, types, etc.
      map('gO', lsp_fzf.lsp_document_symbols, 'Document Symbols')

      -- Fuzzy find all the symbols in your current workspace.
      --  Similar to document symbols, except searches over your entire project.
      map('gW', lsp_fzf.lsp_live_workspace_symbols, '[W]orkspace Symbols')

      -- 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('grt', function() lsp_fzf.lsp_typedefs { jump1 = true } end, '[T]ype Definition')
    end,
  })

  -- 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/
  ---@class LspServersConfig
  ---@type table<string, vim.lsp.Config>
  local servers = {
    -- clangd = {},
    -- gopls = {},
    -- pyright = {},
    -- tsc = {},
    --
    -- Some languages (like rust) have entire language plugins that can be useful:
    --    https://github.com/mrcjkb/rustaceanvim
    --
    -- But for many setups, the LSP (`rust_analyzer`) will work just fine
    -- rust_analyzer = {},
    --

    stylua = {}, -- Used to format Lua code

    -- Special Lua Config, as recommended by neovim help docs
    lua_ls = {
      on_init = function(client)
        client.server_capabilities.documentFormattingProvider = false -- Disable formatting (formatting is done by stylua)

        if client.workspace_folders then
          local path = client.workspace_folders[1].name
          if path ~= vim.fn.stdpath 'config' and (vim.uv.fs_stat(path .. '/.luarc.json') or vim.uv.fs_stat(path .. '/.luarc.jsonc')) then return end
        end

        local current_settings = client.config.settings --[[@as lspconfig.settings.lua_ls]]
        client.config.settings.Lua = vim.tbl_deep_extend('force', current_settings.Lua, {
          runtime = {
            version = 'LuaJIT',
            path = { 'lua/?.lua', 'lua/?/init.lua' },
          },
          workspace = {
            checkThirdParty = false,
            -- NOTE: this is a lot slower and will cause issues when working on your own configuration.
            --  See https://github.com/neovim/nvim-lspconfig/issues/3189
            library = vim.api.nvim_get_runtime_file('', true),
          },
        })
      end,
      ---@type lspconfig.settings.lua_ls
      settings = {
        Lua = {
          format = { enable = false }, -- Disable formatting (formatting is done by stylua)
        },
      },
    },
    tailwindcss = {
      settings = {
        tailwindCSS = {
          experimental = {
            classRegex = {
              'tw`([^`]*)',
              'tw="([^"]*)',
              'tw={"([^"}]*)',
              'tw\\.\\w+`([^`]*)',
              'tw\\(.*?\\)`([^`]*)',
              { 'c(?:ls)?x\\(([^)]*)\\)', '["\'`]([^"\'`]*)["\'`]' },
            },
          },
        },
      },
    },
    ty = {},
    ruff = {},
    rust_analyzer = {},
    ['stylelint-language-server'] = {},
    cssls = {},
    css_variables = {},
    sqlls = {},
    buf_ls = {},
    harper_ls = {
      -- filetypes = { 'markdown', 'text', 'gitcommit', 'gitrebase' },
      settings = {
        ['harper-ls'] = {
          linters = {
            SentenceCapitalization = false,
            Spaces = false,
          },
        },
      },
    },
    gh_actions_ls = {},
    bashls = {
      filetypes = { 'bash', 'sh', 'zsh' },
    },
  }

  -- Add any extra servers that are not managed by Mason here
  local external_servers = {}

  -- Explicitly set up LSP servers before mason-lspconfig loads default configs
  for server, config in pairs(vim.tbl_extend('keep', servers, external_servers)) do
    if not vim.tbl_isempty(config) then vim.lsp.config(server, config) end
  end

  -- LSP dependencies — must be added and set up before nvim-lspconfig config runs.
  -- Mason must be set up first since mason-lspconfig depends on it.
  vim.pack.add {
    gh 'neovim/nvim-lspconfig',
    gh 'mason-org/mason.nvim',
    gh 'mason-org/mason-lspconfig.nvim',
    gh 'WhoIsSethDaniel/mason-tool-installer.nvim',
    gh 'zapling/mason-lock.nvim',
    gh 'j-hui/fidget.nvim',
  }
  require('mason').setup {}
  require('mason-lock').setup {}
  require('fidget').setup {}

  -- 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.
  --
  -- 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
    'biome', -- Used to format js/ts
    'prettierd', -- Used to format markdown
    'stylelint', -- Used to format css
  })
  require('mason-tool-installer').setup { ensure_installed = ensure_installed }

  -- Translates between nvim-lspconfig server names and mason.nvim package names (e.g. lua_ls <-> lua-language-server)
  require('mason-lspconfig').setup {
    ensure_installed = {}, -- explicitly set to an empty table (Kickstart populates installs via mason-tool-installer)
    automatic_enable = true, -- Change this to true if you want to automatically enable servers that are installed manually (e.g. via :Mason / :MasonInstall)
  }

  -- Enable extra server not managed by Mason, if any
  if not vim.tbl_isempty(external_servers) then vim.lsp.enable(vim.tbl_keys(external_servers)) end

  -- Typescript specific LSP config
  vim.pack.add {
    gh 'nvim-lua/plenary.nvim',
    gh 'pmizio/typescript-tools.nvim',
  }
  require('typescript-tools').setup {
    settings = {
      tsserver_file_preferences = {
        importModuleSpecifierPreference = 'non-relative',
        includeInlayParameterNameHints = 'all',
        includeInlayParameterNameHintsWhenArgumentMatchesName = true,
        includeInlayFunctionParameterTypeHints = true,
        includeInlayVariableTypeHints = true,
        includeInlayVariableTypeHintsWhenTypeMatchesName = true,
        includeInlayPropertyDeclarationTypeHints = true,
        includeInlayFunctionLikeReturnTypeHints = true,
        includeInlayEnumMemberValueHints = true,
      },
      jsx_close_tag = {
        enabled = true,
      },
    },
  }

  -- Copilot
  vim.pack.add {
    gh 'zbirenbaum/copilot.lua',
  }
  require('copilot').setup {
    suggestion = {
      enabled = true,
      auto_trigger = true,
    },
  }

  -- Sidekick AI assistant CLI integration
  vim.pack.add { gh 'folke/sidekick.nvim' }
  require('sidekick').setup {
    cli = {
      win = {
        keys = {
          nav_left = {
            '<C-h>',
            function() vim.schedule(require('nvim-tmux-navigation').NvimTmuxNavigateLeft) end,
            mode = 't',
            expr = false,
            desc = 'Navigate Left',
          },
          nav_down = {
            '<C-j>',
            function() vim.schedule(require('nvim-tmux-navigation').NvimTmuxNavigateDown) end,
            mode = 't',
            expr = false,
            desc = 'Navigate Down',
          },
          nav_up = {
            '<C-k>',
            function() vim.schedule(require('nvim-tmux-navigation').NvimTmuxNavigateUp) end,
            mode = 't',
            expr = false,
            desc = 'Navigate Up',
          },
          nav_right = {
            '<C-l>',
            function() vim.schedule(require('nvim-tmux-navigation').NvimTmuxNavigateRight) end,
            mode = 't',
            expr = false,
            desc = 'Navigate Right',
          },
        },
      },
      mux = {
        backend = 'tmux',
        enabled = true,
      },
    },
  }
  vim.keymap.set('n', '<tab>', function()
    -- if there is a next edit, jump to it, otherwise apply it if any
    if not require('sidekick').nes_jump_or_apply() then
      return '<Tab>' -- fallback to normal tab
    end
  end, { expr = true, desc = 'Goto/Apply Next Edit Suggestion' })
  vim.keymap.set({ 'n', 't', 'i', 'x' }, '<c-.>', function() require('sidekick.cli').toggle() end, { desc = 'Sidekick Toggle' })
  vim.keymap.set('n', '<leader>aa', function() require('sidekick.cli').toggle() end, { desc = 'Sidekick Toggle CLI' })
  vim.keymap.set('n', '<leader>as', function() require('sidekick.cli').select() end, { desc = 'Select CLI' })
  vim.keymap.set('n', '<leader>ad', function() require('sidekick.cli').close() end, { desc = 'Detach a CLI Session' })
  vim.keymap.set({ 'x', 'n' }, '<leader>at', function() require('sidekick.cli').send { msg = '{this}' } end, { desc = 'Send This' })
  vim.keymap.set('n', '<leader>af', function() require('sidekick.cli').send { msg = '{file}' } end, { desc = 'Send File' })
  vim.keymap.set('x', '<leader>av', function() require('sidekick.cli').send { msg = '{selection}' } end, { desc = 'Send Visual Selection' })
  vim.keymap.set({ 'n', 'x' }, '<leader>ap', function() require('sidekick.cli').prompt() end, { desc = 'Sidekick Select Prompt' })
  vim.keymap.set('n', '<leader>ao', function() require('sidekick.cli').toggle { name = 'opencode', focus = true } end, { desc = 'Sidekick Toggle OpenCode' })
  vim.keymap.set('n', '<leader>ac', function() require('sidekick.cli').toggle { name = 'claude', focus = true } end, { desc = 'Sidekick Toggle Claude' })

  -- Autoformat
  vim.pack.add { gh 'stevearc/conform.nvim' }
  require('conform').setup {
    notify_on_error = false,
    format_on_save = {
      timeout_ms = 500,
      lsp_format = 'fallback',
    },
    formatters = {
      ['biome-check'] = {
        require_cwd = true,
      },
      prettierd = {
        require_cwd = true,
      },
    },
    formatters_by_ft = {
      lua = { 'stylua' },
      -- Conform can also run multiple formatters sequentially
      -- You can use 'stop_after_first' to run the first available formatter from the list
      python = { 'ruff_organize_imports', 'ruff_fix', 'ruff_format' },
      javascript = { 'biome-check' },
      javascriptreact = { 'biome-check' },
      typescript = { 'biome-check' },
      typescriptreact = { 'biome-check' },
      markdown = { 'prettierd', 'injected' },
      css = { 'stylelint' },
      proto = { 'buf' },
      bash = { 'shfmt' },
      zsh = { 'shfmt' },
      ['*'] = { 'trim_whitespace' },
    },
  }

  -- Autocompletion
  -- blink-copilot and blink-cmp-git are sources used by blink.cmp
  vim.pack.add {
    gh 'fang2hou/blink-copilot',
    gh 'Kaiser-Yang/blink-cmp-git',
    { src = gh 'saghen/blink.cmp', version = vim.version.range '1.*' },
  }

  -- [[ Helper Functions ]]
  local function get_github_token_from_netrc()
    local netrc_path = vim.fn.expand '~/.netrc'
    local file = io.open(netrc_path, 'r')
    if not file then return '' end
    local token = ''
    for line in file:lines() do
      local machine, login, password = line:match 'machine api%.github%.com login (%S+) password (%S+)'
      if machine and login and password then
        token = password
        break
      end
    end
    file:close()
    return token
  end

  --- @module 'blink.cmp'
  --- @type blink.cmp.Config
  require('blink.cmp').setup {
    keymap = {
      -- 'default' (recommended) for mappings similar to built-in completions
      --   <c-y> to accept ([y]es) the completion.
      --    This will auto-import if your LSP supports it.
      --    This will expand snippets if the LSP sent a snippet.
      -- 'super-tab' for tab to accept
      -- 'enter' for enter to accept
      -- 'none' for no mappings
      --
      -- For an understanding of why the 'default' preset is recommended,
      -- you will need to read `:help ins-completion`
      --
      -- No, but seriously. Please read `:help ins-completion`, it is really good!
      --
      -- All presets have the following mappings:
      -- <tab>/<s-tab>: move to right/left of your snippet expansion
      -- <c-space>: Open menu or open docs if already open
      -- <c-n>/<c-p> or <up>/<down>: Select next/previous item
      -- <c-e>: Hide menu
      -- <c-k>: Toggle signature help
      --
      -- See :h blink-cmp-config-keymap for defining your own keymap
      preset = 'default',
    },

    appearance = {
      -- 'mono' (default) for 'Nerd Font Mono' or 'normal' for 'Nerd Font'
      -- Adjusts spacing to ensure icons are aligned
      nerd_font_variant = 'mono',
    },

    completion = {
      -- By default, you may press `<c-space>` to show the documentation.
      -- Optionally, set `auto_show = true` to show the documentation after a delay.
      documentation = { auto_show = true, auto_show_delay_ms = 500 },
    },

    sources = {
      default = { 'copilot', 'lsp', 'git', 'path', 'buffer' },
      providers = {
        copilot = {
          name = 'copilot',
          module = 'blink-copilot',
          async = true,
          score_offset = 100, -- Make copilot suggestions have higher priority
        },
        git = {
          module = 'blink-cmp-git',
          name = 'git',
          enabled = function() return vim.tbl_contains({ 'git', 'gitcommit', 'ghmarkdown', 'markdown' }, vim.bo.filetype) end,
          --- @module 'blink-cmp-git'
          --- @type blink-cmp-git.Options
          opts = {
            commit = {
              get_token = get_github_token_from_netrc,
            },
            git_centers = {
              github = {
                issue = {
                  get_token = get_github_token_from_netrc,
                },
                pull_request = {
                  get_token = get_github_token_from_netrc,
                },
                mention = {
                  get_token = get_github_token_from_netrc,
                },
              },
            },
          },
        },
      },
    },
    -- Blink.cmp includes an optional, recommended rust fuzzy matcher,
    -- which automatically downloads a prebuilt binary when enabled.
    --
    -- By default, we use the Lua implementation instead, but you may enable
    -- the rust implementation via `'prefer_rust_with_warning'`
    --
    -- See :h blink-cmp-config-fuzzy for more information
    fuzzy = { implementation = 'lua' },

    -- Shows a signature help window while you type arguments for a function
    signature = { enabled = true },
  }

  -- Diagnostics display
  vim.pack.add { gh 'folke/trouble.nvim' }
  require('trouble').setup {}
  vim.keymap.set('n', '<leader>xx', '<cmd>Trouble diagnostics toggle<cr>', { desc = 'Diagnostics (Trouble)' })
  vim.keymap.set('n', '<leader>xX', '<cmd>Trouble diagnostics toggle filter.buf=0<cr>', { desc = 'Buffer Diagnostics (Trouble)' })

  -- Focus mode for prose filetypes
  vim.pack.add { gh 'folke/zen-mode.nvim' }
  require('zen-mode').setup { window = { width = 0.65 } }
  vim.api.nvim_create_autocmd({ 'VimEnter' }, {
    desc = 'Zen mode for prose',
    group = vim.api.nvim_create_augroup('zen-mode', { clear = true }),
    pattern = { '*.md', '*.markdown', '*.txt', 'COMMIT_EDITMSG' },
    callback = function() require('zen-mode').open { window = { width = 0.65 } } end,
  })

  -- Collection of various small independent plugins/modules
  -- nvim-treesitter-textobjects must be added before mini.nvim so mini.ai can use treesitter specs

  vim.pack.add {
    { src = gh 'nvim-treesitter/nvim-treesitter-textobjects', version = 'main' },
    gh 'nvim-mini/mini.nvim',
  }

  -- Better Around/Inside textobjects
  --
  -- Examples:
  --  - va)  - [V]isually select [A]round [)]paren
  --  - yinq - [Y]ank [I]nside [N]ext [Q]uote
  --  - ci'  - [C]hange [I]nside [']quote
  local spec_treesitter = require('mini.ai').gen_spec.treesitter
  require('mini.ai').setup {
    -- NOTE: Avoid conflicts with the built-in incremental selection mappings on Neovim>=0.12 (see `:help treesitter-incremental-selection`)
    mappings = {
      around_next = 'aa',
      inside_next = 'ii',
    },
    custom_textobjects = {
      F = spec_treesitter {
        a = '@function.outer',
        i = '@function.inner',
      },
      o = spec_treesitter {
        a = { '@conditional.outer', '@loop.outer' },
        i = { '@conditional.inner', '@loop.inner' },
      },
    },
    search_method = 'cover',
  }

  -- Similar to vim-sensible, but broader.
  --   Some config and options above likely duplicate this.
  require('mini.basics').setup {
    options = {
      basic = true,
      extra_ui = true,
    },
    mappings = {
      basic = false,
      windows = true,
    },
    autocommands = {
      basic = true,
    },
  }

  -- Keymaps for forwards/backwards objects, like vim-unimpaired
  require('mini.bracketed').setup {
    -- Use mappings from mini.indentscope
    indent = { suffix = '' },

    -- Disable mappings that are defined elsewhere
    file = { suffix = '' },
    window = { suffix = '' },
  }

  -- Highlight the word under the cursor
  require('mini.cursorword').setup()

  -- Highlight hex colors and todo-style keywords followed by a colon, e.g. `TODO:`
  local hipatterns = require 'mini.hipatterns'
  local function keywords(words)
    return vim.tbl_map(function(word) return '%f[%w]()' .. word .. '():' end, words)
  end
  hipatterns.setup {
    highlighters = {
      fixme = { pattern = keywords { 'FIXME', 'FIX', 'BUG', 'ISSUE' }, group = 'MiniHipatternsFixme' },
      hack = { pattern = keywords { 'HACK', 'WARN', 'WARNING', 'XXX', 'PERF' }, group = 'MiniHipatternsHack' },
      todo = { pattern = keywords { 'TODO' }, group = 'MiniHipatternsTodo' },
      note = { pattern = keywords { 'NOTE', 'INFO' }, group = 'MiniHipatternsNote' },
      hex_color = hipatterns.gen_highlighter.hex_color(),
    },
  }

  -- Diff hunk manipulation
  require('mini.diff').setup {
    view = {
      style = 'sign',
    },
  }
  vim.keymap.set('n', '<leader>do', require('mini.diff').toggle_overlay, { desc = 'Toggle [D]iff [O]verlay' })

  -- Fun icons for filetypes, actions, signs, etc.
  require('mini.icons').setup()
  MiniIcons.mock_nvim_web_devicons()

  -- Indent guides
  local indentscope = require 'mini.indentscope'
  indentscope.setup {
    draw = {
      animation = indentscope.gen_animation.none(),
    },
  }

  -- t, f, T, F are repeatable motions
  -- Highlight the next motion for subsequent tfTF motions
  require('mini.jump').setup {
    delay = {
      -- Delay between jump and highlighting all possible jumps
      highlight = 1000,
      -- Delay between jump and automatic stop if idle (no jump is done)
      idle_stop = 3000,
    },
  }

  -- Jump to locations with <enter>
  require('mini.jump2d').setup {
    view = {
      dim = true,
      n_steps_ahead = 2,
    },
    allowed_lines = {
      cursor_at = false,
      blank = false,
      fold = false,
    },
  }

  -- Automatically pair brackets, parens, etc.
  require('mini.pairs').setup {
    mappings = {
      -- Double quote: Prevent pairing if either side is a letter
      ['"'] = {
        action = 'closeopen',
        pair = '""',
        neigh_pattern = '[^%w\\][^%w]',
        register = { cr = false },
      },
      -- Single quote: Prevent pairing if either side is a letter
      ["'"] = {
        action = 'closeopen',
        pair = "''",
        neigh_pattern = '[^%w\\][^%w]',
        register = { cr = false },
      },
    },
    skip_ts = { 'string', 'comment' },
    skip_unbalanced = true,
    markdown = true,
  }

  -- Simple and easy statusline.
  --  You could remove this setup call if you don't like it,
  --  and try some other statusline plugin
  local statusline = require 'mini.statusline'
  -- Add custom highlights for inactive statusline
  vim.cmd 'hi MiniStatuslineInactiveMod guifg=#ebcb8b guibg=#2e3440'
  statusline.setup {
    -- set use_icons to true if you have a Nerd Font
    use_icons = vim.g.have_nerd_font,
    content = {
      -- show modified flag in inactive windows
      inactive = function()
        if vim.bo.buftype == 'terminal' then return '%t' end
        return '%#MiniStatuslineInactive#%f %#MiniStatuslineInactiveMod#%m%#MiniStatuslineInactive#%r%='
      end,
    },
  }

  -- You can configure sections in the statusline by overriding their
  -- default behavior.
  ---@diagnostic disable-next-line: duplicate-set-field
  statusline.section_filename = function(args)
    -- In terminal always use plain name
    if vim.bo.buftype == 'terminal' then
      return '%t'
    elseif MiniStatusline.is_truncated(args.trunc_width) then
      -- File name with 'truncate', 'modified', 'readonly' flags
      -- Use relative path if truncated
      return '%f %#DiffChange#%m%#MinistatusLineFilename#%r%='
    else
      -- Use fullpath if not truncated
      return '%F %#DiffChange#%m%#MinistatusLineFilename#%r%='
    end
  end

  -- Add/delete/replace surroundings (brackets, quotes, etc.)
  --
  -- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren
  -- - sd'   - [S]urround [D]elete [']quotes
  -- - sr)'  - [S]urround [R]eplace [)] [']
  require('mini.surround').setup()

  -- Highlight trailing whitespace and automatically trim it on write
  require('mini.trailspace').setup()

  -- Highlight, edit, and navigate code
  vim.pack.add { { src = gh 'nvim-treesitter/nvim-treesitter', version = 'main' } }
  -- [[ Configure Treesitter ]] See `:help nvim-treesitter-intro`
  -- The main branch of nvim-treesitter is a rewrite with different architecture.
  local ts = require 'nvim-treesitter'

  local languages = {
    'bash',
    'c',
    'css',
    'diff',
    'dockerfile',
    'git_config',
    'git_rebase',
    'gitattributes',
    'gitcommit',
    'gitignore',
    'html',
    'javascript',
    'json',
    'lua',
    'luadoc',
    'markdown',
    'markdown_inline',
    'python',
    'query',
    'regex',
    'rust',
    'sql',
    'toml',
    'tsx',
    'typescript',
    'vim',
    'vimdoc',
    'yaml',
  }
  ts.install(languages)

  ---@param buf integer
  ---@param language string
  local function treesitter_try_attach(buf, language)
    -- Check if the buffer is valid (might not be after install completes)
    if not vim.api.nvim_buf_is_valid(buf) then return end

    -- Check if a parser exists and load it
    if not vim.treesitter.language.add(language) then return end

    -- Enable syntax highlighting and other treesitter features
    vim.treesitter.start(buf, language)

    -- Enable treesitter based folds
    -- For more info on folds see `:help folds`
    -- vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
    -- vim.wo.foldmethod = 'expr'

    -- Check if treesitter indentation is available for this language, and if so enable it
    -- in case there is no indent query, the indentexpr will fallback to the vim's built in one
    local has_indent_query = vim.treesitter.query.get(language, 'indents') ~= nil

    -- Enable treesitter based indentation
    if has_indent_query then vim.bo.indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()" end
  end

  local available_parsers = ts.get_available()
  vim.api.nvim_create_autocmd('FileType', {
    callback = function(args)
      local buf, filetype = args.buf, args.match

      local language = vim.treesitter.language.get_lang(filetype)
      if not language then return end

      local installed_parsers = ts.get_installed 'parsers'

      if vim.tbl_contains(installed_parsers, language) then
        -- Enable the parser if it is already installed
        treesitter_try_attach(buf, language)
      elseif vim.tbl_contains(available_parsers, language) then
        -- If a parser is available in `nvim-treesitter`, auto-install it and enable it after the installation is done
        vim.notify('Installing treesitter parser for ' .. language .. '...', vim.log.levels.INFO)
        ts.install(language):await(function() treesitter_try_attach(buf, language) end)
      else
        -- Try to enable treesitter features in case the parser exists but is not available from `nvim-treesitter`
        treesitter_try_attach(buf, language)
      end
    end,
    desc = 'Install treesitter parser for the current or specified filetype',
  })

  -- <C-l> jumps to the end of the current treesitter node
  vim.keymap.set('i', '<C-l>', function()
    local node = vim.treesitter.get_node()
    if node ~= nil then
      local row, col = node:end_()
      pcall(vim.api.nvim_win_set_cursor, 0, { row + 1, col })
    end
  end, { desc = 'Jump to end of treesitter node' })

  -- There are additional nvim-treesitter modules that you can use to interact
  -- with nvim-treesitter. You should go explore a few and see what interests you:
  --
  --    - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context
  --    - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects (using the `main` branch)

  -- Edit and manage Obsidian notes and links
  -- plenary.nvim, blink.cmp, fzf-lua, and nvim-treesitter are all already added above
  local obsidian_vault = vim.fn.expand '~/Library/Mobile Documents/iCloud~md~obsidian/Documents/Obsidian Vault'
  if vim.uv.fs_stat(obsidian_vault) then
    vim.pack.add { gh 'obsidian-nvim/obsidian.nvim' }
    require('obsidian').setup {
      workspaces = {
        {
          name = 'work',
          path = obsidian_vault,
        },
      },
      completion = {
        min_chars = 1,
      },
      legacy_commands = false,
    }
  end

  -- Smear cursor on motions
  vim.pack.add { gh 'sphamba/smear-cursor.nvim' }
  require('smear_cursor').setup {
    stiffness = 0.8,
    trailing_stiffness = 0.6,
    stiffness_insert_mode = 0.7,
    trailing_stiffness_insert_mode = 0.7,
    damping = 0.95,
    damping_insert_mode = 0.95,
    distance_stop_animating = 0.5,
  }

  -- Custom plugin to load Ghostty's vim files
  if vim.env.GHOSTTY_RESOURCES_DIR then
    local ghostty_site = vim.env.GHOSTTY_RESOURCES_DIR .. '/../nvim/site'
    if vim.uv.fs_stat(ghostty_site) then vim.opt.rtp:prepend(ghostty_site) end
    -- The default ftdetect looks for */ghostty/config, but it is in a different location on MacOS.
    vim.api.nvim_create_autocmd('BufRead', {
      pattern = '*/com.mitchellh.ghostty/config',
      callback = function() vim.bo.filetype = 'ghostty' end,
    })
  end
end

-- The line beneath this is called `modeline`. See `:help modeline`
-- vim: ts=2 sts=2 sw=2 et