path: root/arch/lightvim/.config/lightvim/lua/plugins.lua

local function blink_expand_menu()
    local cfg = require("blink.cmp.config").completion
    cfg.menu.max_height = 10
    cfg.documentation.auto_show = true
    pcall(function()
        require("blink.cmp.completion.windows.menu").update_position()
    end)
end

vim.api.nvim_create_autocmd("User", {
    pattern = "BlinkCmpMenuClose",
    callback = function()
        local ok, cfg = pcall(function() return require("blink.cmp.config").completion end)
        if not ok then return end
        cfg.menu.max_height = 5
        cfg.documentation.auto_show = false
    end,
})

vim.g.rustaceanvim = {
    server = {
        default_settings = {
            ["rust-analyzer"] = {
                cargo = { allFeatures = true },
                check = { command = "clippy" },
                inlayHints = { lifetimeElisionHints = { enable = "skip_trivial" } },
            },
        },
    },
}

return {
    -- === Icons (mocks nvim-web-devicons for fzf-lua / bufferline / oil) ===
    {
        "echasnovski/mini.icons",
        lazy = true,
        init = function()
            package.preload["nvim-web-devicons"] = function()
                require("mini.icons").mock_nvim_web_devicons()
                return package.loaded["nvim-web-devicons"]
            end
        end,
    },

    -- === Motion ===
    {
        url = "https://codeberg.org/andyg/leap.nvim",
        keys = {
            { "s", "<Plug>(leap)", mode = { "n", "x", "o" }, desc = "Leap" },
            { "S", "<Plug>(leap-from-window)", mode = { "n", "o" }, desc = "Leap from window" },
        },
    },

    -- === Editing ===
    {
        "windwp/nvim-autopairs",
        event = "InsertEnter",
        opts = { check_ts = true },
    },
    {
        "kevinhwang91/nvim-ufo",
        dependencies = { "kevinhwang91/promise-async" },
        event = "BufReadPost",
        keys = {
            { "zR", function() require("ufo").openAllFolds() end,  desc = "Open all folds" },
            { "zM", function() require("ufo").closeAllFolds() end, desc = "Close all folds" },
        },
        opts = {
            provider_selector = function()
                return { "treesitter", "indent" }
            end,
        },
    },
    {
        "kylechui/nvim-surround",
        version = "*",
        event = "VeryLazy",
        init = function()
            vim.g.nvim_surround_no_insert_mappings = true
            vim.g.nvim_surround_no_normal_mappings = true
            vim.g.nvim_surround_no_visual_mappings = true
        end,
        config = function()
            require("nvim-surround").setup({})
            local map = vim.keymap.set
            map("i", "<C-g>z", "<Plug>(nvim-surround-insert)",          { desc = "Surround (insert)" })
            map("i", "<C-g>Z", "<Plug>(nvim-surround-insert-line)",     { desc = "Surround line (insert)" })
            map("n", "gza",    "<Plug>(nvim-surround-normal)",          { desc = "Add surround" })
            map("n", "gzaa",   "<Plug>(nvim-surround-normal-cur)",      { desc = "Add surround (curline)" })
            map("n", "gzA",    "<Plug>(nvim-surround-normal-line)",     { desc = "Add surround (linewise)" })
            map("n", "gzAA",   "<Plug>(nvim-surround-normal-cur-line)", { desc = "Add surround line (cur)" })
            map("n", "gzd",    "<Plug>(nvim-surround-delete)",          { desc = "Delete surround" })
            map("n", "gzc",    "<Plug>(nvim-surround-change)",          { desc = "Change surround" })
            map("n", "gzC",    "<Plug>(nvim-surround-change-line)",     { desc = "Change surround (linewise)" })
            map("x", "gz",     "<Plug>(nvim-surround-visual)",          { desc = "Surround selection" })
            map("x", "gZ",     "<Plug>(nvim-surround-visual-line)",     { desc = "Surround selection (linewise)" })
        end,
    },
    {
        "jake-stewart/multicursor.nvim",
        event = "VeryLazy",
        config = function()
            local mc = require("multicursor-nvim")
            mc.setup()
            local set = vim.keymap.set
            local nv = { "n", "v" }

            -- Adding cursors (Alt+Shift+arrow — Ctrl+Shift+arrow is move-line)
            set(nv, "<M-S-Down>",  function() mc.lineAddCursor(1) end,  { desc = "Add cursor down" })
            set(nv, "<M-S-Up>",    function() mc.lineAddCursor(-1) end, { desc = "Add cursor up" })

            -- Skipping (advance without dropping a cursor)
            set(nv, "<leader>m<Down>", function() mc.lineSkipCursor(1) end,  { desc = "Skip line down" })
            set(nv, "<leader>m<Up>",   function() mc.lineSkipCursor(-1) end, { desc = "Skip line up" })

            -- Match-based add / skip
            set(nv, "<leader>mn",  function() mc.matchAddCursor(1) end,  { desc = "Add cursor: next match" })
            set(nv, "<leader>mp",  function() mc.matchAddCursor(-1) end, { desc = "Add cursor: prev match" })
            set(nv, "<leader>ms",  function() mc.matchSkipCursor(1) end, { desc = "Skip match, advance" })
            set(nv, "<leader>mA",  mc.matchAllAddCursors,                { desc = "Cursors for all matches" })

            -- Repeat keys: ;/, add or skip when cursors active; default f/F/t/T otherwise
            set("n", ";", function()
                if mc.hasCursors() then mc.matchAddCursor(1) else vim.cmd("normal! ;") end
            end, { desc = "Repeat f/F/t/T  ·  next-match cursor when active" })
            set("n", ",", function()
                if mc.hasCursors() then mc.matchSkipCursor(1) else vim.cmd("normal! ,") end
            end, { desc = "Reverse f/F/t/T  ·  skip-match when active" })

            -- Manual toggle / delete
            set(nv, "<leader>mt",  mc.toggleCursor,                      { desc = "Toggle cursor here" })
            set(nv, "<leader>mx",  mc.deleteCursor,                      { desc = "Delete cursor under main" })

            -- Rotate / jump main focus through cursor list (arrows)
            set(nv, "<leader>m<Right>", mc.nextCursor,                   { desc = "Rotate to next cursor" })
            set(nv, "<leader>m<Left>",  mc.prevCursor,                   { desc = "Rotate to prev cursor" })
            set(nv, "<leader>mF",       mc.firstCursor,                  { desc = "Jump to first cursor" })
            set(nv, "<leader>mL",       mc.lastCursor,                   { desc = "Jump to last cursor" })

            -- Bulk ops
            set(nv, "<leader>m=",  mc.alignCursors,                     { desc = "Align cursors" })
            set(nv, "<leader>mu",  mc.restoreCursors,                   { desc = "Restore last cursors" })
            set(nv, "<leader>md",  function()
                if mc.cursorsEnabled() then mc.disableCursors() else mc.enableCursors() end
            end, { desc = "Freeze/unfreeze cursors" })
            set(nv, "<leader>m.",  function() mc.transposeCursors(1) end,  { desc = "Transpose forward" })
            set(nv, "<leader>m,",  function() mc.transposeCursors(-1) end, { desc = "Transpose back" })

            -- Pattern-based (visual mode — needs a selection)
            set("x", "<leader>m/", mc.matchCursors,                     { desc = "Cursors at regex matches" })
            set("x", "<leader>mS", mc.splitCursors,                     { desc = "Split selection by pattern" })

            -- Esc: re-enable / clear / nohlsearch
            set("n", "<esc>", function()
                if not mc.cursorsEnabled() then
                    mc.enableCursors()
                elseif mc.hasCursors() then
                    mc.clearCursors()
                else
                    vim.cmd("nohlsearch")
                end
            end)
        end,
    },

    -- === Treesitter (main branch, nvim 0.11+ API) ===
    {
        "nvim-treesitter/nvim-treesitter",
        branch = "main",
        lazy = false,
        build = ":TSUpdate",
        dependencies = {
            { "nvim-treesitter/nvim-treesitter-textobjects", branch = "main" },
        },
        config = function()
            require("nvim-treesitter").setup({})

            local parsers = {
                "c", "cpp", "python", "lua", "haskell", "rust", "odin",
                "vim", "vimdoc", "query", "bash", "diff",
                "markdown", "markdown_inline", "json", "toml", "yaml",
            }
            require("nvim-treesitter").install(parsers)

            vim.api.nvim_create_autocmd("FileType", {
                callback = function(args)
                    local lang = vim.treesitter.language.get_lang(vim.bo[args.buf].filetype)
                    if lang and vim.treesitter.language.add(lang) then
                        pcall(vim.treesitter.start, args.buf, lang)
                        vim.bo[args.buf].indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"
                    end
                end,
            })

            -- Textobjects ---------------------------------------------------
            local ok_to, to = pcall(require, "nvim-treesitter-textobjects")
            if not ok_to then return end
            to.setup({
                select = { lookahead = true },
                move = { set_jumps = true },
            })
            local sel  = require("nvim-treesitter-textobjects.select")
            local move = require("nvim-treesitter-textobjects.move")
            local swap = require("nvim-treesitter-textobjects.swap")
            local map  = vim.keymap.set

            local objs = {
                { "af", "@function.outer",    "around function" },
                { "if", "@function.inner",    "inside function" },
                { "ac", "@class.outer",       "around class" },
                { "ic", "@class.inner",       "inside class" },
                { "aa", "@parameter.outer",   "around argument" },
                { "ia", "@parameter.inner",   "inside argument" },
                { "ab", "@block.outer",       "around block" },
                { "ib", "@block.inner",       "inside block" },
                { "ai", "@conditional.outer", "around conditional" },
                { "ii", "@conditional.inner", "inside conditional" },
                { "al", "@loop.outer",        "around loop" },
                { "il", "@loop.inner",        "inside loop" },
            }
            for _, o in ipairs(objs) do
                local lhs, q, d = o[1], o[2], o[3]
                map({ "x", "o" }, lhs, function() sel.select_textobject(q, "textobjects") end, { desc = d })
            end

            local nmo = { "n", "x", "o" }
            map(nmo, "]m", function() move.goto_next_start("@function.outer", "textobjects") end,     { desc = "next func start" })
            map(nmo, "[m", function() move.goto_previous_start("@function.outer", "textobjects") end, { desc = "prev func start" })
            map(nmo, "]M", function() move.goto_next_end("@function.outer", "textobjects") end,       { desc = "next func end" })
            map(nmo, "[M", function() move.goto_previous_end("@function.outer", "textobjects") end,   { desc = "prev func end" })
            map(nmo, "]]", function() move.goto_next_start("@class.outer", "textobjects") end,        { desc = "next class start" })
            map(nmo, "[[", function() move.goto_previous_start("@class.outer", "textobjects") end,    { desc = "prev class start" })
            map(nmo, "][", function() move.goto_next_end("@class.outer", "textobjects") end,          { desc = "next class end" })
            map(nmo, "[]", function() move.goto_previous_end("@class.outer", "textobjects") end,      { desc = "prev class end" })

            map("n", "<leader>a", function() swap.swap_next("@parameter.inner") end,      { desc = "Swap arg with next" })
            map("n", "<leader>A", function() swap.swap_previous("@parameter.inner") end,  { desc = "Swap arg with prev" })
        end,
    },

    -- === UI ===
    {
        "nvim-lualine/lualine.nvim",
        event = "VeryLazy",
        opts = function()
            local habamax = {
                normal = {
                    a = { fg = "#1c1c1c", bg = "#bcbcbc", gui = "bold" },
                    b = { fg = "#bcbcbc", bg = "#3a3a3a" },
                    c = { fg = "#8a8a8a", bg = "#1c1c1c" },
                },
                insert   = { a = { fg = "#1c1c1c", bg = "#87afaf", gui = "bold" } },
                visual   = { a = { fg = "#1c1c1c", bg = "#d7afaf", gui = "bold" } },
                replace  = { a = { fg = "#1c1c1c", bg = "#ff8787", gui = "bold" } },
                command  = { a = { fg = "#1c1c1c", bg = "#d7d787", gui = "bold" } },
                inactive = {
                    a = { fg = "#8a8a8a", bg = "#1c1c1c" },
                    b = { fg = "#8a8a8a", bg = "#1c1c1c" },
                    c = { fg = "#585858", bg = "#1c1c1c" },
                },
            }
            return {
                options = {
                    theme = habamax,
                    globalstatus = true,
                    component_separators = { left = "|", right = "|" },
                    section_separators = { left = "", right = "" },
                },
                sections = {
                    lualine_a = { "mode" },
                    lualine_b = { "branch", "diff", "diagnostics" },
                    lualine_c = { { "filename", path = 1 } },
                    lualine_x = { "encoding", "filetype" },
                    lualine_y = { "progress" },
                    lualine_z = { "location" },
                },
            }
        end,
    },
    {
        "akinsho/bufferline.nvim",
        version = "*",
        event = "VeryLazy",
        keys = {
            { "<leader>bp", "<cmd>BufferLinePick<CR>",         desc = "Pick buffer" },
            { "<leader>bo", "<cmd>BufferLineCloseOthers<CR>",  desc = "Close others" },
            { "<leader>bc", "<cmd>BufferLinePickClose<CR>",    desc = "Close (pick)" },
        },
        opts = {
            options = {
                mode = "buffers",
                show_buffer_close_icons = false,
                show_close_icon = false,
                separator_style = "thin",
                always_show_bufferline = false,
                diagnostics = "nvim_lsp",
            },
        },
    },
    {
        "lewis6991/gitsigns.nvim",
        event = { "BufReadPre", "BufNewFile" },
        opts = {
            signs = {
                add          = { text = "▎" },
                change       = { text = "▎" },
                delete       = { text = "" },
                topdelete    = { text = "" },
                changedelete = { text = "▎" },
            },
        },
    },
    {
        "folke/snacks.nvim",
        priority = 1000,
        lazy = false,
        opts = {
            dashboard = {
                sections = {
                    { section = "header" },
                    { section = "keys", gap = 1, padding = 1 },
                    { section = "startup" },
                },
            },
        },
    },
    {
        "mbbill/undotree",
        keys = {
            { "<leader>u", "<cmd>UndotreeToggle<CR>", desc = "Undo tree" },
        },
    },
    {
        "stevearc/oil.nvim",
        lazy = false,
        keys = {
            { "<leader>e", "<cmd>Oil<CR>", desc = "File explorer" },
            { "-",         "<cmd>Oil<CR>", desc = "Open parent dir" },
        },
        opts = {
            default_file_explorer = true,
            view_options = { show_hidden = true },
            constrain_cursor = false,
        },
    },

    -- === Picker (fzf-lua) ===
    {
        "ibhagwan/fzf-lua",
        cmd = "FzfLua",
        keys = {
            { "<leader>ff", "<cmd>FzfLua files<CR>",               desc = "Find files" },
            { "<leader>fg", "<cmd>FzfLua live_grep<CR>",           desc = "Live grep" },
            { "<leader>fb", "<cmd>FzfLua buffers<CR>",             desc = "Buffers" },
            { "<leader>fs", "<cmd>FzfLua grep_cword<CR>",          desc = "Grep word under cursor" },
            { "<leader>fr", "<cmd>FzfLua oldfiles<CR>",            desc = "Recent files" },
            { "<leader>fc", "<cmd>FzfLua commands<CR>",            desc = "Commands" },
            { "<leader>fd", "<cmd>FzfLua diagnostics_document<CR>",desc = "Document diagnostics" },
            { "<leader>/",  "<cmd>FzfLua blines<CR>",              desc = "Search current buffer" },
        },
        opts = {
            winopts = {
                height = 0.6,
                width = 0.8,
                border = "single",
                preview = { border = "single" },
            },
            fzf_opts = { ["--cycle"] = true },
            grep = {
                rg_opts = "--hidden --follow --glob '!.git' --column --line-number --no-heading --color=always",
            },
            files = {
                rg_opts = "--files --hidden --follow --glob '!.git'",
            },
            lsp = { code_actions = { previewer = "codeaction_native" } },
        },
        config = function(_, opts)
            require("fzf-lua").setup(opts)
            require("fzf-lua").register_ui_select()
        end,
    },

    -- === Code actions preview ===
    {
        "aznhe21/actions-preview.nvim",
        keys = {
            {
                "<leader>ca",
                function() require("actions-preview").code_actions() end,
                mode = { "n", "v" },
                desc = "Code action",
            },
        },
    },

    -- === Navigation (tmux) ===
    {
        "christoomey/vim-tmux-navigator",
        cmd = {
            "TmuxNavigateLeft",  "TmuxNavigateDown",
            "TmuxNavigateUp",    "TmuxNavigateRight",
        },
        keys = {
            { "<C-Left>",  "<cmd>TmuxNavigateLeft<CR>",  desc = "Pane left",  mode = { "n", "t" } },
            { "<C-Down>",  "<cmd>TmuxNavigateDown<CR>",  desc = "Pane down",  mode = { "n", "t" } },
            { "<C-Up>",    "<cmd>TmuxNavigateUp<CR>",    desc = "Pane up",    mode = { "n", "t" } },
            { "<C-Right>", "<cmd>TmuxNavigateRight<CR>", desc = "Pane right", mode = { "n", "t" } },
        },
        init = function()
            vim.g.tmux_navigator_no_mappings = 1
        end,
    },

    -- === Which-key ===
    {
        "folke/which-key.nvim",
        event = "VeryLazy",
        opts = {
            icons = { mappings = false },
            delay = 300,
            spec = {
                { "<leader>f",  group = "find" },
                { "<leader>b",  group = "buffer" },
                { "<leader>s",  group = "split" },
                { "<leader>r",  group = "refactor" },
                { "<leader>c",  group = "code" },
                { "<leader>m",  group = "multicursor" },
                { "<leader>cF", desc  = "Toggle autoformat" },
                { "<leader>cf", desc  = "Format buffer" },
                { "<leader>e",  desc  = "File explorer" },
                { "<leader>u",  desc  = "Undo tree" },
                { "<leader>bp", desc  = "Pick buffer" },
                { "<leader>bo", desc  = "Close others" },
                { "<leader>bc", desc  = "Close (pick)" },
            },
        },
        keys = {
            { "<leader>?", function() require("which-key").show({ global = false }) end, desc = "Buffer keymaps" },
        },
    },

    -- === Completion / snippets ===
    {
        "saghen/blink.cmp",
        version = "*",
        dependencies = { "L3MON4D3/LuaSnip", "rafamadriz/friendly-snippets" },
        opts = {
            keymap = {
                preset = "none",
                ["<C-Space>"] = { "show", "show_documentation", "hide_documentation" },
                ["<C-e>"]     = { "hide" },
                ["<CR>"]      = { "accept", "fallback" },
                ["<Tab>"]     = { blink_expand_menu, "select_next", "fallback" },
                ["<S-Tab>"]   = { "select_prev", "fallback" },
                ["<C-b>"]     = { "scroll_documentation_up", "fallback" },
                ["<C-f>"]     = { "scroll_documentation_down", "fallback" },
                ["<C-n>"]     = { "select_next", "fallback" },
                ["<C-p>"]     = { "select_prev", "fallback" },
                ["<C-k>"]     = { "snippet_forward", "fallback" },
                ["<C-j>"]     = { "snippet_backward", "fallback" },
            },
            appearance = { nerd_font_variant = "mono" },
            sources = { default = { "lsp", "path", "snippets", "buffer" } },
            snippets = { preset = "luasnip" },
            completion = {
                documentation = { auto_show = false, auto_show_delay_ms = 200 },
                ghost_text = { enabled = false },
                menu = { auto_show = true, max_height = 5 },
            },
        },
    },
    {
        "L3MON4D3/LuaSnip",
        event = "InsertEnter",
        dependencies = { "rafamadriz/friendly-snippets" },
        config = function()
            require("luasnip.loaders.from_vscode").lazy_load()
        end,
    },

    -- === Formatting ===
    {
        "stevearc/conform.nvim",
        event = "BufWritePre",
        cmd = { "ConformInfo", "FormatToggle" },
        keys = {
            {
                "<leader>cF",
                function()
                    vim.g.format_on_save = not vim.g.format_on_save
                    vim.notify(
                        "Format on save: " .. (vim.g.format_on_save and "enabled" or "disabled"),
                        vim.log.levels.INFO,
                        { title = "conform" }
                    )
                end,
                desc = "Toggle autoformat",
            },
            {
                "<leader>cf",
                function()
                    require("conform").format({ async = true, lsp_fallback = true })
                end,
                desc = "Format buffer",
            },
        },
        config = function()
            vim.g.format_on_save = true
            require("conform").setup({
                formatters_by_ft = {
                    c       = { "clang_format" },
                    cpp     = { "clang_format" },
                    python  = { "isort", "black" },
                    lua     = { "stylua" },
                    haskell = { "ormolu" },
                    odin    = { "odinfmt" },
                    rust    = { "rustfmt" },
                },
                format_on_save = function(bufnr)
                    if not vim.g.format_on_save then return end
                    if vim.g.disable_autoformat_buf and vim.g.disable_autoformat_buf[bufnr] then return end
                    return { timeout_ms = 500, lsp_fallback = true }
                end,
            })
            require("conform").formatters.clang_format = {
                prepend_args = { "--style={IndentWidth: 4, TabWidth: 4, UseTab: Never}" },
            }
        end,
    },

    -- === Linting ===
    {
        "mfussenegger/nvim-lint",
        event = { "BufReadPost", "BufWritePost", "InsertLeave" },
        config = function()
            require("lint").linters_by_ft = {
                c      = { "cppcheck" },
                cpp    = { "cppcheck" },
                python = { "ruff" },
            }
            vim.api.nvim_create_autocmd({ "BufWritePost", "BufReadPost", "InsertLeave" }, {
                callback = function() require("lint").try_lint() end,
            })
        end,
    },

    -- === Mason (installer only) ===
    {
        "williamboman/mason.nvim",
        cmd = { "Mason", "MasonInstall", "MasonUninstall", "MasonUpdate", "MasonLog" },
        opts = {},
    },

    -- === LSP ===
    {
        "neovim/nvim-lspconfig",
        event = { "BufReadPre", "BufNewFile" },
        dependencies = {
            "saghen/blink.cmp",
            {
                "folke/lazydev.nvim",
                ft = "lua",
                opts = { library = { { path = "luvit-meta/library", words = { "vim%.uv" } } } },
            },
        },
        config = function()
            vim.lsp.config("*", {
                capabilities = require("blink.cmp").get_lsp_capabilities(),
            })

            vim.lsp.enable({ "clangd", "pyright", "lua_ls", "hls", "ols" })

            vim.api.nvim_create_autocmd("LspAttach", {
                callback = function(ev)
                    local map = function(keys, func, desc)
                        vim.keymap.set("n", keys, func, { buffer = ev.buf, desc = "LSP: " .. desc })
                    end
                    if vim.lsp.inlay_hint then
                        vim.lsp.inlay_hint.enable(true, { bufnr = ev.buf })
                    end
                    map("gd", vim.lsp.buf.definition,      "Goto definition")
                    map("gD", vim.lsp.buf.declaration,     "Goto declaration")
                    map("gr", vim.lsp.buf.references,      "Goto references")
                    map("gI", vim.lsp.buf.implementation,  "Goto implementation")
                    map("K",  vim.lsp.buf.hover,           "Hover docs")
                    map("<leader>rn", vim.lsp.buf.rename,  "Rename")
                    map("[d", vim.diagnostic.goto_prev,    "Prev diagnostic")
                    map("]d", vim.diagnostic.goto_next,    "Next diagnostic")
                    map("<leader>e", vim.diagnostic.open_float, "Show diagnostic")
                end,
            })

            vim.diagnostic.config({
                virtual_text = true,
                signs = {
                    text = {
                        [vim.diagnostic.severity.ERROR] = "",
                        [vim.diagnostic.severity.WARN]  = "",
                        [vim.diagnostic.severity.INFO]  = "",
                        [vim.diagnostic.severity.HINT]  = "",
                    },
                },
                underline = true,
                update_in_insert = false,
            })
        end,
    },
    {
        "j-hui/fidget.nvim",
        event = "LspAttach",
        opts = { notification = { window = { winblend = 0 } } },
    },
    {
        "mrcjkb/rustaceanvim",
        version = "^9",
        lazy = false,
    },
}