Initial commit

modules/features/neovim/lua-config/init.lua

@@ -0,0 +1,9 @@
+require("options")
+require("plugins.lsp")
+require("plugins.completion")
+require("plugins.formatting")
+require("plugins.treesitter")
+require("plugins.telescope")
+require("plugins.ui")
+require("plugins.core")
+require("plugins.ai")

modules/features/neovim/lua-config/lua/options.lua

@@ -0,0 +1,138 @@
+-- Set <space> as the leader key
+-- See `:help mapleader`
+--  NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used)
+vim.g.mapleader = " "
+vim.g.maplocalleader = " "
+
+-- [[ Setting options ]]
+-- See `:help vim.o`
+-- NOTE: You can change these options as you wish!
+--  For more options, you can see `:help option-list`
+
+vim.o.expandtab = true
+vim.o.shiftwidth = 2
+vim.o.tabstop = 2
+vim.o.softtabstop = 2
+
+-- Make line numbers default
+vim.o.number = true
+-- You can also add relative line numbers, to help with jumping.
+--  Experiment for yourself to see if you like it!
+-- vim.o.relativenumber = true
+
+-- Enable mouse mode, can be useful for resizing splits for example!
+vim.o.mouse = "a"
+
+-- Don't show the mode, since it's already in the status line
+vim.o.showmode = false
+
+vim.opt.shortmess:append("Wc")
+
+-- Sync clipboard between OS and Neovim.
+--  Schedule the setting after `UiEnter` because it can increase startup-time.
+--  Remove this option if you want your OS clipboard to remain independent.
+--  See `:help 'clipboard'`
+vim.schedule(function()
+	vim.o.clipboard = "unnamedplus"
+end)
+
+-- Enable break indent
+vim.o.breakindent = true
+
+-- Save undo history
+vim.o.undofile = true
+
+-- Case-insensitive searching UNLESS \C or one or more capital letters in the search term
+vim.o.ignorecase = true
+vim.o.smartcase = true
+
+-- Keep signcolumn on by default
+vim.o.signcolumn = "yes"
+
+-- Decrease update time
+vim.o.updatetime = 250
+
+-- Decrease mapped sequence wait time
+vim.o.timeoutlen = 300
+
+-- Configure how new splits should be opened
+vim.o.splitright = true
+vim.o.splitbelow = true
+
+-- Sets how neovim will display certain whitespace characters in the editor.
+--  See `:help 'list'`
+--  and `:help 'listchars'`
+--
+--  Notice listchars is set using `vim.opt` instead of `vim.o`.
+--  It is very similar to `vim.o` but offers an interface for conveniently interacting with tables.
+--   See `:help lua-options`
+--   and `:help lua-options-guide`
+vim.o.list = true
+vim.opt.listchars = { tab = "» ", trail = "·", nbsp = "␣" }
+
+-- Preview substitutions live, as you type!
+vim.o.inccommand = "split"
+
+-- Show which line your cursor is on
+vim.o.cursorline = true
+
+-- Minimal number of screen lines to keep above and below the cursor.
+vim.o.scrolloff = 10
+
+-- if performing an operation that would fail due to unsaved changes in the buffer (like `:q`),
+-- instead raise a dialog asking if you wish to save the current file(s)
+-- See `:help 'confirm'`
+vim.o.confirm = true
+
+-- [[ Basic Keymaps ]]
+--  See `:help vim.keymap.set()`
+
+-- Clear highlights on search when pressing <Esc> in normal mode
+--  See `:help hlsearch`
+vim.keymap.set("n", "<Esc>", "<cmd>nohlsearch<CR>")
+
+-- Diagnostic keymaps
+vim.keymap.set("n", "<leader>q", vim.diagnostic.setloclist, { desc = "Open diagnostic [Q]uickfix list" })
+
+-- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier
+-- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which
+-- is not what someone will guess without a bit more experience.
+--
+-- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping
+-- or just use <C-\><C-n> to exit terminal mode
+vim.keymap.set("t", "<Esc><Esc>", "<C-\\><C-n>", { desc = "Exit terminal mode" })
+
+-- TIP: Disable arrow keys in normal mode
+-- vim.keymap.set('n', '<left>', '<cmd>echo "Use h to move!!"<CR>')
+-- vim.keymap.set('n', '<right>', '<cmd>echo "Use l to move!!"<CR>')
+-- vim.keymap.set('n', '<up>', '<cmd>echo "Use k to move!!"<CR>')
+-- vim.keymap.set('n', '<down>', '<cmd>echo "Use j to move!!"<CR>')
+
+-- Keybinds to make split navigation easier.
+--  Use CTRL+<hjkl> to switch between windows
+--
+--  See `:help wincmd` for a list of all window commands
+vim.keymap.set("n", "<C-h>", "<C-w><C-h>", { desc = "Move focus to the left window" })
+vim.keymap.set("n", "<C-l>", "<C-w><C-l>", { desc = "Move focus to the right window" })
+vim.keymap.set("n", "<C-j>", "<C-w><C-j>", { desc = "Move focus to the lower window" })
+vim.keymap.set("n", "<C-k>", "<C-w><C-k>", { desc = "Move focus to the upper window" })
+
+-- NOTE: Some terminals have colliding keymaps or are not able to send distinct keycodes
+-- vim.keymap.set("n", "<C-S-h>", "<C-w>H", { desc = "Move window to the left" })
+-- vim.keymap.set("n", "<C-S-l>", "<C-w>L", { desc = "Move window to the right" })
+-- vim.keymap.set("n", "<C-S-j>", "<C-w>J", { desc = "Move window to the lower" })
+-- vim.keymap.set("n", "<C-S-k>", "<C-w>K", { desc = "Move window to the upper" })
+
+-- [[ Basic Autocommands ]]
+--  See `:help lua-guide-autocommands`
+
+-- Highlight when yanking (copying) text
+--  Try it with `yap` in normal mode
+--  See `:help vim.hl.on_yank()`
+vim.api.nvim_create_autocmd("TextYankPost", {
+	desc = "Highlight when yanking (copying) text",
+	group = vim.api.nvim_create_augroup("kickstart-highlight-yank", { clear = true }),
+	callback = function()
+		vim.hl.on_yank()
+	end,
+})

modules/features/neovim/lua-config/lua/plugins/ai.lua

@@ -0,0 +1,72 @@
+require("lz.n").load({
+  {
+    "copilot.lua",
+    cmd = "Copilot",
+    event = "InsertEnter",
+    after = function()
+      require("copilot").setup({
+        -- Disable inline suggestions, let CodeCompanion (or blink) handle interactions
+        suggestion = { enabled = false },
+        panel = { enabled = false },
+      })
+    end,
+  },
+  {
+    "codecompanion.nvim",
+    cmd = { "CodeCompanion", "CodeCompanionChat", "CodeCompanionActions" },
+    keys = {
+      { "<leader>aa", "<cmd>CodeCompanionChat Toggle<cr>", mode = { "n", "v" }, desc = "[A]I [A]ssistant" },
+      { "<leader>ac", "<cmd>CodeCompanionActions<cr>", mode = { "n", "v" }, desc = "[A]I [C]ode Actions" },
+    },
+    after = function()
+      require("codecompanion").setup({
+        -- Set Gemini as the default strategy
+        strategies = {
+          chat = {
+            adapter = "gemini",
+          },
+          inline = {
+            adapter = "gemini",
+          },
+        },
+        -- Configure all available adapters
+        adapters = {
+          copilot = function()
+            return require("codecompanion.adapters").extend("copilot", {
+              schema = {
+                model = {
+                  default = "claude-3.5-sonnet", -- Good default for Copilot chat
+                },
+              },
+            })
+          end,
+          gemini = function()
+            return require("codecompanion.adapters").extend("gemini", {
+              env = {
+                api_key = "GEMINI_API_KEY",
+              },
+              schema = {
+                model = {
+                  default = "gemini-3.1-pro-preview",
+                },
+              },
+            })
+          end,
+          gemini_cli = function()
+            return require("codecompanion.adapters").extend("gemini_cli", {
+              -- Pass the model as a CLI argument
+              args = {
+                "--model",
+                "gemini-3.1-pro-preview",
+              },
+              -- Set authentication to use standard Google Login
+              env = {
+                auth_method = "oauth-personal",
+              },
+            })
+          end,
+        },
+      })
+    end,
+  },
+})

modules/features/neovim/lua-config/lua/plugins/completion.lua

@@ -0,0 +1,104 @@
+require("lz.n").load({
+  {
+    "friendly-snippets",
+  },
+  {
+    "luasnip",
+    before = function()
+      require("lz.n").trigger_load("friendly-snippets")
+    end,
+    after = function()
+      require("luasnip.loaders.from_vscode").lazy_load()
+      -- Load custom lua snippets
+      require("luasnip.loaders.from_lua").load({ paths = { vim.fn.stdpath("config") .. "/snippets" } })
+    end,
+  },
+  {
+    "colorful-menu.nvim",
+    after = function()
+      require("colorful-menu").setup({})
+    end,
+  },
+  {
+    "blink.cmp",
+    event = { "InsertEnter", "CmdlineEnter" },
+    before = function()
+      -- Trigger lazydev so it's ready for blink source
+      require("lz.n").trigger_load({ "lazydev.nvim", "luasnip", "colorful-menu.nvim" })
+    end,
+    after = function()
+      require("blink.cmp").setup({
+        keymap = {
+          preset = "default",
+
+          -- [Up/Down]
+          ["<C-j>"] = { "select_next", "fallback" },
+          ["<C-k>"] = { "select_prev", "fallback" }, -- Overrides Signature Help
+
+          -- [Insert Suggestion]
+          ["<tab>"] = { "select_and_accept", "fallback" },
+
+          -- [Remap Signature Help]
+          -- Since we took <C-k>, let's move signature help to <C-g> (optional)
+          ["<C-g>"] = { "show_signature", "hide_signature", "fallback" },
+        },
+
+        appearance = {
+          nerd_font_variant = "mono",
+        },
+
+        completion = {
+          documentation = {
+            auto_show = true,
+            auto_show_delay_ms = 500,
+          },
+          menu = {
+            draw = {
+              columns = { { "kind_icon" }, { "label", gap = 1 } },
+              components = {
+                label = {
+                  text = function(ctx)
+                    return require("colorful-menu").blink_components_text(ctx)
+                  end,
+                  highlight = function(ctx)
+                    return require("colorful-menu").blink_components_highlight(ctx)
+                  end,
+                },
+              },
+            },
+          },
+        },
+
+        cmdline = {
+          completion = {
+            menu = {
+              auto_show = true,
+            },
+          },
+          keymap = { preset = "inherit" },
+        },
+
+        sources = {
+          default = {
+            "lsp",
+            "path",
+            "snippets",
+            "lazydev",
+          },
+          providers = {
+            lazydev = { module = "lazydev.integrations.blink", score_offset = 100 },
+          },
+        },
+
+        snippets = { preset = "luasnip" },
+
+        fuzzy = { implementation = "prefer_rust_with_warning" },
+
+        signature = {
+          enabled = true,
+        },
+      })
+    end,
+  },
+})
+

modules/features/neovim/lua-config/lua/plugins/core.lua

@@ -0,0 +1,65 @@
+require("lz.n").load({
+  {
+    "mini.nvim",
+    event = { "BufReadPre", "BufNewFile" },
+    after = function()
+      -- Better Around/Inside textobjects
+      require("mini.ai").setup({ n_lines = 500 })
+
+      -- Add/delete/replace surroundings (brackets, quotes, etc.)
+      require("mini.surround").setup()
+
+      -- Auto-pairs (replaces nvim-autopairs)
+      require("mini.pairs").setup()
+
+      local files = require("mini.files")
+      files.setup()
+      vim.keymap.set("n", "<leader>e", function()
+        if not files.close() then
+          files.open(vim.api.nvim_buf_get_name(0))
+        end
+      end, { desc = "File [E]xplorer" })
+
+      local icons = require("mini.icons")
+      icons.setup()
+      icons.mock_nvim_web_devicons()
+
+      local hipatterns = require("mini.hipatterns")
+      hipatterns.setup({
+        highlighters = {
+          -- Highlight hex color strings (#rrggbb) using that color
+          hex_color = hipatterns.gen_highlighter.hex_color(),
+          -- Highlight TODOs, FIXMEs, etc. (replaces todo-comments.nvim)
+          fixme = { pattern = "%f[%w]()FIXME()%f[%W]", group = "MiniHipatternsFixme" },
+          hack = { pattern = "%f[%w]()HACK()%f[%W]", group = "MiniHipatternsHack" },
+          todo = { pattern = "%f[%w]()TODO()%f[%W]", group = "MiniHipatternsTodo" },
+          note = { pattern = "%f[%w]()NOTE()%f[%W]", group = "MiniHipatternsNote" },
+        },
+      })
+
+      local indentscope = require("mini.indentscope")
+      indentscope.setup({
+        symbol = "│",
+      })
+
+      vim.api.nvim_create_autocmd("FileType", {
+        pattern = { "help", "alpha", "dashboard", "neo-tree", "Trouble", "lazy", "mason" },
+        callback = function()
+          vim.b.miniindentscope_disable = true
+        end,
+      })
+    end,
+  },
+  {
+    "guess-indent.nvim",
+    event = { "BufReadPre", "BufNewFile" },
+    after = function()
+      require("guess-indent").setup({})
+    end,
+  },
+  {
+    "direnv.vim",
+    event = "BufEnter",
+  },
+})
+

modules/features/neovim/lua-config/lua/plugins/formatting.lua

@@ -0,0 +1,49 @@
+require("lz.n").load({
+  {
+    "conform.nvim",
+    event = "BufWritePre",
+    cmd = "ConformInfo",
+    keys = {
+      {
+        "<leader>f",
+        function()
+          require("conform").format({ async = true, lsp_format = "fallback" })
+        end,
+        mode = "",
+        desc = "[F]ormat buffer",
+      },
+    },
+    after = function()
+      require("conform").setup({
+        notify_on_error = true,
+        format_on_save = function(bufnr)
+          -- Disable "format_on_save lsp_fallback" for languages that don't
+          -- have a well standardized coding style. You can add additional
+          -- languages here or re-enable it for the disabled ones.
+          local disable_filetypes = { c = true, cpp = true }
+          if disable_filetypes[vim.bo[bufnr].filetype] then
+            return nil
+          else
+            return {
+              timeout_ms = 500,
+              lsp_format = "fallback",
+            }
+          end
+        end,
+        formatters_by_ft = {
+          lua = { "stylua" },
+          -- Conform can also run multiple formatters sequentially
+          python = { "isort", "black" },
+          --
+          -- You can use 'stop_after_first' to run the first available formatter from the list
+          -- javascript = { "prettierd", "prettier", stop_after_first = true },
+        },
+        formatters = {
+          stylua = {
+            prepend_args = { "--indent-type", "Spaces", "--indent-width", "2" },
+          },
+        },
+      })
+    end,
+  },
+})

modules/features/neovim/lua-config/lua/plugins/lsp.lua

@@ -0,0 +1,192 @@
+require("lz.n").load({
+  {
+    "typst-preview.nvim",
+    ft = "typst",
+    after = function()
+      -- Setup typst-preview
+      require("typst-preview").setup({
+        -- Optionally configure things here
+        dependencies_bin = {
+          -- For example, use tinymist as the LSP if that's what you are running
+        },
+      })
+
+      vim.keymap.set("n", "<leader>tp", "<cmd>TypstPreviewToggle<cr>", { desc = "[T]ypst [P]review Toggle" })
+    end,
+  },
+  {
+    "lazydev.nvim",
+    cmd = "LazyDev",
+    ft = "lua",
+    after = function()
+      require("lazydev").setup({
+        library = {
+          { words = { "nixCats", "settings" }, path = "nix-info" },
+        },
+      })
+    end,
+  },
+  {
+    "nvim-lspconfig",
+    event = { "BufReadPre", "BufNewFile" },
+    before = function()
+      require("lz.n").trigger_load("lazydev.nvim")
+    end,
+    after = function()
+      vim.api.nvim_create_autocmd("LspAttach", {
+        group = vim.api.nvim_create_augroup("kickstart-lsp-attach", { clear = true }),
+        callback = function(args)
+          -- Get the client and buffer from the event arguments [cite: 119]
+          local client = vim.lsp.get_client_by_id(args.data.client_id)
+          local bufnr = args.buf
+
+          local map = function(keys, func, desc, mode)
+            mode = mode or "n"
+            vim.keymap.set(mode, keys, func, { buffer = bufnr, desc = "LSP: " .. desc })
+          end
+
+          -- Standard LSP functions
+          map("<leader>rn", vim.lsp.buf.rename, "[R]e[n]ame")
+          map("<leader>ca", vim.lsp.buf.code_action, "[C]ode [A]ction", { "n", "x" })
+          map("gD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")
+          map("K", vim.lsp.buf.hover, "Hover Documentation")
+
+          -- Telescope Mappings
+          map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition")
+          map("gr", require("telescope.builtin").lsp_references, "[G]oto [R]eferences")
+          map("gI", require("telescope.builtin").lsp_implementations, "[G]oto [I]mplementation")
+          map("<leader>D", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition")
+          map("<leader>ds", require("telescope.builtin").lsp_document_symbols, "[D]ocument [S]ymbols")
+          map("<leader>ws", require("telescope.builtin").lsp_dynamic_workspace_symbols, "[W]orkspace [S]ymbols")
+
+          -- Highlight references (Document Highlight)
+          if client and client:supports_method("textDocument/documentHighlight", bufnr) then
+            local highlight_augroup = vim.api.nvim_create_augroup("kickstart-lsp-highlight", { clear = false })
+            vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, {
+              buffer = bufnr,
+              group = highlight_augroup,
+              callback = vim.lsp.buf.document_highlight,
+            })
+
+            vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, {
+              buffer = bufnr,
+              group = highlight_augroup,
+              callback = vim.lsp.buf.clear_references,
+            })
+
+            vim.api.nvim_create_autocmd("LspDetach", {
+              group = vim.api.nvim_create_augroup("kickstart-lsp-detach", { clear = true }),
+              callback = function(event)
+                vim.lsp.buf.clear_references()
+                vim.api.nvim_clear_autocmds({ group = "kickstart-lsp-highlight", buffer = event.buf })
+              end,
+            })
+          end
+
+          -- Inlay Hints
+          if client and client:supports_method("textDocument/inlayHint", bufnr) then
+            vim.lsp.inlay_hint.enable(true, { bufnr = bufnr })
+            map("<leader>th", function()
+              vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }))
+            end, "[T]oggle Inlay [H]ints")
+          end
+        end,
+      })
+
+      -- 1. Setup Diagnostics (Visuals)
+      vim.diagnostic.config({
+        severity_sort = true,
+        -- underline = { severity = vim.diagnostic.severity.ERROR },
+        signs = {
+          text = {
+            [vim.diagnostic.severity.ERROR] = " ",
+            [vim.diagnostic.severity.WARN] = " ",
+            [vim.diagnostic.severity.INFO] = " ",
+            [vim.diagnostic.severity.HINT] = "󰠠 ",
+          },
+        },
+        virtual_text = {
+          source = "if_many",
+          spacing = 4,
+          prefix = "●",
+          format = function(diagnostic)
+            local diagnostic_message = {
+              [vim.diagnostic.severity.ERROR] = diagnostic.message,
+              [vim.diagnostic.severity.WARN] = diagnostic.message,
+              [vim.diagnostic.severity.INFO] = diagnostic.message,
+              [vim.diagnostic.severity.HINT] = diagnostic.message,
+            }
+            return diagnostic_message[diagnostic.severity]
+          end,
+        },
+      })
+
+      vim.lsp.config("lua_ls", {
+        settings = {
+          Lua = {
+            runtime = { version = "LuaJIT" },
+            signatureHelp = { enabled = true },
+            diagnostics = { globals = { "nixCats", "vim" } },
+            telemetry = { enabled = false },
+            completion = { callSnippet = "Replace" },
+          },
+        },
+      })
+      vim.lsp.enable("lua_ls")
+
+      local settings = require("nix-info").settings
+
+      -- Nix
+      vim.lsp.config("nixd", {
+        settings = {
+          nixd = {
+            nixpkgs = { expr = settings.nixdExtras.nixpkgs },
+            options = {
+              nixos = { expr = settings.nixdExtras.nixos_options },
+              ["home-manager"] = { expr = settings.nixdExtras.home_manager_options },
+            },
+            formatting = { command = { "nixfmt" } },
+          },
+        },
+      })
+      vim.lsp.enable("nixd")
+
+      -- Dafny
+      vim.lsp.enable("dafny")
+
+      -- TypeScript/JS
+      vim.lsp.enable("ts_ls")
+
+      -- Rust
+      vim.lsp.enable("rust_analyzer")
+
+      -- Python
+      vim.lsp.enable("ty")
+      vim.lsp.enable("ruff")
+
+      vim.lsp.enable("astro")
+
+      vim.lsp.config("tinymist", {
+        settings = {
+          tinymist = {
+            formatterMode = "typstyle",
+          },
+        },
+      })
+      vim.lsp.enable("tinymist")
+    end,
+  },
+  {
+    "trouble.nvim",
+    cmd = "Trouble",
+    keys = {
+      { "<leader>xx", "<cmd>Trouble diagnostics toggle<cr>", desc = "Diagnostics (Trouble)" },
+      { "<leader>xX", "<cmd>Trouble diagnostics toggle filter.buf=0<cr>", desc = "Buffer Diagnostics (Trouble)" },
+    },
+    after = function()
+      require("trouble").setup({
+        focus = true,
+      })
+    end,
+  },
+})

modules/features/neovim/lua-config/lua/plugins/telescope.lua

@@ -0,0 +1,101 @@
+require("lz.n").load({
+  {
+    "project.nvim",
+    event = { "VimEnter" }, -- Load early to set root correctly
+    after = function()
+      require("project").setup({
+        -- 1. Automagically change directory to project root
+        manual_mode = false,
+
+        -- LSP detection
+        lsp = { enabled = true },
+
+        -- Files/folders that indicate a root
+        patterns = { ".git", "_darcs", ".hg", ".bzr", ".svn", "Makefile", "package.json", "flake.nix" },
+
+        -- Show hidden files in telescope
+        show_hidden = true,
+
+        -- When the project scope changes, change the directory
+        scope_chdir = "global",
+      })
+    end,
+  },
+  {
+    "telescope.nvim",
+    event = "VimEnter",
+    before = function()
+      require("lz.n").trigger_load("project.nvim")
+    end,
+    after = function()
+      local actions = require("telescope.actions")
+
+      require("telescope").setup({
+        defaults = {
+          path_display = { "truncate" },
+          layout_strategy = "horizontal",
+          layout_config = {
+            prompt_position = "top",
+          },
+          sorting_strategy = "ascending",
+          mappings = {
+            i = {
+              ["<C-k>"] = actions.move_selection_previous, -- Move up with Ctrl-k
+              ["<C-j>"] = actions.move_selection_next, -- Move down with Ctrl-j
+              ["<C-q>"] = actions.send_selected_to_qflist + actions.open_qflist, -- Send to quickfix
+            },
+          },
+        },
+        extensions = {
+          ["ui-select"] = {
+            require("telescope.themes").get_dropdown(),
+          },
+        },
+      })
+
+      -- Enable Telescope extensions if they are installed
+      pcall(require("telescope").load_extension, "projects")
+      pcall(require("telescope").load_extension, "fzf")
+      pcall(require("telescope").load_extension, "ui-select")
+
+      -- See `:help telescope.builtin`
+      local builtin = require("telescope.builtin")
+      vim.keymap.set("n", "<leader>sh", builtin.help_tags, { desc = "[S]earch [H]elp" })
+      vim.keymap.set("n", "<leader>sk", builtin.keymaps, { desc = "[S]earch [K]eymaps" })
+      vim.keymap.set("n", "<leader>sf", builtin.find_files, { desc = "[S]earch [F]iles" })
+      vim.keymap.set("n", "<leader>ss", builtin.builtin, { desc = "[S]earch [S]elect Telescope" })
+      vim.keymap.set("n", "<leader>sw", builtin.grep_string, { desc = "[S]earch current [W]ord" })
+      vim.keymap.set("n", "<leader>sg", builtin.live_grep, { desc = "[S]earch by [G]rep" })
+      vim.keymap.set("n", "<leader>sd", builtin.diagnostics, { desc = "[S]earch [D]iagnostics" })
+      vim.keymap.set("n", "<leader>sr", builtin.resume, { desc = "[S]earch [R]esume" })
+      vim.keymap.set("n", "<leader>s.", builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })
+      vim.keymap.set("n", "<leader><leader>", builtin.buffers, { desc = "[ ] Find existing buffers" })
+      vim.keymap.set("n", "<leader>sp", function()
+        require("telescope").extensions.projects.projects({})
+      end, { desc = "[S]earch [P]rojects" })
+
+      -- Slightly advanced example of overriding default behavior and theme
+      vim.keymap.set("n", "<leader>/", function()
+        -- You can pass additional configuration to Telescope to change the theme, layout, etc.
+        builtin.current_buffer_fuzzy_find(require("telescope.themes").get_dropdown({
+          winblend = 10,
+          previewer = false,
+        }))
+      end, { desc = "[/] Fuzzily search in current buffer" })
+
+      -- It's also possible to pass additional configuration options.
+      --  See `:help telescope.builtin.live_grep()` for information about particular keys
+      vim.keymap.set("n", "<leader>s/", function()
+        builtin.live_grep({
+          grep_open_files = true,
+          prompt_title = "Live Grep in Open Files",
+        })
+      end, { desc = "[S]earch [/] in Open Files" })
+
+      -- Shortcut for searching your Neovim configuration files
+      vim.keymap.set("n", "<leader>sn", function()
+        builtin.find_files({ cwd = vim.fn.stdpath("config") })
+      end, { desc = "[S]earch [N]eovim files" })
+    end,
+  },
+})

modules/features/neovim/lua-config/lua/plugins/treesitter.lua

@@ -0,0 +1,28 @@
+local ok, treesitter = pcall(require, "nvim-treesitter")
+
+if not ok then
+  return
+end
+
+treesitter.setup({})
+
+local group = vim.api.nvim_create_augroup("lux-treesitter", { clear = true })
+local enableTreesitter = function(bufnr)
+  vim.schedule(function()
+    if not vim.api.nvim_buf_is_valid(bufnr) then
+      return
+    end
+
+    if pcall(vim.treesitter.start, bufnr) then
+      vim.bo[bufnr].indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"
+    end
+  end)
+end
+
+vim.api.nvim_create_autocmd({ "BufEnter", "BufWinEnter", "FileType" }, {
+  group = group,
+  pattern = "*",
+  callback = function(args)
+    enableTreesitter(args.buf)
+  end,
+})

modules/features/neovim/lua-config/lua/plugins/typst.lua

@@ -0,0 +1 @@
+require("lz.n").load({})

modules/features/neovim/lua-config/lua/plugins/ui.lua

@@ -0,0 +1,81 @@
+require("lz.n").load({
+  {
+    "theme-loader",
+    event = "VimEnter",
+    load = function()
+      local settings = require("nix-info").settings
+      local theme_code = settings.themeSetup
+
+      local func, err = loadstring(theme_code)
+      if func then
+        func()
+      else
+        print("Error loading theme code: " .. err)
+      end
+
+    end,
+  },
+  {
+    "lualine.nvim",
+    event = "VimEnter",
+    after = function()
+      require("lualine").setup({
+        options = {
+          icons_enabled = true,
+          globalstatus = true,
+          component_separators = "",
+          section_separators = "",
+        },
+        sections = {
+          lualine_a = { "mode" },
+          lualine_b = { "branch", "diagnostics" },
+          lualine_c = { "filename" },
+
+          lualine_x = { "lsp_status" },
+          lualine_y = { "progress" },
+          lualine_z = { "location" },
+        },
+      })
+    end,
+  },
+  {
+    "zen-mode.nvim",
+    cmd = "ZenMode",
+    after = function()
+      require("zen-mode").setup({
+        window = {
+          options = {
+            linebreak = true,
+          },
+        },
+      })
+    end,
+  },
+  {
+    "which-key.nvim",
+    event = "VimEnter",
+    before = function()
+      require("lz.n").trigger_load("mini.nvim")
+    end,
+    after = function()
+      require("which-key").setup({
+        preset = "modern",
+        delay = 200,
+        icons = {
+          -- set icon mappings to true if you have a Nerd Font
+          mappings = true,
+          -- If you are using a Nerd Font: set icons.keys to an empty table which will use the
+          -- default which-key.nvim defined Nerd Font icons, otherwise define a string table
+          keys = {},
+        },
+
+        -- Document existing key chains
+        spec = {
+          { "<leader>s", group = "[S]earch" },
+          { "<leader>t", group = "[T]oggle" },
+          { "<leader>h", group = "Git [H]unk", mode = { "n", "v" } },
+        },
+      })
+    end,
+  },
+})

modules/features/neovim/lua-config/snippets/nix.lua

@@ -0,0 +1,91 @@
+local ls = require("luasnip")
+local s = ls.snippet
+local t = ls.text_node
+local i = ls.insert_node
+
+return {
+  -- Full lux module (both nixos and homeManager)
+  s("luxmod", {
+    t({
+      "{ inputs, ... }:",
+      "{",
+      "  lux."
+    }),
+    i(1, "moduleName"),
+    t({
+      " = {",
+      "    nixos = { config, lib, pkgs, ... }: {",
+      "      "
+    }),
+    i(2),
+    t({
+      "",
+      "    };",
+      "",
+      "    homeManager = { config, lib, pkgs, ... }: {",
+      "      "
+    }),
+    i(3),
+    t({
+      "",
+      "    };",
+      "  };",
+      "}",
+    }),
+  }),
+
+  -- lux nixos only module
+  s("luxnixos", {
+    t({
+      "{ inputs, ... }:",
+      "{",
+      "  lux."
+    }),
+    i(1, "moduleName"),
+    t({
+      ".nixos = { config, lib, pkgs, ... }: {",
+      "    "
+    }),
+    i(0),
+    t({
+      "",
+      "  };",
+      "}",
+    }),
+  }),
+
+  -- lux homeManager only module
+  s("luxhm", {
+    t({
+      "{ inputs, ... }:",
+      "{",
+      "  lux."
+    }),
+    i(1, "moduleName"),
+    t({
+      ".homeManager = { config, lib, pkgs, ... }: {",
+      "    "
+    }),
+    i(0),
+    t({
+      "",
+      "  };",
+      "}",
+    }),
+  }),
+
+  -- den inline aspect
+  s("denaspect", {
+    t({
+      "(",
+      "  { host, user, ... }: {",
+      "    "
+    }),
+    i(0),
+    t({
+      "",
+      "  }",
+      ")"
+    }),
+  }),
+}