@sebastienrousseau/dotfiles 0.2.499 → 0.2.500

package/dot_config/nvim/lua/plugins/coding.lua

@@ -0,0 +1,216 @@
+-- Copyright (c) 2015-2026 Dotfiles. All rights reserved.
+-- @module nvim.plugins.coding
+-- Syntax, completion, and language intelligence plugins.
+-- Treesitter provides AST-based highlighting and text-objects.
+-- nvim-cmp drives the completion engine with LSP, snippet, and path sources.
+-- venv-selector enables Python virtualenv switching from within Neovim.
+return {
+  -- Treesitter (Syntax Highlighting)
+  {
+    "nvim-treesitter/nvim-treesitter",
+    build = ":TSUpdate",
+    event = { "BufReadPost", "BufNewFile" },
+    config = function()
+      -- Use correct module path (configs)
+      local ok, ts_config = pcall(require, "nvim-treesitter.configs")
+      if not ok then
+        -- Treesitter not installed yet, skip configuration
+        return
+      end
+
+      ts_config.setup({
+        ensure_installed = {
+          "python",
+          "go",
+          "markdown",
+          "json",
+          "toml",
+          "yaml",
+          "bash",
+          "vim",
+          "regex",
+          "lua",
+          "rust",
+          "dockerfile",
+        },
+        highlight = { enable = true },
+        indent = { enable = true },
+      })
+    end,
+  },
+
+  -- Neotest (Testing)
+  {
+    "nvim-neotest/neotest",
+    dependencies = {
+      "nvim-neotest/nvim-nio",
+      "nvim-neotest/neotest-python",
+      "nvim-neotest/neotest-plenary",
+      "nvim-lua/plenary.nvim",
+      "nvim-treesitter/nvim-treesitter",
+    },
+    config = function()
+      require("neotest").setup({
+        adapters = {
+          require("neotest-python")({
+            dap = { justMyCode = false },
+            runner = "pytest",
+            args = { "--cov", "--cov-report=term-missing", "-v" },
+          }),
+          require("neotest-plenary"),
+        },
+      })
+      -- Keymaps
+      vim.keymap.set("n", "<leader>tn", function()
+        require("neotest").run.run()
+      end, { desc = "Run nearest test" })
+      vim.keymap.set("n", "<leader>tf", function()
+        require("neotest").run.run(vim.fn.expand("%"))
+      end, { desc = "Run test file" })
+      vim.keymap.set("n", "<leader>ts", function()
+        require("neotest").summary.toggle()
+      end, { desc = "Toggle test summary" })
+      vim.keymap.set("n", "<leader>to", function()
+        require("neotest").output.open({ enter = true })
+      end, { desc = "Show test output" })
+    end,
+  },
+
+  -- Debugging (DAP + Python)
+  {
+    "mfussenegger/nvim-dap",
+    dependencies = {
+      "rcarriga/nvim-dap-ui",
+      "mfussenegger/nvim-dap-python",
+      "nvim-neotest/nvim-nio",
+      "theHamsta/nvim-dap-virtual-text",
+      "jbyuki/one-small-step-for-vimkind",
+    },
+    config = function()
+      local dap_python = require("dap-python")
+      local osv = require("osv")
+
+      -- DAP UI setup and listeners are in dap.lua (avoid duplication)
+      require("nvim-dap-virtual-text").setup()
+
+      -- Python path resolution
+      local venv_path = os.getenv("VIRTUAL_ENV")
+      local python_path
+      if venv_path then
+        python_path = venv_path .. "/bin/python"
+      else
+        python_path = vim.fn.exepath("python3") or vim.fn.exepath("python")
+      end
+
+      dap_python.setup(python_path)
+      dap_python.test_runner = "pytest"
+
+      -- Local Lua debugger (OSV)
+      local dap = require("dap")
+      osv.setup({ port = 8086 })
+      dap.adapters.nlua = function(callback, config)
+        callback({ type = "server", host = config.host or "127.0.0.1", port = config.port or 8086 })
+      end
+      dap.configurations.lua = {
+        {
+          type = "nlua",
+          request = "attach",
+          name = "Attach to running Neovim instance",
+        },
+      }
+
+      -- Signs
+      vim.fn.sign_define("DapBreakpoint", { text = "B", texthl = "DapBreakpoint", linehl = "", numhl = "" })
+      vim.fn.sign_define(
+        "DapStopped",
+        { text = "S", texthl = "DapStopped", linehl = "DapStopped", numhl = "DapStopped" }
+      )
+    end,
+  },
+
+  -- Debugging (DAP + Go)
+  {
+    "leoluz/nvim-dap-go",
+    ft = { "go" },
+    dependencies = { "mfussenegger/nvim-dap" },
+    config = function()
+      require("dap-go").setup()
+    end,
+  },
+
+  -- Linting (Nvim-Lint)
+  {
+    "mfussenegger/nvim-lint",
+    event = { "BufReadPre", "BufNewFile" },
+    config = function()
+      local lint = require("lint")
+      lint.linters_by_ft = {
+        python = { "mypy", "codespell" },
+        markdown = { "codespell" },
+        dockerfile = { "hadolint" },
+      }
+
+      vim.api.nvim_create_autocmd({ "BufWritePost", "BufEnter", "InsertLeave" }, {
+        group = vim.api.nvim_create_augroup("lint", { clear = true }),
+        callback = function()
+          lint.try_lint()
+        end,
+      })
+    end,
+  },
+
+  -- Neogen (Docstrings)
+  {
+    "danymat/neogen",
+    dependencies = "nvim-treesitter/nvim-treesitter",
+    cmd = "Neogen",
+    keys = {
+      { "<leader>nd", ":Neogen<CR>", desc = "Generate Docstring" },
+    },
+    config = function()
+      require("neogen").setup({ snippet_engine = "nvim" })
+    end,
+  },
+
+  -- Telescope (Fuzzy Finder)
+  {
+    "nvim-telescope/telescope.nvim",
+    dependencies = { "nvim-telescope/telescope-fzf-native.nvim", "ThePrimeagen/git-worktree.nvim" },
+    cmd = "Telescope",
+    config = function()
+      local telescope = require("telescope")
+      telescope.setup({
+        defaults = {
+          file_ignore_patterns = { ".git/", "node_modules", ".venv" },
+          layout_strategy = "horizontal",
+          layout_config = { prompt_position = "top" },
+          sorting_strategy = "ascending",
+          winblend = 0,
+        },
+        pickers = {
+          find_files = { hidden = true },
+        },
+      })
+      pcall(telescope.load_extension, "fzf")
+      pcall(telescope.load_extension, "git_worktree")
+    end,
+  },
+  { "nvim-telescope/telescope-fzf-native.nvim", build = "make" },
+  -- Venv Selector (Python Env Management)
+  {
+    "linux-cultist/venv-selector.nvim",
+    version = false, -- No tagged releases; track default branch
+    dependencies = {
+      "neovim/nvim-lspconfig",
+      "nvim-telescope/telescope.nvim",
+      "mfussenegger/nvim-dap-python",
+    },
+    cmd = "VenvSelect",
+    keys = { { "<leader>cv", "<cmd>VenvSelect<cr>", desc = "Select VirtualEnv" } },
+    opts = {
+      name = { "venv", ".venv", "env", ".env" },
+      auto_refresh = false, -- Disable auto-scan to prevent home dir timeouts
+      dap_enabled = true,
+    },
+  },
+}

package/dot_config/nvim/lua/plugins/completion.lua

@@ -0,0 +1,60 @@
+-- Copyright (c) 2015-2026 Dotfiles. All rights reserved.
+-- Completion engine: blink.cmp (replaces nvim-cmp + 6 plugins)
+-- https://github.com/Saghen/blink.cmp
+
+return {
+  {
+    "saghen/blink.cmp",
+    version = "1.*",
+    event = "InsertEnter",
+    dependencies = {
+      "rafamadriz/friendly-snippets",
+    },
+    opts = {
+      keymap = {
+        preset = "default",
+        ["<C-space>"] = { "show", "show_documentation", "hide_documentation" },
+        ["<C-e>"] = { "hide" },
+        ["<CR>"] = { "accept", "fallback" },
+        ["<Tab>"] = { "snippet_forward", "select_next", "fallback" },
+        ["<S-Tab>"] = { "snippet_backward", "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" },
+      },
+      appearance = {
+        nerd_font_variant = "mono",
+      },
+      completion = {
+        accept = { auto_brackets = { enabled = true } },
+        documentation = {
+          auto_show = true,
+          auto_show_delay_ms = 200,
+          window = { border = "rounded" },
+        },
+        menu = {
+          border = "rounded",
+          draw = {
+            columns = {
+              { "kind_icon" },
+              { "label", "label_description", gap = 1 },
+            },
+          },
+        },
+        list = {
+          selection = { preselect = true, auto_insert = false },
+        },
+      },
+      sources = {
+        default = { "lsp", "path", "snippets", "buffer" },
+      },
+      snippets = { preset = "default" },
+      signature = {
+        enabled = true,
+        window = { border = "rounded" },
+      },
+    },
+    opts_extend = { "sources.default" },
+  },
+}

package/dot_config/nvim/lua/plugins/dap.lua

@@ -0,0 +1,412 @@
+-- Copyright (c) 2015-2026 Dotfiles. All rights reserved.
+-- @module nvim.plugins.dap
+-- Debug Adapter Protocol (DAP) Configuration.
+-- Provides in-editor debugging with nvim-dap and a VS Code-like UI via dap-ui.
+-- js-debug-adapter handles Node/Chrome/Edge; the dev server port defaults to
+-- 3000 but can be overridden via DAP_DEV_SERVER_PORT.
+
+-- Layout constants
+local SIDEBAR_WIDTH = 40
+local BOTTOM_PANEL_HEIGHT = 10
+local QUARTER_SIZE = 0.25
+local HALF_SIZE = 0.5
+local DEFAULT_DEV_SERVER_PORT = tonumber(vim.env.DAP_DEV_SERVER_PORT) or 3000
+
+return {
+  -- DAP Core
+  {
+    "mfussenegger/nvim-dap",
+    dependencies = {
+      "williamboman/mason.nvim",
+      "jay-babu/mason-nvim-dap.nvim",
+      "rcarriga/nvim-dap-ui",
+      "nvim-neotest/nvim-nio",
+    },
+    keys = {
+      {
+        "<leader>db",
+        function()
+          require("dap").toggle_breakpoint()
+        end,
+        desc = "Toggle Breakpoint",
+      },
+      {
+        "<leader>dc",
+        function()
+          require("dap").continue()
+        end,
+        desc = "Continue",
+      },
+      {
+        "<leader>di",
+        function()
+          require("dap").step_into()
+        end,
+        desc = "Step Into",
+      },
+      {
+        "<leader>do",
+        function()
+          require("dap").step_over()
+        end,
+        desc = "Step Over",
+      },
+      {
+        "<leader>dO",
+        function()
+          require("dap").step_out()
+        end,
+        desc = "Step Out",
+      },
+      {
+        "<leader>dr",
+        function()
+          require("dap").repl.open()
+        end,
+        desc = "Open REPL",
+      },
+      {
+        "<leader>dl",
+        function()
+          require("dap").run_last()
+        end,
+        desc = "Run Last",
+      },
+      {
+        "<leader>dt",
+        function()
+          require("dap").terminate()
+        end,
+        desc = "Terminate",
+      },
+      {
+        "<leader>du",
+        function()
+          require("dapui").toggle()
+        end,
+        desc = "Toggle DAP UI",
+      },
+    },
+    config = function()
+      local dap = require("dap")
+
+      -- JavaScript/TypeScript debugging with js-debug-adapter
+      -- Requires: MasonInstall js-debug-adapter
+      local js_debug_path = vim.fn.stdpath("data") .. "/mason/packages/js-debug-adapter/js-debug/src/dapDebugServer.js"
+
+      for _, adapter in ipairs({ "pwa-node", "pwa-chrome", "node-terminal" }) do
+        dap.adapters[adapter] = {
+          type = "server",
+          host = "localhost",
+          port = "${port}",
+          executable = {
+            command = "node",
+            args = { js_debug_path, "${port}" },
+          },
+        }
+      end
+
+      -- JavaScript/TypeScript configurations
+      for _, lang in ipairs({ "javascript", "typescript", "javascriptreact", "typescriptreact" }) do
+        dap.configurations[lang] = {
+          {
+            type = "pwa-node",
+            request = "launch",
+            name = "Launch file",
+            program = "${file}",
+            cwd = "${workspaceFolder}",
+          },
+          {
+            type = "pwa-node",
+            request = "attach",
+            name = "Attach to process",
+            processId = require("dap.utils").pick_process,
+            cwd = "${workspaceFolder}",
+          },
+          {
+            type = "pwa-chrome",
+            request = "launch",
+            name = "Launch Chrome",
+            url = "http://localhost:" .. DEFAULT_DEV_SERVER_PORT,
+            webRoot = "${workspaceFolder}",
+          },
+        }
+      end
+
+      -- Python debugging with debugpy
+      -- Requires: MasonInstall debugpy
+      dap.adapters.python = function(cb, config)
+        if config.request == "attach" then
+          local port = (config.connect or config).port
+          local host = (config.connect or config).host or "127.0.0.1"
+          cb({ type = "server", port = assert(port, "port required for attach"), host = host })
+        else
+          cb({
+            type = "executable",
+            command = vim.fn.exepath("python3"),
+            args = { "-m", "debugpy.adapter" },
+          })
+        end
+      end
+
+      dap.configurations.python = {
+        {
+          type = "python",
+          request = "launch",
+          name = "Launch file",
+          program = "${file}",
+          cwd = "${workspaceFolder}",
+          pythonPath = function()
+            -- Use venv if available, else system python
+            local venv = os.getenv("VIRTUAL_ENV")
+            if venv then
+              return venv .. "/bin/python"
+            end
+            return vim.fn.exepath("python3") or "python3"
+          end,
+        },
+        {
+          type = "python",
+          request = "launch",
+          name = "Launch with arguments",
+          program = "${file}",
+          args = function()
+            local args_str = vim.fn.input("Arguments: ")
+            return vim.split(args_str, " +")
+          end,
+          cwd = "${workspaceFolder}",
+        },
+        {
+          type = "python",
+          request = "launch",
+          name = "Launch module",
+          module = function()
+            return vim.fn.input("Module: ")
+          end,
+          cwd = "${workspaceFolder}",
+        },
+        {
+          type = "python",
+          request = "launch",
+          name = "Django",
+          program = "${workspaceFolder}/manage.py",
+          args = { "runserver", "--noreload" },
+          django = true,
+          cwd = "${workspaceFolder}",
+        },
+        {
+          type = "python",
+          request = "launch",
+          name = "FastAPI (uvicorn)",
+          module = "uvicorn",
+          args = function()
+            local app = vim.fn.input("App module (e.g. main:app): ", "main:app")
+            return { app, "--reload" }
+          end,
+          cwd = "${workspaceFolder}",
+        },
+        {
+          type = "python",
+          request = "launch",
+          name = "pytest",
+          module = "pytest",
+          args = { "${file}", "-v", "--tb=short" },
+          cwd = "${workspaceFolder}",
+        },
+        {
+          type = "python",
+          request = "attach",
+          name = "Attach to remote",
+          connect = function()
+            local host = vim.fn.input("Host (127.0.0.1): ", "127.0.0.1")
+            local port = tonumber(vim.fn.input("Port (5678): ", "5678"))
+            return { host = host, port = port }
+          end,
+        },
+      }
+
+      -- Go debugging with delve
+      -- Requires: MasonInstall delve
+      dap.adapters.delve = {
+        type = "server",
+        port = "${port}",
+        executable = {
+          command = "dlv",
+          args = { "dap", "-l", "127.0.0.1:${port}" },
+        },
+      }
+
+      dap.configurations.go = {
+        {
+          type = "delve",
+          name = "Launch file",
+          request = "launch",
+          program = "${file}",
+        },
+        {
+          type = "delve",
+          name = "Launch package",
+          request = "launch",
+          program = "${workspaceFolder}",
+        },
+        {
+          type = "delve",
+          name = "Launch test",
+          request = "launch",
+          mode = "test",
+          program = "${file}",
+        },
+        {
+          type = "delve",
+          name = "Launch test (package)",
+          request = "launch",
+          mode = "test",
+          program = "${workspaceFolder}",
+        },
+        {
+          type = "delve",
+          name = "Attach to process",
+          request = "attach",
+          mode = "local",
+          processId = require("dap.utils").pick_process,
+        },
+      }
+
+      -- Rust/C/C++ debugging with codelldb
+      -- Requires: MasonInstall codelldb
+      dap.adapters.codelldb = {
+        type = "server",
+        port = "${port}",
+        executable = {
+          command = vim.fn.stdpath("data") .. "/mason/bin/codelldb",
+          args = { "--port", "${port}" },
+        },
+      }
+
+      for _, lang in ipairs({ "rust", "c", "cpp" }) do
+        dap.configurations[lang] = {
+          {
+            type = "codelldb",
+            request = "launch",
+            name = "Launch executable",
+            program = function()
+              return vim.fn.input("Executable: ", vim.fn.getcwd() .. "/target/debug/", "file")
+            end,
+            cwd = "${workspaceFolder}",
+            stopOnEntry = false,
+          },
+          {
+            type = "codelldb",
+            request = "launch",
+            name = "Launch with arguments",
+            program = function()
+              return vim.fn.input("Executable: ", vim.fn.getcwd() .. "/target/debug/", "file")
+            end,
+            args = function()
+              return vim.split(vim.fn.input("Arguments: "), " +")
+            end,
+            cwd = "${workspaceFolder}",
+          },
+        }
+      end
+
+      -- Bash debugging with bash-debug-adapter
+      -- Requires: MasonInstall bash-debug-adapter
+      dap.adapters.bashdb = {
+        type = "executable",
+        command = vim.fn.stdpath("data") .. "/mason/packages/bash-debug-adapter/bash-debug-adapter",
+        name = "bashdb",
+      }
+
+      dap.configurations.sh = {
+        {
+          type = "bashdb",
+          request = "launch",
+          name = "Launch script",
+          showDebugOutput = true,
+          pathBashdb = vim.fn.stdpath("data") .. "/mason/packages/bash-debug-adapter/extension/bashdb_dir/bashdb",
+          pathBashdbLib = vim.fn.stdpath("data") .. "/mason/packages/bash-debug-adapter/extension/bashdb_dir",
+          trace = true,
+          file = "${file}",
+          program = "${file}",
+          cwd = "${workspaceFolder}",
+          pathCat = "cat",
+          pathBash = "/bin/bash",
+          pathMkfifo = "mkfifo",
+          pathPkill = "pkill",
+          env = {},
+          args = {},
+        },
+      }
+    end,
+  },
+
+  -- Mason DAP integration
+  {
+    "jay-babu/mason-nvim-dap.nvim",
+    dependencies = { "williamboman/mason.nvim", "mfussenegger/nvim-dap" },
+    opts = {
+      ensure_installed = { "js-debug-adapter", "debugpy", "delve", "codelldb", "bash-debug-adapter" },
+      automatic_installation = true,
+      handlers = {},
+    },
+  },
+
+  -- DAP UI
+  {
+    "rcarriga/nvim-dap-ui",
+    dependencies = { "mfussenegger/nvim-dap", "nvim-neotest/nvim-nio" },
+    config = function()
+      local dap = require("dap")
+      local dapui = require("dapui")
+
+      dapui.setup({
+        icons = { expanded = "▾", collapsed = "▸", current_frame = "▸" },
+        mappings = {
+          expand = { "<CR>", "<2-LeftMouse>" },
+          open = "o",
+          remove = "d",
+          edit = "e",
+          repl = "r",
+          toggle = "t",
+        },
+        layouts = {
+          {
+            elements = {
+              { id = "scopes", size = QUARTER_SIZE },
+              { id = "breakpoints", size = QUARTER_SIZE },
+              { id = "stacks", size = QUARTER_SIZE },
+              { id = "watches", size = QUARTER_SIZE },
+            },
+            size = SIDEBAR_WIDTH,
+            position = "left",
+          },
+          {
+            elements = {
+              { id = "repl", size = HALF_SIZE },
+              { id = "console", size = HALF_SIZE },
+            },
+            size = BOTTOM_PANEL_HEIGHT,
+            position = "bottom",
+          },
+        },
+        floating = {
+          border = "rounded",
+          mappings = { close = { "q", "<Esc>" } },
+        },
+      })
+
+      -- Auto open/close DAP UI on debug session lifecycle
+      local function open_dapui()
+        dapui.open()
+      end
+      local function close_dapui()
+        dapui.close()
+      end
+
+      dap.listeners.after.event_initialized["dapui_config"] = open_dapui
+      dap.listeners.before.event_terminated["dapui_config"] = close_dapui
+      dap.listeners.before.event_exited["dapui_config"] = close_dapui
+    end,
+  },
+}