Neovim - Lua Configuration - Complete File-by-File Breakdown

nvim --version

sudo apt update && sudo apt install -y neovim git ripgrep

sudo apt install -y ninja-build gettext cmake unzip curl build-essential

git clone https://github.com/neovim/neovim /tmp/neovim

cd /tmp/neovim

git checkout stable

make CMAKE_BUILD_TYPE=Release

sudo make install

exec $SHELL

# or

hash -r

command -v nvim

nvim --version

sudo apt install -y shellcheck lua-check pylint yamllint jsonlint

sudo apt install -y shfmt jq black

test -d ~/.config/nvim && mv -v ~/.config/nvim{,.backup}

git clone --branch raven https://github.com/r4ven-me/neovim ~/.config/nvim

cd ~/.config/nvim

nvim ./init.lua

require("config.options")
require("config.keymaps")
require("config.autocmds")
require("config.lazy")

vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

local state_path = vim.fn.stdpath("state")
local function state_dir(name)
  return table.concat({ state_path, name }, "/")
end

for _, dir in ipairs({ "swap", "undo", "backup", "sessions", "shada" }) do
  vim.fn.mkdir(state_dir(dir), "p")
end

local function clean_stale_shada_tmp()
  local shada_tmp_files = vim.fn.glob(state_dir("shada") .. "/main.shada.tmp.*", false, true)
  local now = os.time()

  for _, file in ipairs(shada_tmp_files) do
    local mtime = vim.fn.getftime(file)
    if mtime > 0 and now - mtime > 86400 then
      pcall(vim.fn.delete, file)
    end
  end
end

clean_stale_shada_tmp()

vim.opt.mouse = "a"
vim.opt.encoding = "utf-8"
vim.opt.number = true
vim.opt.scrolloff = 7
vim.opt.showmode = false
vim.opt.showcmd = false
vim.opt.more = false
vim.opt.cursorline = true
vim.opt.cursorlineopt = "both"
vim.opt.ignorecase = true
vim.opt.smartcase = true
vim.opt.laststatus = 2
vim.opt.cmdheight = 1
vim.opt.tabstop = 4
vim.opt.softtabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
vim.opt.autoindent = true
vim.opt.smartindent = true
vim.opt.fileformats = { "unix", "dos", "mac" }
vim.opt.showtabline = 2
vim.opt.clipboard = "unnamedplus"
vim.opt.termguicolors = true
vim.opt.splitbelow = true
vim.opt.splitright = true
vim.opt.equalalways = true
vim.opt.updatetime = 250
vim.opt.timeoutlen = 500
vim.opt.ttimeoutlen = 200
vim.opt.completeopt = { "menu", "menuone", "noselect" }
vim.opt.signcolumn = "yes"

vim.opt.sessionoptions = {
  "buffers",
  "curdir",
  "folds",
  "help",
  "tabpages",
  "winsize",
  "winpos",
  "terminal",
  "localoptions",
}

vim.opt.shada = { "!", "'100", "<50", "s10", "h" }
vim.opt.shadafile = state_dir("shada") .. "/main.shada"

vim.opt.swapfile = true
vim.opt.directory = state_dir("swap") .. "//"
vim.opt.writebackup = true
vim.opt.backup = false
vim.opt.backupcopy = "auto"
vim.opt.backupdir = state_dir("backup") .. "//"
vim.opt.undofile = true
vim.opt.undodir = state_dir("undo") .. "//"

vim.opt.foldmethod = "indent"
vim.opt.foldnestmax = 10
vim.opt.foldenable = false
vim.opt.foldlevel = 2

vim.opt.guicursor = table.concat({
  "n-v-c:block-Cursor",
  "i-ci-ve:ver25-iCursor",
  "r-cr:hor20-rCursor",
  "o:hor50",
}, ",")

vim.diagnostic.config({
  virtual_text = {
    spacing = 2,
    prefix = "●",
    source = "if_many",
  },
  signs = true,
  underline = true,
  update_in_insert = false,
  severity_sort = true,
  float = {
    border = "rounded",
    source = "if_many",
    header = "",
  },
})

local diagnostic_signs = {
  Error = "E",
  Warn = "W",
  Hint = "H",
  Info = "I",
}

for type, icon in pairs(diagnostic_signs) do
  local hl = "DiagnosticSign" .. type
  vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl })
end

local map = vim.keymap.set
local opts = { noremap = true, silent = true }

map("n", "<CR>", "o<Esc>", opts)
map("n", "<Space>", "a <Esc>", opts)
map("i", "jk", "<Esc>", opts)
map("n", ",<Space>", "<cmd>nohlsearch<CR>", opts)
map("n", "x", '"_x', opts)
map("x", "x", '"_x', opts)
map("x", "p", "P", opts)
map("x", "P", "p", opts)
map("n", "WW", "<cmd>w<CR>", opts)

local function git_commit_current_dir()
  local file = vim.fn.expand("%:p")
  local dir = vim.fn.fnamemodify(file ~= "" and file or vim.fn.getcwd(), ":h")

  vim.cmd("!" .. table.concat({
    "git add " .. vim.fn.shellescape(dir),
    "git commit -m Upd",
    "git push",
  }, " && "))
end

map("n", "<S-F1>", "<cmd>help nvim-config<CR>", vim.tbl_extend("force", opts, { desc = "Open Neovim config help" }))
map("n", "<F13>", git_commit_current_dir, vim.tbl_extend("force", opts, { desc = "Git add/commit/push current dir" }))

local session_prefix = vim.fn.stdpath("state") .. "/sessions/session"

local function save_session(num)
  vim.cmd("mksession! " .. vim.fn.fnameescape(session_prefix .. num .. ".vim"))
end

local function load_session(num)
  vim.cmd("source " .. vim.fn.fnameescape(session_prefix .. num .. ".vim"))
  vim.schedule(function()
    vim.cmd("Neotree show")
    vim.cmd("wincmd w")
  end)
end

for key, num in pairs({
  ["<S-F9>"] = "1",
  ["<S-F10>"] = "2",
  ["<S-F11>"] = "3",
  ["<S-F12>"] = "4",
  ["<F21>"] = "1",
  ["<F22>"] = "2",
  ["<F23>"] = "3",
  ["<F24>"] = "4",
}) do
  map("n", key, function()
    save_session(num)
  end, { desc = "Save session " .. num })
  map("i", key, function()
    vim.cmd.stopinsert()
    save_session(num)
    vim.cmd.startinsert()
  end, { desc = "Save session " .. num })
end

for key, num in pairs({
  ["<F9>"] = "1",
  ["<F10>"] = "2",
  ["<F11>"] = "3",
  ["<F12>"] = "4",
}) do
  map("n", key, function()
    load_session(num)
  end, { desc = "Load session " .. num })
end

map("", "<S-ScrollWheelUp>", "<cmd>BufferLineMovePrev<CR>", { desc = "Move buffer left" })
map("", "<S-ScrollWheelDown>", "<cmd>BufferLineMoveNext<CR>", { desc = "Move buffer right" })

map("n", "<leader>d", vim.diagnostic.open_float, { desc = "Line diagnostics" })
map("n", "[d", vim.diagnostic.goto_prev, { desc = "Previous diagnostic" })
map("n", "]d", vim.diagnostic.goto_next, { desc = "Next diagnostic" })

map("n", "<Esc><Esc>", function()
  local ok, noice = pcall(require, "noice")
  if ok then
    noice.cmd("dismiss")
  else
    vim.cmd.nohlsearch()
  end
end, { desc = "Dismiss UI messages/search" })

local group = vim.api.nvim_create_augroup("UserConfig", { clear = true })

vim.api.nvim_create_autocmd("FileType", {
  group = group,
  pattern = "*",
  callback = function()
    vim.opt_local.formatoptions:remove({ "c", "r", "o" })
  end,
})

vim.api.nvim_create_autocmd("FileType", {
  group = group,
  pattern = { "lua", "json", "yaml", "toml" },
  callback = function()
    vim.opt_local.shiftwidth = 2
    vim.opt_local.tabstop = 2
    vim.opt_local.softtabstop = 2
    vim.opt_local.expandtab = true
  end,
})

vim.api.nvim_create_autocmd("FileType", {
  group = group,
  pattern = { "sh", "bash", "zsh", "python" },
  callback = function(event)
    local function run_current_file()
      local file = vim.api.nvim_buf_get_name(event.buf)
      if file == "" then
        return
      end

      vim.cmd.write()
      vim.fn.system({ "chmod", "ug+x", file })
      vim.cmd("!" .. vim.fn.shellescape(file))
    end

    vim.keymap.set({ "n", "i" }, "<S-F5>", run_current_file, {
      buffer = event.buf,
      desc = "Save and run current file",
    })
  end,
})

vim.api.nvim_create_autocmd("BufReadPost", {
  group = group,
  callback = function(event)
    vim.api.nvim_create_autocmd("BufWinEnter", {
      group = group,
      once = true,
      buffer = event.buf,
      callback = function()
        local ft = vim.bo[event.buf].filetype
        local last_line = vim.api.nvim_buf_get_mark(event.buf, '"')[1]

        if ft:match("commit") or ft:match("rebase") then
          return
        end

        if last_line > 1 and last_line <= vim.api.nvim_buf_line_count(event.buf) then
          pcall(vim.cmd.normal, { args = { 'g`"' }, bang = true })
        end
      end,
    })
  end,
})

vim.api.nvim_create_autocmd("SessionLoadPost", {
  group = group,
  command = "wincmd =",
})

local function is_editor_buffer(buf)
  if not vim.api.nvim_buf_is_valid(buf) or vim.bo[buf].buftype ~= "" or vim.bo[buf].filetype == "neo-tree" then
    return false
  end

  if vim.api.nvim_buf_get_name(buf) ~= "" or vim.bo[buf].modified then
    return true
  end

  local lines = vim.api.nvim_buf_get_lines(buf, 0, 2, false)
  return #lines > 1 or lines[1] ~= ""
end

vim.api.nvim_create_autocmd("QuitPre", {
  group = group,
  callback = function()
    local current_win = vim.api.nvim_get_current_win()
    if not is_editor_buffer(vim.api.nvim_get_current_buf()) then
      return
    end

    local auxiliary_windows = {}
    for _, win in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
      if win ~= current_win then
        local buf = vim.api.nvim_win_get_buf(win)
        if is_editor_buffer(buf) then
          return
        end

        local filetype = vim.bo[buf].filetype
        if
          filetype == "neo-tree"
          or filetype == "codecompanion"
          or filetype == "codecompanion_input"
          or vim.bo[buf].buftype == "terminal"
        then
          table.insert(auxiliary_windows, win)
        end
      end
    end

    for _, win in ipairs(auxiliary_windows) do
      if vim.api.nvim_win_is_valid(win) then
        vim.api.nvim_win_close(win, true)
      end
    end
  end,
})

vim.api.nvim_create_autocmd("VimLeavePre", {
  group = group,
  callback = function()
    vim.fn.mkdir(vim.fn.stdpath("state") .. "/shada", "p")
  end,
})

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"

if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "--branch=stable",
    lazyrepo,
    lazypath,
  })

  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end

vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  spec = {
    { import = "plugins" },
  },
  install = {
    colorscheme = { "nord" },
  },
  checker = {
    enabled = false,
  },
  change_detection = {
    notify = false,
  },
  rocks = {
    enabled = false,
  },
  performance = {
    rtp = {
      disabled_plugins = {
        "gzip",
        "netrwPlugin",
        "tarPlugin",
        "tohtml",
        "tutor",
        "zipPlugin",
      },
    },
  },
})

local neo_tree_was_open = false
local window_before_save

local function close_neo_tree_before_save()
  neo_tree_was_open = false
  window_before_save = vim.api.nvim_get_current_win()

  for _, win in ipairs(vim.api.nvim_list_wins()) do
    if vim.bo[vim.api.nvim_win_get_buf(win)].filetype == "neo-tree" then
      neo_tree_was_open = true
      vim.cmd("Neotree close")
      break
    end
  end
end

local function restore_neo_tree_after_save()
  if not neo_tree_was_open then
    return
  end

  vim.cmd("Neotree show")
  if window_before_save and vim.api.nvim_win_is_valid(window_before_save) then
    vim.api.nvim_set_current_win(window_before_save)
  end
end

return {
  "rmagatti/auto-session",
  lazy = false,
  opts = {
    auto_save = true,
    auto_restore = false,
    auto_session_root_dir = vim.fn.stdpath("state") .. "/sessions/",
    bypass_save_filetypes = { "neo-tree", "toggleterm" },
    pre_save_cmds = {
      close_neo_tree_before_save,
    },
    post_save_cmds = {
      restore_neo_tree_after_save,
    },
    post_restore_cmds = {
      "Neotree show",
      "wincmd w",
    },
  },
  keys = {
    { "WS", "<cmd>AutoSession save<CR>", desc = "Save current session" },
    { "WR", "<cmd>AutoSession restore<CR>", desc = "Restore last session" },
  },
}

return {
  "windwp/nvim-autopairs",
  event = "InsertEnter",
  opts = {},
}

return {
  "akinsho/bufferline.nvim",
  version = "*",
  event = "VeryLazy",
  dependencies = {
    "nvim-tree/nvim-web-devicons",
    "famiu/bufdelete.nvim",
  },
  keys = {
    { "<S-l>", "<cmd>BufferLineCycleNext<CR>", desc = "Next buffer" },
    { "<S-h>", "<cmd>BufferLineCyclePrev<CR>", desc = "Previous buffer" },
  },
  config = function()
    vim.cmd([[
      function! OpenFileExplorer(_1, _2, _3, _4)
        Neotree toggle
      endfunction
    ]])

    vim.cmd([[
      function! OpenAIChat(_1, _2, _3, _4)
        if exists(':CodeCompanionChat') == 2
          CodeCompanionChat Toggle
        else
          echohl ErrorMsg
          echom 'CodeCompanion requires Neovim 0.11+. Run ~/bin/install-neovim first.'
          echohl None
        endif
      endfunction

      function! OpenBottomTerminal(_1, _2, _3, _4)
        lua toggle_bottom_terminal()
      endfunction
    ]])

    local function open_buffer(bufnr)
      local current_buf = vim.api.nvim_get_current_buf()

      if vim.bo[current_buf].filetype == "neo-tree" then
        local editor_win = require("neo-tree").get_prior_window({
          "codecompanion",
          "codecompanion_input",
          "terminal",
          "toggleterm",
        }, true)

        if editor_win < 0 or not vim.api.nvim_win_is_valid(editor_win) then
          vim.notify("No editor window available", vim.log.levels.WARN)
          return
        end

        vim.api.nvim_set_current_win(editor_win)
      end

      vim.api.nvim_set_current_buf(bufnr)
    end

    require("bufferline").setup({
      options = {
        mode = "buffers",
        themable = true,
        numbers = "none",
        close_command = "Bdelete! %d",
        left_mouse_command = open_buffer,
        right_mouse_command = "Bdelete! %d",
        middle_mouse_command = "Bdelete! %d",
        diagnostics = "nvim_lsp",
        show_buffer_icons = true,
        show_buffer_close_icons = false,
        show_close_icon = false,
        show_tab_indicators = true,
        persist_buffer_sort = true,
        separator_style = "thick",
        always_show_bufferline = true,
        indicator = {
          icon = "",
          style = "icon",
        },
        offsets = {
          {
            filetype = "neo-tree",
            text = " Files",
            highlight = "Directory",
            separator = true,
          },
        },
        custom_areas = {
          left = function()
            return {
              { text = " %@OpenFileExplorer@  %X ", bg = "#5E81AC", fg = "#ECEFF4", gui = "bold" },
              { text = " ", fg = "#5E81AC" },
            }
          end,
          right = function()
            return {
              { text = " ", fg = "#5E81AC" },
              { text = " %@OpenAIChat@ 󰍹 %X ", bg = "#5E81AC", fg = "#ECEFF4", gui = "bold" },
              { text = "", bg = "#5E81AC", fg = "#81A1C1" },
              { text = " %@OpenBottomTerminal@  %X ", bg = "#5E81AC", fg = "#ECEFF4", gui = "bold" },
            }
          end,
        },
      },
      highlights = {
        fill = { fg = "#3B4252", bg = "#3B4252" },
        background = { fg = "#D8DEE9", bg = "#434C5E" },
        tab = { fg = "#D8DEE9", bg = "#434C5E" },
        tab_selected = { fg = "#ECEFF4", bg = "#5E81AC", bold = true, italic = false },
        tab_separator = { fg = "#3B4252", bg = "#4C566A" },
        tab_separator_selected = { fg = "#3B4252", bg = "#5E81AC" },
        buffer_selected = { fg = "#ECEFF4", bg = "#5E81AC", bold = true, italic = false },
        buffer_visible = { fg = "#D8DEE9", bg = "#434C5E" },
        separator = { fg = "#3B4252", bg = "#3B4252" },
        indicator_visible = { fg = "#D8DEE9", bg = "#434C5E" },
        modified = { fg = "#EBCB8B", bg = "#434C5E" },
        modified_visible = { fg = "#EBCB8B", bg = "#434C5E" },
        modified_selected = { fg = "#EBCB8B", bg = "#5E81AC" },
        duplicate_selected = { fg = "#E5E9F0", bg = "#5E81AC", italic = true },
        duplicate_visible = { bg = "#434C5E", italic = true },
        duplicate = { fg = "#D8DEE9", bg = "#434C5E", italic = true },
        error = { fg = "#BF616A", bg = "#434C5E" },
        error_visible = { fg = "#BF616A", bg = "#434C5E" },
        error_selected = { fg = "#ECEFF4", bg = "#5E81AC", bold = true, italic = false },
        warning = { fg = "#EBCB8B", bg = "#434C5E" },
        warning_visible = { fg = "#EBCB8B", bg = "#434C5E" },
        warning_selected = { fg = "#ECEFF4", bg = "#5E81AC", bold = true, italic = false },
        trunc_marker = { fg = "#81A1C1", bg = "#434C5E" },
        offset_separator = { bg = "#2E3440" },
      },
    })
  end,
}

return {
  "olimorris/codecompanion.nvim",
  version = "*",
  enabled = vim.fn.has("nvim-0.11") == 1,
  cmd = {
    "CodeCompanion",
    "CodeCompanionActions",
    "CodeCompanionChat",
    "CodeCompanionCLI",
    "CodeCompanionCodeReview",
  },
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
    {
      "MeanderingProgrammer/render-markdown.nvim",
      ft = { "markdown", "codecompanion" },
      opts = {
        file_types = { "markdown", "codecompanion" },
      },
    },
  },
  init = function()
    vim.api.nvim_create_autocmd("FileType", {
      pattern = { "codecompanion", "codecompanion_input" },
      callback = function()
        vim.schedule(function()
          if _G.keep_bottom_terminal_full_width then
            _G.keep_bottom_terminal_full_width(true)
          end
        end)
      end,
    })
  end,
  keys = {
    { "<F5>", "<cmd>CodeCompanionChat Toggle<CR>", mode = { "n", "i" }, desc = "Toggle AI chat" },
    { "<leader>ai", "<cmd>CodeCompanionChat Toggle<CR>", desc = "Toggle AI chat" },
    { "<leader>aa", "<cmd>CodeCompanionActions<CR>", mode = { "n", "v" }, desc = "AI actions" },
  },
  opts = {
    adapters = {
      acp = {
        extend = {
          codex = {
            defaults = {
              auth_method = "chat-gpt",
            },
          },
        },
      },
    },
    interactions = {
      chat = {
        adapter = "codex",
      },
      cli = {
        agent = "claude_code",
        agents = {
          claude_code = {
            cmd = "claude",
            args = {},
            description = "Claude Code CLI",
            provider = "terminal",
          },
          codex = {
            cmd = "codex",
            args = {},
            description = "OpenAI Codex CLI",
            provider = "terminal",
          },
        },
      },
    },
    display = {
      action_palette = {
        provider = "telescope",
      },
      chat = {
        show_context = false,
        show_header_separator = false,
        window = {
          layout = "vertical",
          position = "right",
          width = 0.4,
        },
        start_in_insert_mode = true,
      },
    },
    opts = {
      language = "Russian",
    },
  },
}

local function format_buffer()
  require("conform").format({ async = true, lsp_fallback = true })
end

return {
  "stevearc/conform.nvim",
  cmd = "ConformInfo",
  keys = {
    { "<leader>f", format_buffer, mode = { "n", "v" }, desc = "Format buffer" },
    { "<S-F3>", format_buffer, mode = { "n", "v" }, desc = "Format buffer" },
    { "<F15>", format_buffer, mode = { "n", "v" }, desc = "Format buffer" },
  },
  opts = {
    notify_on_error = false,
    formatters_by_ft = {
      lua = { "stylua" },
      sh = { "shfmt" },
      bash = { "shfmt" },
      zsh = { "shfmt" },
      python = { "ruff_format", "black" },
      json = { "jq" },
      yaml = { "yamlfmt", "prettier" },
    },
  },
}

return {
  "lewis6991/gitsigns.nvim",
  event = { "BufReadPost", "BufNewFile" },
  opts = {
    signs = {
      add = { text = "+" },
      change = { text = "~" },
      delete = { text = "_" },
      topdelete = { text = "‾" },
      changedelete = { text = "~" },
      untracked = { text = "+" },
    },
    current_line_blame = false,
  },
}

return {
  "lukas-reineke/indent-blankline.nvim",
  main = "ibl",
  event = { "BufReadPost", "BufNewFile" },
  opts = {
    scope = {
      show_start = false,
      show_end = true,
    },
  },
}

return {
  "mfussenegger/nvim-lint",
  event = { "BufReadPost", "BufNewFile" },
  config = function()
    local lint = require("lint")
    local enabled = false

    lint.linters.shellcheck.args = {
      "--format",
      "json1",
      "-",
    }

    local function executable(name)
      return vim.fn.executable(name) == 1
    end

    local function add_linters(target, ft, linters)
      local available = {}

      for _, name in ipairs(linters) do
        if executable(name) then
          table.insert(available, name)
        end
      end

      if #available > 0 then
        target[ft] = available
      end
    end

    local linters_by_ft = {}
    add_linters(linters_by_ft, "lua", { "luacheck" })
    add_linters(linters_by_ft, "sh", { "shellcheck" })
    add_linters(linters_by_ft, "bash", { "shellcheck" })
    add_linters(linters_by_ft, "zsh", { "zsh" })
    add_linters(linters_by_ft, "python", { "ruff", "pylint" })
    add_linters(linters_by_ft, "json", { "jsonlint" })
    add_linters(linters_by_ft, "yaml", { "yamllint" })

    lint.linters_by_ft = linters_by_ft

    local group = vim.api.nvim_create_augroup("UserLint", { clear = true })

    local timers = {}

    local function run_lint(notify_status, bufnr)
      bufnr = bufnr or vim.api.nvim_get_current_buf()
      if not vim.api.nvim_buf_is_valid(bufnr) then
        return
      end

      vim.api.nvim_buf_call(bufnr, function()
        local filetype = vim.bo.filetype
        local linters = lint.linters_by_ft[filetype]

        if not linters or #linters == 0 then
          if notify_status then
            vim.notify(
              "No installed linter configured for filetype: " .. (filetype ~= "" and filetype or "unknown"),
              vim.log.levels.WARN
            )
          end
          return
        end

        lint.try_lint()
        if notify_status then
          vim.notify("Lint started: " .. table.concat(linters, ", "))
        end
      end)
    end

    local function try_lint(bufnr)
      if enabled then
        run_lint(false, bufnr)
      end
    end

    local function try_lint_debounced(bufnr)
      local timer = timers[bufnr]
      if timer then
        timer:stop()
        timer:close()
      end

      timers[bufnr] = vim.defer_fn(function()
        timers[bufnr] = nil
        try_lint(bufnr)
      end, 500)
    end

    vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave", "TextChanged", "TextChangedI" }, {
      group = group,
      callback = function(event)
        try_lint_debounced(event.buf)
      end,
    })

    local initial_buf = vim.api.nvim_get_current_buf()
    vim.schedule(function()
      try_lint(initial_buf)
    end)

    vim.api.nvim_create_user_command("Lint", function()
      run_lint(true)
    end, {})

    local function toggle_linter()
      enabled = not enabled
      if enabled then
        run_lint(false)
      else
        vim.diagnostic.reset(nil, 0)
      end
      vim.notify("Lint " .. (enabled and "enabled" or "disabled"))
    end

    vim.api.nvim_create_user_command("LinterToggle", toggle_linter, {})
    vim.api.nvim_create_user_command("LintToggle", toggle_linter, {})

    vim.keymap.set({ "n", "i" }, "<F7>", function()
      if vim.api.nvim_get_mode().mode:match("^i") then
        vim.cmd.stopinsert()
      end
      enabled = true
      run_lint(true)
    end, { desc = "Enable and run lint" })

    vim.keymap.set({ "n", "i" }, "<S-F7>", function()
      enabled = false
      vim.diagnostic.reset(nil, 0)
      vim.notify("Lint disabled")
    end, { desc = "Disable lint" })

    vim.keymap.set({ "n", "i" }, "<F19>", function()
      enabled = false
      vim.diagnostic.reset(nil, 0)
      vim.notify("Lint disabled")
    end, { desc = "Disable lint" })
  end,
}

return {
  "neovim/nvim-lspconfig",
  enabled = false,
  event = { "BufReadPre", "BufNewFile" },
  config = function()
    local lspconfig = require("lspconfig")
    local capabilities = vim.lsp.protocol.make_client_capabilities()

    -- Flip enabled=true above and add servers here when full LSP is needed.
    lspconfig.lua_ls.setup({ capabilities = capabilities })
    lspconfig.pyright.setup({ capabilities = capabilities })
  end,
}

return {
  "nvim-lualine/lualine.nvim",
  event = "VeryLazy",
  dependencies = { "nvim-tree/nvim-web-devicons" },
  opts = {
    options = {
      theme = {
        normal = {
          a = { fg = "#ECEFF4", bg = "#5E81AC", gui = "bold" },
          b = { fg = "#E5E9F0", bg = "#4C566A" },
          c = { fg = "#D8DEE9", bg = "#3B4252" },
        },
        insert = {
          a = { fg = "#2E3440", bg = "#A3BE8C", gui = "bold" },
          b = { fg = "#E5E9F0", bg = "#4C566A" },
          c = { fg = "#D8DEE9", bg = "#3B4252" },
        },
        visual = {
          a = { fg = "#2E3440", bg = "#B48EAD", gui = "bold" },
          b = { fg = "#E5E9F0", bg = "#4C566A" },
          c = { fg = "#D8DEE9", bg = "#3B4252" },
        },
        replace = {
          a = { fg = "#2E3440", bg = "#EBCB8B", gui = "bold" },
          b = { fg = "#E5E9F0", bg = "#4C566A" },
          c = { fg = "#D8DEE9", bg = "#3B4252" },
        },
        command = {
          a = { fg = "#2E3440", bg = "#88C0D0", gui = "bold" },
          b = { fg = "#E5E9F0", bg = "#4C566A" },
          c = { fg = "#D8DEE9", bg = "#3B4252" },
        },
        inactive = {
          a = { fg = "#D8DEE9", bg = "#3B4252" },
          b = { fg = "#D8DEE9", bg = "#3B4252" },
          c = { fg = "#81A1C1", bg = "#2E3440" },
        },
      },
      component_separators = { left = "", right = "" },
      section_separators = { left = "", right = "" },
      globalstatus = true,
    },
    sections = {
      lualine_a = { "mode" },
      lualine_b = { "branch", "diagnostics" },
      lualine_c = {
        { "filename", path = 1 },
      },
      lualine_x = { "encoding", "fileformat", "filetype" },
      lualine_y = { "progress" },
      lualine_z = { "location" },
    },
    inactive_sections = {
      lualine_a = {},
      lualine_b = {},
      lualine_c = { "filename" },
      lualine_x = { "location" },
      lualine_y = {},
      lualine_z = {},
    },
    extensions = { "neo-tree", "quickfix" },
  },
}

return {
  "nvim-neo-tree/neo-tree.nvim",
  branch = "v3.x",
  cmd = "Neotree",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-tree/nvim-web-devicons",
    "MunifTanjim/nui.nvim",
  },
  keys = {
    { "<F3>", "<cmd>Neotree toggle<CR>", desc = "Toggle Neo-tree" },
  },
  opts = {
    close_if_last_window = true,
    enable_git_status = true,
    event_handlers = {
      {
        event = "neo_tree_window_after_open",
        handler = function()
          local terminal_win = vim.t.toggleterm_restore_win
          vim.t.toggleterm_restore_win = nil

          vim.schedule(function()
            if _G.keep_bottom_terminal_full_width then
              _G.keep_bottom_terminal_full_width(false)
            end

            if type(terminal_win) == "number" and vim.api.nvim_win_is_valid(terminal_win) then
              vim.api.nvim_set_current_win(terminal_win)
              vim.cmd.startinsert()
            end
          end)
        end,
      },
    },
    window = {
      width = 35,
    },
    filesystem = {
      bind_to_cwd = true,
      cwd_target = "window",
      filtered_items = {
        hide_dotfiles = false,
        hide_gitignored = false,
      },
    },
  },
}