init.lua

-- Neovim configuration with Zig, Rust, Go, and Python LSP support

-- Bootstrap lazy.nvim plugin manager
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

-- Basic settings
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.expandtab = true
vim.opt.shiftwidth = 4
vim.opt.tabstop = 4
vim.opt.smartindent = true
vim.opt.wrap = false
vim.opt.swapfile = false
vim.opt.backup = false
vim.opt.hlsearch = false
vim.opt.incsearch = true
vim.opt.termguicolors = true
vim.opt.scrolloff = 8
vim.opt.signcolumn = "yes"
vim.opt.updatetime = 50
vim.opt.colorcolumn = "100"

-- Clipboard configuration (macOS uses pbcopy/pbpaste by default)
-- Uncomment below for Wayland/Crostini if needed
-- vim.g.clipboard = {
--   name = 'WaylandClipboard',
--   copy = {
--     ['+'] = 'wl-copy',
--     ['*'] = 'wl-copy',
--   },
--   paste = {
--     ['+'] = 'wl-paste --no-newline',
--     ['*'] = 'wl-paste --no-newline',
--   },
--   cache_enabled = 0,
-- }

-- Set leader key
vim.g.mapleader = " "
vim.g.maplocalleader = " "

-- Plugin setup
require("lazy").setup({
  -- Which-key: shows available keymaps as you type
  {
    "folke/which-key.nvim",
    event = "VeryLazy",
    config = function()
      local wk = require("which-key")
      wk.setup({
        preset = "helix",
        delay = 200,  -- Show quickly
        icons = { mappings = false },
        win = {
          border = "rounded",
          padding = { 1, 2 },
          title = true,
          title_pos = "center",
        },
        -- Show pressed keys in cmdline
        show_keys = true,
        -- Don't hide immediately after key press
        triggers = {
          { "<auto>", mode = "nxso" },
        },
      })

      -- Learning mode: show which-key and echo pressed keys
      local learning_mode = false
      vim.api.nvim_create_user_command("LearnKeys", function()
        learning_mode = not learning_mode
        if learning_mode then
          vim.o.showcmd = true
          vim.o.showcmdloc = "statusline"
          wk.setup({ delay = 0 })  -- Show immediately
          vim.notify("Learning mode ON - which-key shows immediately", vim.log.levels.INFO)
        else
          wk.setup({ delay = 200 })
          vim.notify("Learning mode OFF", vim.log.levels.INFO)
        end
      end, { desc = "Toggle key learning mode" })

      vim.keymap.set("n", "<leader>L", "<cmd>LearnKeys<cr>", { desc = "Help: Toggle learning mode" })

      -- Show which-key popup in visual mode
      vim.keymap.set("v", "<leader>", function()
        wk.show({ mode = "v", keys = "<leader>" })
      end, { desc = "Show visual mode keymaps" })

      -- Toggle which-key popup manually (works in any mode)
      vim.keymap.set({ "n", "v" }, "<C-/>", function()
        local mode = vim.fn.mode()
        if mode == "v" or mode == "V" or mode == "\22" then  -- visual modes
          wk.show({ mode = "v", keys = "" })
        else
          wk.show({ mode = "n", keys = "" })
        end
      end, { desc = "Help: Show all keymaps" })

      -- Contextual keymap helper (mode & filetype aware)
      local helper_win = nil
      local helper_buf = nil
      local helper_active = false

      local function close_helper()
        if helper_win and vim.api.nvim_win_is_valid(helper_win) then
          vim.api.nvim_win_close(helper_win, true)
        end
        helper_win = nil
        helper_buf = nil
        helper_active = false
      end

      local function update_helper()
        if not helper_active then return end

        local mode = vim.fn.mode()
        local ft = vim.bo.filetype
        local mode_name = ({ n = "NORMAL", v = "VISUAL", V = "V-LINE", ["\22"] = "V-BLOCK", i = "INSERT" })[mode] or mode:upper()

        -- Determine which keymaps to show based on mode
        local keymap_mode = "n"
        if mode == "v" or mode == "V" or mode == "\22" then
          keymap_mode = "v"
        end

        -- Filetype to category mapping
        local ft_categories = {
          python = { "Python" },
          go = { "Go" },
          rust = { "Rust" },
          zig = { "Zig" },
          markdown = { "Markdown", "Media", "Writing" },
        }
        local relevant_cats = ft_categories[ft] or {}

        -- Collect keymaps
        local lines = {
          "┌─ " .. mode_name .. " │ " .. (ft ~= "" and ft or "no ft") .. " ─┐",
          "",
        }

        local categories = {}

        -- Global keymaps
        for _, m in ipairs(vim.api.nvim_get_keymap(keymap_mode)) do
          if m.desc and m.lhs:match("^ ") then
            local cat = m.desc:match("^([^:]+):") or "Other"
            categories[cat] = categories[cat] or {}
            local key = m.lhs:gsub(" ", "␣")
            table.insert(categories[cat], key .. " → " .. m.desc:gsub("^[^:]+: ", ""))
          end
        end

        -- Buffer-local keymaps
        for _, m in ipairs(vim.api.nvim_buf_get_keymap(0, keymap_mode)) do
          if m.desc and m.lhs:match("^ ") then
            local cat = m.desc:match("^([^:]+):") or "Buffer"
            categories[cat] = categories[cat] or {}
            local key = m.lhs:gsub(" ", "␣")
            table.insert(categories[cat], key .. " → " .. m.desc:gsub("^[^:]+: ", "") .. " ⋆")
          end
        end

        -- Show relevant categories first, then others
        local shown = {}
        for _, cat in ipairs(relevant_cats) do
          if categories[cat] then
            table.insert(lines, "▸ " .. cat)
            for _, m in ipairs(categories[cat]) do
              table.insert(lines, "  " .. m)
            end
            table.insert(lines, "")
            shown[cat] = true
          end
        end

        -- Show other categories
        for cat, maps in pairs(categories) do
          if not shown[cat] then
            table.insert(lines, "▸ " .. cat)
            for _, m in ipairs(maps) do
              table.insert(lines, "  " .. m)
            end
            table.insert(lines, "")
          end
        end

        table.insert(lines, "")
        table.insert(lines, "␣K to close │ ⋆ = buffer-local")

        -- Update or create buffer
        if not helper_buf or not vim.api.nvim_buf_is_valid(helper_buf) then
          helper_buf = vim.api.nvim_create_buf(false, true)
        end
        vim.api.nvim_buf_set_option(helper_buf, "modifiable", true)
        vim.api.nvim_buf_set_lines(helper_buf, 0, -1, false, lines)
        vim.api.nvim_buf_set_option(helper_buf, "modifiable", false)

        -- Create or update window
        local width = 42
        local height = math.min(#lines, vim.o.lines - 4)

        if not helper_win or not vim.api.nvim_win_is_valid(helper_win) then
          helper_win = vim.api.nvim_open_win(helper_buf, false, {
            relative = "editor",
            row = 1,
            col = vim.o.columns - width - 2,
            width = width,
            height = height,
            style = "minimal",
            border = "rounded",
            title = " Keys ",
            title_pos = "center",
          })
          vim.api.nvim_win_set_option(helper_win, "winblend", 15)
          vim.api.nvim_win_set_option(helper_win, "winhighlight", "Normal:NormalFloat")
        else
          vim.api.nvim_win_set_config(helper_win, { height = height })
        end
      end

      local function toggle_helper()
        if helper_active then
          close_helper()
        else
          helper_active = true
          update_helper()
          -- Auto-update on mode/buffer change
          local group = vim.api.nvim_create_augroup("KeymapHelper", { clear = true })
          vim.api.nvim_create_autocmd({ "ModeChanged", "BufEnter", "FileType" }, {
            group = group,
            callback = function()
              vim.defer_fn(update_helper, 50)
            end,
          })
        end
      end

      vim.api.nvim_create_user_command("KeymapHelper", toggle_helper, { desc = "Toggle contextual keymap helper" })
      vim.keymap.set({ "n", "v" }, "<leader>K", toggle_helper, { desc = "Help: Toggle keymap helper" })

      -- Auto-generate group names from "Category: action" description pattern
      -- This runs after all plugins load, so it sees all keymaps
      vim.api.nvim_create_autocmd("User", {
        pattern = "VeryLazy",
        callback = function()
          local groups = {}
          for _, map in ipairs(vim.api.nvim_get_keymap("n")) do
            if map.desc and map.lhs:match("^ ") then  -- leader maps start with space
              local prefix = map.lhs:sub(1, 2)  -- e.g. " p" for <leader>p
              if not groups[prefix] and #map.lhs > 2 then
                -- Extract group name from "Category: action" pattern
                local group_name = map.desc:match("^([^:]+):")
                if group_name then
                  groups[prefix] = group_name
                end
              end
            end
          end

          -- Register groups with which-key
          local spec = {}
          for prefix, name in pairs(groups) do
            table.insert(spec, { "<leader>" .. prefix:sub(2), group = name })
          end
          if #spec > 0 then
            wk.add(spec)
          end
        end,
      })

      -- Show all keymaps with Telescope
      vim.keymap.set("n", "<leader>?", "<cmd>Telescope keymaps<cr>", { desc = "Help: Search keymaps" })

      -- AI-powered vim tutor
      vim.api.nvim_create_user_command("Tutor", function()
        -- Gather all keymaps with descriptions
        local lines = {
          "# Neovim Keymaps Reference",
          "",
          "Ask me anything about these keymaps or how to do something in Neovim!",
          "",
          "## Leader Keymaps (<Space> is leader)",
          "",
        }

        -- Collect and sort keymaps by category
        local categories = {}
        for _, map in ipairs(vim.api.nvim_get_keymap("n")) do
          if map.desc and map.lhs:match("^ ") then
            local cat = map.desc:match("^([^:]+):") or "Other"
            categories[cat] = categories[cat] or {}
            local key = map.lhs:gsub(" ", "<leader>")
            table.insert(categories[cat], "- `" .. key .. "` — " .. map.desc)
          end
        end

        -- Add visual mode keymaps
        for _, map in ipairs(vim.api.nvim_get_keymap("v")) do
          if map.desc and map.lhs:match("^ ") then
            local cat = map.desc:match("^([^:]+):") or "Other"
            categories[cat] = categories[cat] or {}
            local key = map.lhs:gsub(" ", "<leader>")
            table.insert(categories[cat], "- `" .. key .. "` (visual) — " .. map.desc)
          end
        end

        -- Format by category
        for cat, maps in pairs(categories) do
          table.insert(lines, "### " .. cat)
          for _, m in ipairs(maps) do
            table.insert(lines, m)
          end
          table.insert(lines, "")
        end

        -- Add comprehensive vim movements
        table.insert(lines, "## Movements")
        table.insert(lines, "")
        table.insert(lines, "### Basic Motion")
        table.insert(lines, "- `h/j/k/l` — left/down/up/right")
        table.insert(lines, "- `w/W` — word/WORD forward")
        table.insert(lines, "- `b/B` — word/WORD backward")
        table.insert(lines, "- `e/E` — end of word/WORD")
        table.insert(lines, "- `0/$` — start/end of line")
        table.insert(lines, "- `^` — first non-blank char")
        table.insert(lines, "")
        table.insert(lines, "### Find on Line")
        table.insert(lines, "- `f{char}` — find char forward")
        table.insert(lines, "- `F{char}` — find char backward")
        table.insert(lines, "- `t{char}` — till char forward")
        table.insert(lines, "- `T{char}` — till char backward")
        table.insert(lines, "- `;/,` — repeat find forward/backward")
        table.insert(lines, "")
        table.insert(lines, "### Jumping")
        table.insert(lines, "- `gg/G` — top/bottom of file")
        table.insert(lines, "- `{num}G` — go to line number")
        table.insert(lines, "- `{/}` — paragraph up/down")
        table.insert(lines, "- `%` — matching bracket")
        table.insert(lines, "- `<C-o>/<C-i>` — jump list back/forward")
        table.insert(lines, "- `<C-d>/<C-u>` — half page down/up")
        table.insert(lines, "- `zz/zt/zb` — center/top/bottom cursor")
        table.insert(lines, "")
        table.insert(lines, "### Search")
        table.insert(lines, "- `/{pattern}` — search forward")
        table.insert(lines, "- `?{pattern}` — search backward")
        table.insert(lines, "- `n/N` — next/previous match")
        table.insert(lines, "- `*/#` — search word under cursor")
        table.insert(lines, "- `gd` — go to definition (LSP)")
        table.insert(lines, "")
        table.insert(lines, "## Text Objects")
        table.insert(lines, "")
        table.insert(lines, "Use with operators: `d`(delete), `c`(change), `y`(yank), `v`(visual)")
        table.insert(lines, "")
        table.insert(lines, "### Inner (i) vs Around (a)")
        table.insert(lines, "- `iw/aw` — inner/around word")
        table.insert(lines, "- `is/as` — inner/around sentence")
        table.insert(lines, "- `ip/ap` — inner/around paragraph")
        table.insert(lines, "")
        table.insert(lines, "### Delimiters")
        table.insert(lines, "- `i\"/a\"` — inside/around double quotes")
        table.insert(lines, "- `i'/a'` — inside/around single quotes")
        table.insert(lines, "- `i)/a)` or `ib/ab` — inside/around parens")
        table.insert(lines, "- `i]/a]` — inside/around brackets")
        table.insert(lines, "- `i}/a}` or `iB/aB` — inside/around braces")
        table.insert(lines, "- `i>/a>` — inside/around angle brackets")
        table.insert(lines, "- `it/at` — inside/around HTML tags")
        table.insert(lines, "")
        table.insert(lines, "## Efficient Editing Patterns")
        table.insert(lines, "")
        table.insert(lines, "### Common Combos")
        table.insert(lines, "- `ciw` — change word under cursor")
        table.insert(lines, "- `ci\"` — change inside quotes")
        table.insert(lines, "- `ca)` — change around parentheses")
        table.insert(lines, "- `dap` — delete paragraph")
        table.insert(lines, "- `yiw` — yank word")
        table.insert(lines, "- `vi{` — select inside braces")
        table.insert(lines, "")
        table.insert(lines, "### Repeat & Undo")
        table.insert(lines, "- `.` — repeat last change")
        table.insert(lines, "- `u/<C-r>` — undo/redo")
        table.insert(lines, "- `@:` — repeat last command")
        table.insert(lines, "")
        table.insert(lines, "### Registers")
        table.insert(lines, "- `\"ay` — yank to register a")
        table.insert(lines, "- `\"ap` — paste from register a")
        table.insert(lines, "- `\"+y` — yank to system clipboard")
        table.insert(lines, "- `\"+p` — paste from system clipboard")
        table.insert(lines, "- `:reg` — show all registers")
        table.insert(lines, "")
        table.insert(lines, "### Macros")
        table.insert(lines, "- `qa` — start recording macro to register a")
        table.insert(lines, "- `q` — stop recording")
        table.insert(lines, "- `@a` — play macro from register a")
        table.insert(lines, "- `@@` — repeat last macro")
        table.insert(lines, "")

        -- Create buffer with content
        local buf = vim.api.nvim_create_buf(false, true)
        vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
        vim.api.nvim_buf_set_option(buf, "filetype", "markdown")
        vim.api.nvim_buf_set_option(buf, "buftype", "nofile")
        vim.api.nvim_buf_set_name(buf, "[Tutor]")

        -- Open tutor in a vertical split
        vim.cmd("vsplit")
        vim.api.nvim_win_set_buf(0, buf)
        vim.cmd("wincmd H")  -- Move to far left
        vim.cmd("vertical resize 60")

        vim.notify("Tutor opened. Press <leader>ac to open Claude and ask questions!", vim.log.levels.INFO)
      end, { desc = "Open AI-powered Neovim tutor" })

      vim.keymap.set("n", "<leader>h", "<cmd>Tutor<cr>", { desc = "Help: AI Tutor" })
    end,
  },

  -- LSP Configuration
  {
    "neovim/nvim-lspconfig",
    dependencies = {
      -- Mason for managing LSP servers (optional)
      "williamboman/mason.nvim",
      "williamboman/mason-lspconfig.nvim",

      -- Useful status updates for LSP
      { "j-hui/fidget.nvim", opts = {} },

      -- Additional lua configuration for neovim
      { "folke/neodev.nvim", opts = {} },
    },
    config = function()
      -- Setup Mason
      require("mason").setup()
      require("mason-lspconfig").setup({
        ensure_installed = { "rust_analyzer", "gopls" },
        automatic_installation = {
          exclude = { "basedpyright" },  -- installed via uv instead
        },
      })

      -- Setup LSP servers using the modern vim.lsp.config API
      -- Rust analyzer (uses rust-analyzer from PATH or Mason)
      vim.lsp.config['rust_analyzer'] = {
        cmd = { "rust-analyzer" },
        filetypes = { "rust" },
        root_markers = { "Cargo.toml", ".git" },
      }

      -- Go language server (uses gopls from PATH or Mason)
      vim.lsp.config.gopls = {
        cmd = { "gopls" },
        filetypes = { "go", "gomod", "gowork", "gotmpl" },
        root_markers = { "go.mod", ".git", "go.work" },
      }

      -- Python language server (basedpyright - enhanced pyright fork)
      vim.lsp.config.basedpyright = {
        cmd = { "basedpyright-langserver", "--stdio" },
        filetypes = { "python" },
        root_markers = { "pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "uv.lock", ".git" },
        settings = {
          basedpyright = {
            analysis = {
              typeCheckingMode = "standard",
              autoSearchPaths = true,
              useLibraryCodeForTypes = true,
              diagnosticMode = "openFilesOnly",
            },
          },
        },
      }

      -- LSP keymaps
      vim.api.nvim_create_autocmd("LspAttach", {
        group = vim.api.nvim_create_augroup("UserLspConfig", {}),
        callback = function(ev)
          local opts = { buffer = ev.buf }
          vim.keymap.set("n", "gD", vim.lsp.buf.declaration, opts)
          vim.keymap.set("n", "gd", vim.lsp.buf.definition, opts)
          vim.keymap.set("n", "K", vim.lsp.buf.hover, opts)
          vim.keymap.set("n", "gi", vim.lsp.buf.implementation, opts)
          vim.keymap.set("n", "<C-k>", vim.lsp.buf.signature_help, opts)
          vim.keymap.set("n", "<leader>wa", vim.lsp.buf.add_workspace_folder, opts)
          vim.keymap.set("n", "<leader>wr", vim.lsp.buf.remove_workspace_folder, opts)
          vim.keymap.set("n", "<leader>wl", function()
            print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
          end, opts)
          vim.keymap.set("n", "<leader>D", vim.lsp.buf.type_definition, opts)
          vim.keymap.set("n", "<leader>rn", vim.lsp.buf.rename, opts)
          vim.keymap.set({ "n", "v" }, "<leader>ca", vim.lsp.buf.code_action, opts)
          vim.keymap.set("n", "gr", vim.lsp.buf.references, opts)
          vim.keymap.set("n", "<leader>f", function()
            vim.lsp.buf.format({ async = true })
          end, opts)
        end,
      })

      -- Setup ZLS (Zig Language Server)
      vim.lsp.config.zls = {
        cmd = { "zls" },
        filetypes = { "zig", "zir" },
        root_markers = { "zls.json", ".git", "build.zig" },
      }

      -- Enable all configured LSP servers
      vim.lsp.enable("zls")
      vim.lsp.enable("rust_analyzer")
      vim.lsp.enable("gopls")
      vim.lsp.enable("basedpyright")
    end,
  },

  -- Autocompletion
  {
    "hrsh7th/nvim-cmp",
    dependencies = {
      "hrsh7th/cmp-nvim-lsp",
      "hrsh7th/cmp-buffer",
      "hrsh7th/cmp-path",
      "L3MON4D3/LuaSnip",
      "saadparwaiz1/cmp_luasnip",
    },
    config = function()
      local cmp = require("cmp")
      local luasnip = require("luasnip")

      cmp.setup({
        snippet = {
          expand = function(args)
            luasnip.lsp_expand(args.body)
          end,
        },
        mapping = cmp.mapping.preset.insert({
          ["<C-d>"] = cmp.mapping.scroll_docs(-4),
          ["<C-f>"] = cmp.mapping.scroll_docs(4),
          ["<C-Space>"] = cmp.mapping.complete(),
          ["<CR>"] = cmp.mapping.confirm({
            behavior = cmp.ConfirmBehavior.Replace,
            select = true,
          }),
          ["<Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then
              luasnip.expand_or_jump()
            else
              fallback()
            end
          end, { "i", "s" }),
          ["<S-Tab>"] = cmp.mapping(function(fallback)
            if cmp.visible() then
              cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
              luasnip.jump(-1)
            else
              fallback()
            end
          end, { "i", "s" }),
        }),
        sources = {
          { name = "nvim_lsp" },
          { name = "luasnip" },
          { name = "buffer" },
          { name = "path" },
        },
      })
    end,
  },

  -- Treesitter for better syntax highlighting
  {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    main = "nvim-treesitter",
    opts = {
      ensure_installed = { "zig", "rust", "go", "lua", "vim", "vimdoc", "markdown", "markdown_inline", "python" },
      auto_install = true,
      highlight = { enable = true },
      indent = { enable = true },
    },
  },

  -- File explorer
  {
    "nvim-tree/nvim-tree.lua",
    dependencies = { "nvim-tree/nvim-web-devicons" },
    config = function()
      require("nvim-tree").setup()
      vim.keymap.set("n", "<leader>e", ":NvimTreeToggle<CR>", { silent = true })
    end,
  },

  -- Fuzzy finder
  {
    "nvim-telescope/telescope.nvim",
    branch = "master",
    dependencies = { "nvim-lua/plenary.nvim" },
    config = function()
      local builtin = require("telescope.builtin")
      vim.keymap.set("n", "<leader>ff", builtin.find_files, {})
      vim.keymap.set("n", "<leader>fg", builtin.live_grep, {})
      vim.keymap.set("n", "<leader>fb", builtin.buffers, {})
      vim.keymap.set("n", "<leader>fh", builtin.help_tags, {})
    end,
  },

  -- Color scheme
  {
    "folke/tokyonight.nvim",
    lazy = false,
    priority = 1000,
    config = function()
      vim.cmd([[colorscheme tokyonight-night]])
    end,
  },

  -- Status line
  {
    "nvim-lualine/lualine.nvim",
    dependencies = { "nvim-tree/nvim-web-devicons" },
    config = function()
      require("lualine").setup({
        options = {
          theme = "tokyonight",
        },
      })
    end,
  },

  -- Git signs
  {
    "lewis6991/gitsigns.nvim",
    config = function()
      require("gitsigns").setup()
    end,
  },

  -- Comment toggling
  {
    "numToStr/Comment.nvim",
    config = function()
      require("Comment").setup()
    end,
  },

  -- Zen mode for distraction-free writing
  {
    "folke/zen-mode.nvim",
    opts = {},
    keys = {
      { "<leader>z", "<cmd>ZenMode<cr>", desc = "Writing: Zen Mode" },
    },
  },

  -- Dim inactive text while writing
  {
    "folke/twilight.nvim",
    opts = {},
  },

  -- Markdown rendering in-buffer
  {
    "MeanderingProgrammer/render-markdown.nvim",
    dependencies = { "nvim-treesitter/nvim-treesitter", "nvim-tree/nvim-web-devicons" },
    ft = { "markdown" },
    opts = {},
    keys = {
      { "<leader>mr", "<cmd>RenderMarkdown toggle<cr>", desc = "Markdown: Toggle rendering" },
    },
  },

  -- Code outline/navigation (works with LSP + Treesitter)
  {
    "stevearc/aerial.nvim",
    dependencies = { "nvim-treesitter/nvim-treesitter", "nvim-tree/nvim-web-devicons" },
    opts = {
      backends = { "treesitter", "lsp", "markdown", "man" },
      layout = {
        min_width = 30,
        default_direction = "right",
      },
      filter_kind = false, -- show all symbol types
    },
    keys = {
      { "<leader>o", "<cmd>AerialToggle<cr>", desc = "Outline: Toggle" },
      { "<leader>O", "<cmd>AerialNavToggle<cr>", desc = "Outline: Toggle nav" },
      { "{", "<cmd>AerialPrev<cr>", desc = "Outline: Previous symbol" },
      { "}", "<cmd>AerialNext<cr>", desc = "Outline: Next symbol" },
    },
  },

  -- Multi-cursor support (VSCode-style)
  {
    "mg979/vim-visual-multi",
    branch = "master",
  },

  -- Snacks.nvim (required for claudecode.nvim terminal)
  {
    "folke/snacks.nvim",
    priority = 1000,
    lazy = false,
    opts = {},
  },

  -- Claude Code AI integration
  {
    "coder/claudecode.nvim",
    dependencies = { "folke/snacks.nvim" },
    event = "VeryLazy",  -- Load early but not blocking
    config = function()
      require("claudecode").setup({
        terminal_cmd = vim.fn.expand("~/.claude/local/claude"),
      })

      -- Keymaps
      vim.keymap.set("n", "<leader>ac", "<cmd>ClaudeCode<cr>", { desc = "AI: Toggle Claude" })
      vim.keymap.set("n", "<leader>af", "<cmd>ClaudeCodeFocus<cr>", { desc = "AI: Focus Claude" })
      vim.keymap.set("v", "<leader>as", "<cmd>ClaudeCodeSend<cr>", { desc = "AI: Send to Claude" })
      vim.keymap.set("n", "<leader>ab", "<cmd>ClaudeCodeAdd %<cr>", { desc = "AI: Add buffer" })
      vim.keymap.set("n", "<leader>aa", "<cmd>ClaudeCodeDiffAccept<cr>", { desc = "AI: Accept diff" })
      vim.keymap.set("n", "<leader>ad", "<cmd>ClaudeCodeDiffDeny<cr>", { desc = "AI: Reject diff" })

      -- Status check command
      vim.api.nvim_create_user_command("ClaudeStatus", function()
        local ok, claude = pcall(require, "claudecode")
        if ok and claude.status then
          vim.notify("Claude: " .. (claude.status() or "unknown"), vim.log.levels.INFO)
        else
          vim.notify("Claude: plugin loaded, checking connection...", vim.log.levels.INFO)
        end
      end, { desc = "Check Claude connection status" })
    end,
  },

  -- Simple IPython terminal toggle (just works, no setup needed)
  {
    "akinsho/toggleterm.nvim",
    version = "*",
    config = function()
      require("toggleterm").setup({
        size = function(term)
          if term.direction == "horizontal" then
            return 15
          elseif term.direction == "vertical" then
            return vim.o.columns * 0.4
          end
        end,
        open_mapping = [[<c-\>]],
        direction = "vertical",
      })

      -- Dedicated IPython terminal
      local Terminal = require("toggleterm.terminal").Terminal
      local ipython = Terminal:new({
        cmd = "ipython",
        direction = "vertical",
        hidden = true,
        on_open = function(term)
          vim.cmd("startinsert!")
        end,
      })

      -- Toggle IPython REPL
      vim.keymap.set("n", "<leader>pi", function() ipython:toggle() end, { desc = "Python: Toggle IPython" })

      -- Send current line to IPython
      vim.keymap.set("n", "<leader>pl", function()
        local line = vim.api.nvim_get_current_line()
        ipython:send(line, true)
      end, { desc = "Python: Send line" })

      -- Send visual selection to IPython
      vim.keymap.set("v", "<leader>ps", function()
        -- Get visual selection
        local start_pos = vim.fn.getpos("'<")
        local end_pos = vim.fn.getpos("'>")
        local lines = vim.api.nvim_buf_get_lines(0, start_pos[2] - 1, end_pos[2], false)
        if #lines > 0 then
          -- Adjust first and last line for visual selection
          lines[#lines] = string.sub(lines[#lines], 1, end_pos[3])
          lines[1] = string.sub(lines[1], start_pos[3])
        end
        ipython:send(lines, true)
      end, { desc = "Python: Send selection" })

      -- Send paragraph to IPython
      vim.keymap.set("n", "<leader>pp", function()
        local start_line = vim.fn.search("^\\s*$", "bnW") + 1
        local end_line = vim.fn.search("^\\s*$", "nW") - 1
        if end_line < start_line then
          end_line = vim.fn.line("$")
        end
        local lines = vim.api.nvim_buf_get_lines(0, start_line - 1, end_line, false)
        ipython:send(lines, true)
      end, { desc = "Python: Send paragraph" })

      -- Send code block (# %% cell) to IPython
      vim.keymap.set("n", "<leader>pb", function()
        local current_line = vim.fn.line(".")
        local start_line = vim.fn.search("^# %%", "bnW")
        if start_line == 0 then start_line = 1 else start_line = start_line + 1 end
        local end_line = vim.fn.search("^# %%", "nW") - 1
        if end_line < start_line then end_line = vim.fn.line("$") end
        local lines = vim.api.nvim_buf_get_lines(0, start_line - 1, end_line, false)
        ipython:send(lines, true)
      end, { desc = "Python: Send code block" })

      -- Send block and move to next
      vim.keymap.set("n", "<leader>pn", function()
        vim.cmd("normal \\<leader>pb")
        vim.fn.search("^# %%", "W")
      end, { desc = "Python: Send block & next" })

      -- Write selected lines from terminal to new Python buffer
      vim.keymap.set("v", "<leader>pw", function()
        -- Yank selection
        vim.cmd('normal! "zy')
        local content = vim.fn.getreg("z")

        -- Clean up IPython prompts (In [1]:, Out[1]:, ...:, etc.)
        local lines = {}
        for line in content:gmatch("[^\n]+") do
          -- Remove IPython input prompts
          line = line:gsub("^In %[%d+%]: ", "")
          -- Remove continuation prompts
          line = line:gsub("^   %.%.%.: ", "")
          -- Skip output prompts and their content
          if not line:match("^Out%[%d+%]:") then
            table.insert(lines, line)
          end
        end

        -- Create new buffer with content
        vim.cmd("enew")
        vim.bo.filetype = "python"
        vim.api.nvim_buf_set_lines(0, 0, -1, false, lines)
      end, { desc = "Python: Write to new buffer" })
    end,
  },

  -- Image rendering in terminal (for markdown images)
  {
    "3rd/image.nvim",
    opts = {
      backend = "kitty",  -- or "ueberzug" for X11, "iterm" for iTerm2
      max_width = 100,
      max_height = 20,
      max_height_window_percentage = 50,
      integrations = {
        markdown = {
          enabled = true,
          clear_in_insert_mode = true,
          only_render_image_at_cursor = false,
        },
      },
    },
  },

  -- Jupyter notebook editing (converts .ipynb to Python with cell markers)
  {
    "GCBallesteros/jupytext.nvim",
    config = function()
      require("jupytext").setup({
        style = "percent",  -- Use # %% cell markers
        output_extension = "auto",
        force_ft = nil,
      })
    end,
  },

})

-- Additional keybindings
vim.keymap.set("n", "<leader>pv", vim.cmd.Ex)

vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv")
vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
vim.keymap.set("n", "J", "mzJ`z")
vim.keymap.set("n", "<C-d>", "<C-d>zz")
vim.keymap.set("n", "<C-u>", "<C-u>zz")
vim.keymap.set("n", "n", "nzzzv")
vim.keymap.set("n", "N", "Nzzzv")
vim.keymap.set("x", "<leader>p", [["_dP]])
vim.keymap.set({"n", "v"}, "<leader>y", [["+y]])
vim.keymap.set("n", "<leader>Y", [["+Y]])
vim.keymap.set({"n", "v"}, "<leader>d", [["_d]])
vim.keymap.set("n", "Q", "<nop>")

-- Disable Ctrl-Z in ClaudeCode terminal (prevents accidental suspend)
vim.api.nvim_create_autocmd("TermOpen", {
  callback = function()
    -- Check buffer name or terminal command for claude
    local bufname = vim.api.nvim_buf_get_name(0):lower()
    if bufname:match("claude") or bufname:match("ClaudeCode") then
      vim.keymap.set("t", "<C-z>", "<nop>", { buffer = 0 })
    end
    -- Also set after a short delay to catch dynamically named terminals
    vim.defer_fn(function()
      local name = vim.api.nvim_buf_get_name(0):lower()
      if name:match("claude") then
        vim.keymap.set("t", "<C-z>", "<nop>", { buffer = 0 })
      end
    end, 100)
  end,
})

-- Diagnostic configuration
vim.diagnostic.config({
  virtual_text = true,
  signs = true,
  update_in_insert = false,
  underline = true,
  severity_sort = true,
  float = {
    border = "rounded",
    source = "always",
    header = "",
    prefix = "",
  },
})

-- Diagnostic keymaps
vim.keymap.set("n", "[d", vim.diagnostic.goto_prev)
vim.keymap.set("n", "]d", vim.diagnostic.goto_next)
vim.keymap.set("n", "<leader>dl", vim.diagnostic.setloclist)
vim.keymap.set("n", "<leader>q", vim.diagnostic.setloclist)

-- Zig configuration
vim.api.nvim_create_autocmd("FileType", {
  pattern = "zig",
  callback = function()
    -- Set makeprg to use zig build
    vim.opt_local.makeprg = "zig build"

    -- Set errorformat for Zig compiler errors
    vim.opt_local.errorformat = "%f:%l:%c: %t%*[^:]: %m"
  end,
})

-- Rust configuration
vim.api.nvim_create_autocmd("FileType", {
  pattern = "rust",
  callback = function()
    -- Set makeprg to use cargo
    vim.opt_local.makeprg = "cargo build"

    -- Set errorformat for rustc compiler errors
    vim.opt_local.errorformat =
      "%E--> %f:%l:%c," ..
      "%W--> %f:%l:%c," ..
      "%C%m"
  end,
})

-- Go configuration
vim.api.nvim_create_autocmd("FileType", {
  pattern = "go",
  callback = function()
    -- Set makeprg to use go build
    vim.opt_local.makeprg = "go build"

    -- Set errorformat for Go compiler errors
    vim.opt_local.errorformat = "%f:%l:%c: %m,%f:%l: %m"
  end,
})

-- Python configuration
vim.api.nvim_create_autocmd("FileType", {
  pattern = "python",
  callback = function()
    -- Use uv run for Python execution
    vim.opt_local.makeprg = "uv run python %"

    -- Python error format
    vim.opt_local.errorformat = '%C %.%#,%A  File "%f"\\, line %l%.%#,%Z%[%^ ]%\\@=%m'
  end,
})

-- Markdown/prose configuration
vim.api.nvim_create_autocmd("FileType", {
  pattern = "markdown",
  callback = function()
    vim.opt_local.wrap = true
    vim.opt_local.linebreak = true
    vim.opt_local.spell = true
    vim.opt_local.conceallevel = 2
  end,
})

-- Markdown image helper functions
-- Configure these paths to match your workflow
local markdown_media_config = {
  image_search_dir = "~/Downloads",  -- Where to search for images with <Space>mI
  recording_search_dir = "~/Desktop", -- Where to search for recordings with <Space>mR
  image_search_depth = 2,             -- How deep to search for images
  recording_search_depth = 1,         -- How deep to search for recordings
}

local function get_images_dir()
  -- Look for common blog static directories, fallback to static/assets/images
  local candidates = { "static/assets/images", "static/images", "assets/images", "public/images", "images" }
  local cwd = vim.fn.getcwd()
  for _, dir in ipairs(candidates) do
    if vim.fn.isdirectory(cwd .. "/" .. dir) == 1 then
      return dir
    end
  end
  return "static/assets/images"
end

local function get_markdown_image_url(dest_path)
  -- Hugo serves static/ from root, so strip the prefix for URLs
  return "/" .. dest_path:gsub("^static/", "")
end

local function insert_markdown_image(image_path)
  local filename = vim.fn.fnamemodify(image_path, ":t")
  local images_dir = get_images_dir()
  local dest_path = images_dir .. "/" .. filename
  local full_dest = vim.fn.getcwd() .. "/" .. dest_path

  -- Create images directory if it doesn't exist
  vim.fn.mkdir(vim.fn.fnamemodify(full_dest, ":h"), "p")

  -- Copy file
  local result = vim.fn.system({ "cp", vim.fn.expand(image_path), full_dest })
  if vim.v.shell_error ~= 0 then
    vim.notify("Failed to copy image: " .. result, vim.log.levels.ERROR)
    return
  end

  -- Insert markdown image tag at cursor
  local url_path = get_markdown_image_url(dest_path)
  local md_tag = string.format("![%s](%s)", vim.fn.fnamemodify(filename, ":r"), url_path)
  vim.api.nvim_put({ md_tag }, "c", true, true)
  vim.notify("Inserted: " .. dest_path, vim.log.levels.INFO)
end

local function paste_image_from_clipboard(custom_name)
  -- Check if pngpaste is available
  if vim.fn.executable("pngpaste") ~= 1 then
    vim.notify("pngpaste not found. Install with: brew install pngpaste", vim.log.levels.ERROR)
    return
  end

  local images_dir = get_images_dir()
  local timestamp = os.date("%Y%m%d-%H%M%S")
  local basename = custom_name or ("screenshot-" .. timestamp)
  -- Ensure .png extension
  local filename = basename:match("%.png$") and basename or (basename .. ".png")
  local dest_path = images_dir .. "/" .. filename
  local full_dest = vim.fn.getcwd() .. "/" .. dest_path

  -- Create images directory if it doesn't exist
  vim.fn.mkdir(vim.fn.fnamemodify(full_dest, ":h"), "p")

  -- Save clipboard image using pngpaste
  local result = vim.fn.system({ "pngpaste", full_dest })
  if vim.v.shell_error ~= 0 then
    vim.notify("No image in clipboard or paste failed", vim.log.levels.WARN)
    return
  end

  -- Insert markdown image tag at cursor
  local alt_text = vim.fn.fnamemodify(filename, ":r")
  local url_path = get_markdown_image_url(dest_path)
  local md_tag = string.format("![%s](%s)", alt_text, url_path)
  vim.api.nvim_put({ md_tag }, "c", true, true)
  vim.notify("Pasted: " .. dest_path, vim.log.levels.INFO)
end

-- Command: :MarkdownInsertImage ~/path/to/image.png
vim.api.nvim_create_user_command("MarkdownInsertImage", function(opts)
  if opts.args == "" then
    vim.notify("Usage: :MarkdownInsertImage <path>", vim.log.levels.WARN)
    return
  end
  insert_markdown_image(opts.args)
end, { nargs = 1, complete = "file", desc = "Insert image into markdown" })

local function insert_recording_as_gif(video_path, custom_name)
  -- Check if ffmpeg is available
  if vim.fn.executable("ffmpeg") ~= 1 then
    vim.notify("ffmpeg not found. Install with: brew install ffmpeg", vim.log.levels.ERROR)
    return
  end

  local expanded_path = vim.fn.expand(video_path)
  if vim.fn.filereadable(expanded_path) ~= 1 then
    vim.notify("File not found: " .. video_path, vim.log.levels.ERROR)
    return
  end

  local images_dir = get_images_dir()
  local timestamp = os.date("%Y%m%d-%H%M%S")
  local basename = custom_name or ("recording-" .. timestamp)
  -- Ensure .gif extension
  local filename = basename:match("%.gif$") and basename or (basename .. ".gif")
  local dest_path = images_dir .. "/" .. filename
  local full_dest = vim.fn.getcwd() .. "/" .. dest_path

  -- Create images directory if it doesn't exist
  vim.fn.mkdir(vim.fn.fnamemodify(full_dest, ":h"), "p")

  vim.notify("Converting to GIF...", vim.log.levels.INFO)

  -- Convert using ffmpeg (10fps, 800px width, optimized for web)
  local cmd = string.format(
    'ffmpeg -i "%s" -vf "fps=10,scale=800:-1:flags=lanczos" -loop 0 -y "%s" 2>&1',
    expanded_path, full_dest
  )
  local result = vim.fn.system(cmd)
  if vim.v.shell_error ~= 0 then
    vim.notify("ffmpeg conversion failed: " .. result, vim.log.levels.ERROR)
    return
  end

  -- Insert markdown image tag at cursor
  local alt_text = vim.fn.fnamemodify(filename, ":r")
  local url_path = get_markdown_image_url(dest_path)
  local md_tag = string.format("![%s](%s)", alt_text, url_path)
  vim.api.nvim_put({ md_tag }, "c", true, true)
  vim.notify("Inserted: " .. dest_path, vim.log.levels.INFO)
end

-- Command: :MarkdownInsertRecording ~/Desktop/screen.mov [optional-name]
-- Supports paths with spaces (use tab completion or quotes)
vim.api.nvim_create_user_command("MarkdownInsertRecording", function(opts)
  local args = opts.fargs
  if #args == 0 then
    vim.notify("Usage: :MarkdownInsertRecording <video-path> [name]", vim.log.levels.WARN)
    return
  end
  -- Join all args except last as path if last looks like a name (no path separators)
  local path, name
  if #args == 1 then
    path = args[1]
  elseif not args[#args]:match("[/\\]") and #args > 1 then
    name = args[#args]
    path = table.concat(args, " ", 1, #args - 1)
  else
    path = table.concat(args, " ")
  end
  insert_recording_as_gif(path, name)
end, { nargs = "+", complete = "file", desc = "Convert recording to GIF and insert" })

-- Keymap for pasting from clipboard (markdown files only)
vim.api.nvim_create_autocmd("FileType", {
  pattern = "markdown",
  callback = function()
    vim.keymap.set("n", "<leader>mi", function() paste_image_from_clipboard() end, { buffer = true, desc = "Media: Paste image" })
    vim.keymap.set("n", "<leader>mn", function()
      vim.ui.input({ prompt = "Image name: " }, function(name)
        if name and name ~= "" then paste_image_from_clipboard(name) end
      end)
    end, { buffer = true, desc = "Media: Paste image (named)" })
    vim.keymap.set("n", "<leader>mI", function()
      local search_dir = vim.fn.expand(markdown_media_config.image_search_dir)
      local depth = tostring(markdown_media_config.image_search_depth)
      require("telescope.builtin").find_files({
        prompt_title = "Select Image (" .. markdown_media_config.image_search_dir .. ")",
        cwd = search_dir,
        find_command = { "find", ".", "-maxdepth", depth, "-type", "f", "(", "-name", "*.png", "-o", "-name", "*.jpg", "-o", "-name", "*.jpeg", "-o", "-name", "*.gif", "-o", "-name", "*.webp", ")" },
        attach_mappings = function(_, map)
          map("i", "<CR>", function(prompt_bufnr)
            local selection = require("telescope.actions.state").get_selected_entry()
            require("telescope.actions").close(prompt_bufnr)
            if selection then
              local file_path = selection.path or (search_dir .. "/" .. selection[1])
              insert_markdown_image(file_path)
            end
          end)
          return true
        end,
      })
    end, { buffer = true, desc = "Media: Insert from path" })
    vim.keymap.set("n", "<leader>mR", function()
      local search_dir = vim.fn.expand(markdown_media_config.recording_search_dir)
      local depth = tostring(markdown_media_config.recording_search_depth)
      require("telescope.builtin").find_files({
        prompt_title = "Select Recording (" .. markdown_media_config.recording_search_dir .. ")",
        cwd = search_dir,
        find_command = { "find", ".", "-maxdepth", depth, "-type", "f", "(", "-name", "*.mov", "-o", "-name", "*.mp4", "-o", "-name", "*.webm", ")" },
        attach_mappings = function(_, map)
          map("i", "<CR>", function(prompt_bufnr)
            local selection = require("telescope.actions.state").get_selected_entry()
            require("telescope.actions").close(prompt_bufnr)
            if selection then
              local file_path = selection.path or (search_dir .. "/" .. selection[1])
              vim.ui.input({ prompt = "GIF name (optional): " }, function(name)
                insert_recording_as_gif(file_path, name ~= "" and name or nil)
              end)
            end
          end)
          return true
        end,
      })
    end, { buffer = true, desc = "Media: Recording to GIF" })
  end,
})

-- Build and run keymaps (language-aware)
-- These work with makeprg set by FileType autocmds
vim.keymap.set("n", "<leader>m", ":make<CR>", { desc = "Build: Run make" })
vim.keymap.set("n", "<leader>M", ":make ", { desc = "Build: Make with args" })

-- Language-specific run and test commands
vim.keymap.set("n", "<leader>r", function()
  local ft = vim.bo.filetype
  if ft == "zig" then
    vim.cmd("make run")
  elseif ft == "rust" then
    vim.cmd("!cargo run")
  elseif ft == "go" then
    vim.cmd("!go run .")
  elseif ft == "python" then
    vim.cmd("!uv run python %")
  else
    print("Run not configured for filetype: " .. ft)
  end
end, { desc = "Run: Build and run" })

vim.keymap.set("n", "<leader>t", function()
  local ft = vim.bo.filetype
  if ft == "zig" then
    vim.cmd("make test")
  elseif ft == "rust" then
    vim.cmd("!cargo test")
  elseif ft == "go" then
    vim.cmd("!go test")
  elseif ft == "python" then
    vim.cmd("!uv run pytest")
  else
    print("Test not configured for filetype: " .. ft)
  end
end, { desc = "Test: Run tests" })

-- Terminal-based run (output stays visible, can copy from it)
vim.keymap.set("n", "<leader>rr", function()
  local ft = vim.bo.filetype
  local cmd
  if ft == "zig" then
    cmd = "zig build run"
  elseif ft == "rust" then
    cmd = "cargo run"
  elseif ft == "go" then
    cmd = "go run ."
  elseif ft == "python" then
    cmd = "uv run python " .. vim.fn.expand("%")
  else
    print("Run not configured for filetype: " .. ft)
    return
  end
  vim.cmd("split | terminal " .. cmd)
  vim.cmd("startinsert")
end, { desc = "Run: In terminal" })

vim.keymap.set("n", "<leader>rt", function()
  local ft = vim.bo.filetype
  local cmd
  if ft == "zig" then
    cmd = "zig build test"
  elseif ft == "rust" then
    cmd = "cargo test"
  elseif ft == "go" then
    cmd = "go test"
  elseif ft == "python" then
    cmd = "uv run pytest"
  else
    print("Test not configured for filetype: " .. ft)
    return
  end
  vim.cmd("split | terminal " .. cmd)
  vim.cmd("startinsert")
end, { desc = "Test: In terminal" })

-- Quickfix navigation
vim.keymap.set("n", "<leader>co", ":copen<CR>", { desc = "Quickfix: Open" })
vim.keymap.set("n", "<leader>cc", ":cclose<CR>", { desc = "Quickfix: Close" })
vim.keymap.set("n", "[q", ":cprev<CR>", { desc = "Quickfix: Previous" })
vim.keymap.set("n", "]q", ":cnext<CR>", { desc = "Quickfix: Next" })

-- Copy all quickfix errors to clipboard
vim.keymap.set("n", "<leader>ce", function()
  local qf_list = vim.fn.getqflist()
  local errors = {}
  for _, item in ipairs(qf_list) do
    local bufname = vim.fn.bufname(item.bufnr)
    local line = string.format("%s:%d:%d: %s", bufname, item.lnum, item.col, item.text)
    table.insert(errors, line)
  end
  local error_text = table.concat(errors, "\n")
  vim.fn.setreg("+", error_text)
  print("Copied " .. #errors .. " errors to clipboard")
end, { desc = "Quickfix: Copy errors to clipboard" })

-- Quick run current file (for single-file programs)
vim.keymap.set("n", "<leader>zf", ":!zig run %<CR>", { desc = "Zig: Run file" })
vim.keymap.set("n", "<leader>rf", ":!rustc % && ./%:t:r<CR>", { desc = "Rust: Run file" })
vim.keymap.set("n", "<leader>gf", ":!go run %<CR>", { desc = "Go: Run file" })
vim.keymap.set("n", "<leader>pf", ":!uv run python %<CR>", { desc = "Python: Run file" })
-- clear ^@ characters
vim.keymap.set('n', '<leader>fn', ':%s/\\%x00/\\r/g<CR>', { desc = 'Fix: Null bytes to newlines' })