Initial commit

home/programs/nixCats/.stylua.toml

@@ -0,0 +1,2 @@
+indent_type = "Spaces"
+indent_width = 2

home/programs/nixCats/default.nix

@@ -0,0 +1,155 @@
+{ inputs, config, ... }:
+let
+  inherit (inputs.nixCats) utils;
+  luaPath = ./.;
+  categoryDefinitions =
+    { pkgs, ... }:
+    {
+      # to define and use a new category, simply add a new list to a set here,
+      # and later, you will include categoryname = true; in the set you
+      # provide when you build the package using this builder function.
+      # see :help nixCats.flake.outputs.packageDefinitions for info on that section.
+
+      # lspsAndRuntimeDeps:
+      # this section is for dependencies that should be available
+      # at RUN TIME for plugins. Will be available to PATH within neovim terminal
+      # this includes LSPs
+      lspsAndRuntimeDeps = {
+        general = with pkgs; [
+          universal-ctags
+          stdenv.cc.cc
+          ripgrep
+          fd
+
+          stylua
+          lua-language-server
+
+          nixd
+          nix-doc
+          nixfmt
+
+          dafny
+
+          typescript
+          typescript-language-server
+
+          rust-analyzer
+          rustfmt
+
+          markdownlint-cli2
+
+          basedpyright
+          black
+          isort
+        ];
+      };
+
+      startupPlugins = {
+        general = with pkgs.vimPlugins; [
+          lz-n
+          plenary-nvim
+          catppuccin-nvim
+        ];
+      };
+
+      optionalPlugins = {
+        general = with pkgs.vimPlugins; [
+          nvim-treesitter.withAllGrammars
+          nvim-treesitter-textobjects
+          nvim-treesitter-context
+          trouble-nvim
+
+          guess-indent-nvim
+          gitsigns-nvim
+          which-key-nvim
+
+          telescope-nvim
+          telescope-fzf-native-nvim
+          telescope-ui-select-nvim
+
+          conform-nvim
+          blink-cmp
+          luasnip
+          friendly-snippets
+
+          todo-comments-nvim
+          mini-nvim
+
+          nvim-lspconfig
+          lazydev-nvim
+          nvim-autopairs
+          indent-blankline-nvim
+          nvim-lint
+
+          render-markdown-nvim
+
+          colorful-menu-nvim
+        ];
+      };
+
+      sharedLibraries = {
+        general = with pkgs; [ ];
+      };
+
+      environmentVariables = { };
+      extraWrapperArgs = { };
+      python3.libraries = {
+        test = (_: [ ]);
+      };
+      extraLuaPackages = {
+        general = [ (_: [ ]) ];
+      };
+      extraCats = { };
+    };
+
+  packageDefinitions = {
+    nixCats =
+      { pkgs, ... }:
+      {
+        settings = {
+          suffix-path = true;
+          suffix-LD = true;
+          aliases = [
+            "nvim"
+            "vim"
+            "vi"
+          ];
+          wrapRc = true;
+          configDirName = "nixCats";
+          hosts.python3.enable = true;
+          hosts.node.enable = true;
+        };
+
+        categories = {
+          general = true;
+        };
+
+        extra = {
+          nixdExtras = {
+            nixpkgs = ''import ${pkgs.path} {}'';
+            nixos_options = ''(builtins.getFlake "path:///home/kiri/.config/nixos").nixosConfigurations.${toString config.var.hostname}.options'';
+            home_manager_options = ''(builtins.getFlake "path:///home/kiri/.config/nixos").nixosConfigurations.${toString config.var.hostname}.options.home-manager.users.type.getSubOptions []'';
+          };
+        };
+      };
+
+  };
+
+  defaultPackageName = "nixCats";
+in
+{
+  imports = [
+    (utils.mkHomeModules {
+      inherit
+        defaultPackageName
+        luaPath
+        categoryDefinitions
+        packageDefinitions
+        ;
+      inherit (inputs) nixpkgs;
+      dependencyOverlays = [ (utils.standardPluginOverlay inputs) ];
+    })
+  ];
+
+  nixCats.enable = true;
+}

home/programs/nixCats/init.lua

@@ -0,0 +1,5 @@
+require("options")
+require("plugins.ui")
+require("plugins.editor")
+require("plugins.coding")
+require("plugins.lsp")

home/programs/nixCats/lua/options.lua

@@ -0,0 +1,133 @@
+-- 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`
+
+-- 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,
+})

home/programs/nixCats/lua/plugins/coding.lua

@@ -0,0 +1,263 @@
+require("lz.n").load({
+  -- {
+  --   "nvim-treesitter-context",
+  --   event = "BufReadPost",
+  --   after = function()
+  --     require("treesitter-context").setup({
+  --       enable = true,
+  --       max_lines = 3, -- How many lines the window should span
+  --     })
+  --   end,
+  -- },
+  {
+    "nvim-lint",
+    event = { "BufReadPre", "BufNewFile" },
+    after = function()
+      local lint = require("lint")
+      lint.linters_by_ft = {
+        markdown = { "markdownlint-cli2" },
+      }
+
+      -- Create autocommand which carries out the actual linting
+      -- on the specified events.
+      local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true })
+      vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave" }, {
+        group = lint_augroup,
+        callback = function()
+          -- Only run the linter in buffers that you can modify in order to
+          -- avoid superfluous noise, notably within the handy LSP pop-ups that
+          -- describe the hovered symbol using Markdown.
+          if vim.bo.modifiable then
+            lint.try_lint()
+          end
+        end,
+      })
+    end,
+  },
+  {
+    "nvim-autopairs",
+    event = "InsertEnter",
+    after = function()
+      require("nvim-autopairs").setup({
+        check_ts = true,
+      })
+    end,
+  },
+  {
+    "nvim-treesitter",
+    dep_of = "render-markdown.nvim",
+    -- cmd = { "" },
+    event = "DeferredUIEnter",
+    -- ft = "",
+    -- keys = "",
+    -- colorscheme = "",
+    load = function(name)
+      vim.cmd.packadd(name)
+      vim.cmd.packadd("nvim-treesitter-textobjects")
+    end,
+    after = function()
+      -- [[ Configure Treesitter ]]
+      -- See `:help nvim-treesitter`
+      require("nvim-treesitter.configs").setup({
+        highlight = { enable = true },
+        indent = { enable = true },
+        incremental_selection = {
+          enable = true,
+          keymaps = {
+            init_selection = "<c-space>",
+            node_incremental = "<c-space>",
+            scope_incremental = "<c-s>",
+            node_decremental = "<M-space>",
+          },
+        },
+        textobjects = {
+          select = {
+            enable = true,
+            lookahead = true, -- Automatically jump forward to textobj, similar to targets.vim
+            keymaps = {
+              -- You can use the capture groups defined in textobjects.scm
+              ["aa"] = "@parameter.outer",
+              ["ia"] = "@parameter.inner",
+              ["af"] = "@function.outer",
+              ["if"] = "@function.inner",
+              ["ac"] = "@class.outer",
+              ["ic"] = "@class.inner",
+            },
+          },
+          move = {
+            enable = true,
+            set_jumps = true, -- whether to set jumps in the jumplist
+            goto_next_start = {
+              ["]m"] = "@function.outer",
+              ["]]"] = "@class.outer",
+            },
+            goto_next_end = {
+              ["]M"] = "@function.outer",
+              ["]["] = "@class.outer",
+            },
+            goto_previous_start = {
+              ["[m"] = "@function.outer",
+              ["[["] = "@class.outer",
+            },
+            goto_previous_end = {
+              ["[M"] = "@function.outer",
+              ["[]"] = "@class.outer",
+            },
+          },
+          swap = {
+            enable = true,
+            swap_next = {
+              ["<leader>a"] = "@parameter.inner",
+            },
+            swap_previous = {
+              ["<leader>A"] = "@parameter.inner",
+            },
+          },
+        },
+      })
+    end,
+  },
+  {
+    "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 },
+        },
+      })
+    end,
+  },
+  {
+    "friendly-snippets",
+  },
+  {
+    "luasnip",
+    before = function()
+      require("lz.n").trigger_load("friendly-snippets")
+    end,
+    after = function()
+      require("luasnip.loaders.from_vscode").lazy_load()
+    end,
+  },
+  {
+    "blink.cmp",
+    before = function()
+      -- Trigger lazydev so it's ready for blink source
+      require("lz.n").trigger_load({ "lazydev.nvim", "luasnip" })
+    end,
+    event = "VimEnter",
+    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]
+          ["<C-l>"] = { "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 = {
+          -- By default, you may press `<c-space>` to show the documentation.
+          -- Optionally, set `auto_show = true` to show the documentation after a delay.
+          documentation = {
+            auto_show = true,
+            auto_show_delay_ms = 500,
+            window = {
+              border = "rounded",
+            },
+          },
+          menu = {
+            border = "rounded",
+            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" },
+
+        -- Shows a signature help window while you type arguments for a function
+        signature = {
+          window = { border = "rounded" },
+          enabled = true,
+        },
+      })
+    end,
+  },
+})

home/programs/nixCats/lua/plugins/editor.lua

@@ -0,0 +1,170 @@
+require("lz.n").load({
+  {
+    "guess-indent.nvim",
+    event = "BufReadPre",
+    after = function()
+      require("guess-indent").setup({})
+    end,
+  },
+  {
+    "gitsigns.nvim",
+    event = { "BufReadPre", "BufNewFile" },
+    after = function()
+      require("gitsigns").setup({
+        signs = {
+          add = { text = "▎" },
+          change = { text = "▎" },
+          delete = { text = "" },
+          topdelete = { text = "" },
+          changedelete = { text = "▎" },
+        },
+        on_attach = function(bufnr)
+          local gitsigns = require("gitsigns")
+
+          local function map(mode, l, r, opts)
+            opts = opts or {}
+            opts.buffer = bufnr
+            vim.keymap.set(mode, l, r, opts)
+          end
+
+          -- Navigation
+          map("n", "]c", function()
+            if vim.wo.diff then
+              vim.cmd.normal({ "]c", bang = true })
+            else
+              gitsigns.nav_hunk("next")
+            end
+          end, { desc = "Jump to next git [c]hange" })
+
+          map("n", "[c", function()
+            if vim.wo.diff then
+              vim.cmd.normal({ "[c", bang = true })
+            else
+              gitsigns.nav_hunk("prev")
+            end
+          end, { desc = "Jump to previous git [c]hange" })
+
+          -- Actions
+          -- visual mode
+          map("v", "<leader>hs", function()
+            gitsigns.stage_hunk({ vim.fn.line("."), vim.fn.line("v") })
+          end, { desc = "git [s]tage hunk" })
+          map("v", "<leader>hr", function()
+            gitsigns.reset_hunk({ vim.fn.line("."), vim.fn.line("v") })
+          end, { desc = "git [r]eset hunk" })
+          -- normal mode
+          map("n", "<leader>hs", gitsigns.stage_hunk, { desc = "git [s]tage hunk" })
+          map("n", "<leader>hr", gitsigns.reset_hunk, { desc = "git [r]eset hunk" })
+          map("n", "<leader>hS", gitsigns.stage_buffer, { desc = "git [S]tage buffer" })
+          map("n", "<leader>hu", gitsigns.stage_hunk, { desc = "git [u]ndo stage hunk" })
+          map("n", "<leader>hR", gitsigns.reset_buffer, { desc = "git [R]eset buffer" })
+          map("n", "<leader>hp", gitsigns.preview_hunk, { desc = "git [p]review hunk" })
+          map("n", "<leader>hb", gitsigns.blame_line, { desc = "git [b]lame line" })
+          map("n", "<leader>hd", gitsigns.diffthis, { desc = "git [d]iff against index" })
+          map("n", "<leader>hD", function()
+            gitsigns.diffthis("@")
+          end, { desc = "git [D]iff against last commit" })
+          -- Toggles
+          map("n", "<leader>tb", gitsigns.toggle_current_line_blame, { desc = "[T]oggle git show [b]lame line" })
+          map("n", "<leader>tD", gitsigns.preview_hunk_inline, { desc = "[T]oggle git show [D]eleted" })
+        end,
+      })
+    end,
+  },
+  {
+    "telescope.nvim",
+    event = "VimEnter",
+    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, "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" })
+
+      -- 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,
+  },
+  {
+    "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,
+  },
+  {
+    "todo-comments.nvim",
+    event = { "BufReadPre", "BufNewFile" },
+    keys = {
+      { "<leader>st", "<cmd>TodoTelescope<cr>", desc = "[S]earch [T]odos" },
+      { "<leader>xt", "<cmd>TodoTrouble<cr>", desc = "Todo (Trouble)" },
+    },
+    after = function()
+      require("todo-comments").setup({
+        signs = false,
+      })
+    end,
+  },
+})

home/programs/nixCats/lua/plugins/lsp.lua

@@ -0,0 +1,166 @@
+require("lz.n").load({
+  {
+    {
+      -- lazydev makes your lsp way better in your config without needing extra lsp configuration.
+      "lazydev.nvim",
+      cmd = "LazyDev",
+      ft = "lua",
+      after = function()
+        require("lazydev").setup({
+          library = {
+            { words = { "nixCats" }, path = (nixCats.nixCatsPath or "") .. "/lua" },
+          },
+        })
+      end,
+    },
+    {
+      "nvim-lspconfig",
+      event = { "BufReadPre", "BufNewFile" },
+      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
+
+            -- Mappings (Standard LSP functions from lsp-defaults) [cite: 20-23]
+            map("grn", vim.lsp.buf.rename, "[R]e[n]ame")
+            map("gra", vim.lsp.buf.code_action, "[G]oto Code [A]ction", { "n", "x" })
+            map("grD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")
+
+            -- Telescope Mappings
+            map("grr", require("telescope.builtin").lsp_references, "[G]oto [R]eferences")
+            map("gri", require("telescope.builtin").lsp_implementations, "[G]oto [I]mplementation")
+            map("grd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition")
+            map("gO", require("telescope.builtin").lsp_document_symbols, "Open Document Symbols")
+            map("gW", require("telescope.builtin").lsp_dynamic_workspace_symbols, "Open Workspace Symbols")
+            map("grt", require("telescope.builtin").lsp_type_definitions, "[G]oto [T]ype Definition")
+
+            -- 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
+              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,
+          float = { border = "rounded", source = "if_many" },
+          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")
+
+        -- Nix
+        vim.lsp.config("nixd", {
+          settings = {
+            nixd = {
+              nixpkgs = { expr = nixCats.extra("nixdExtras.nixpkgs") },
+              options = {
+                nixos = { expr = nixCats.extra("nixdExtras.nixos_options") },
+                ["home-manager"] = { expr = nixCats.extra("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.config("basedpyright", {
+          settings = {
+            basedpyright = {
+              analysis = {
+                autoSearchPaths = true,
+                useLibraryCodeForTypes = true,
+                diagnosticMode = "openFilesOnly",
+                typeCheckingMode = "standard",
+                inlayHints = {
+                  variableTypes = true,
+                  callArgumentNames = true,
+                  functionReturnTypes = true,
+                },
+              },
+            },
+          },
+        })
+        vim.lsp.enable("basedpyright")
+      end,
+    },
+  },
+})

home/programs/nixCats/lua/plugins/ui.lua

@@ -0,0 +1,158 @@
+require("lz.n").load({
+  {
+    "catppuccin-nvim",
+    event = "VimEnter",
+    after = function()
+      require("catppuccin").setup({
+        flavour = "mocha",
+        term_colors = true,
+        dim_inactive = {
+          enabled = true,
+          shade = "dark",
+          percentage = 0.15,
+        },
+        integrations = {
+          gitsigns = true,
+          telescope = true,
+          treesitter = true,
+          treesitter_context = true,
+          markdown = true,
+          which_key = true,
+          blink_cmp = {
+            style = "bordered",
+          },
+        },
+
+        native_lsp = {
+          enabled = true,
+          virtual_text = {
+            errors = { "italic" },
+            hints = { "italic" },
+            warnings = { "italic" },
+            information = { "italic" },
+          },
+          underlines = {
+            errors = { "underline" },
+            hints = { "underline" },
+            warnings = { "underline" },
+            information = { "underline" },
+          },
+          inlay_hints = {
+            background = true,
+          },
+        },
+      })
+
+      vim.cmd.colorscheme("catppuccin")
+    end,
+  },
+  {
+    "colorful-menu.nvim",
+    after = function()
+      require("colorful-menu").setup({})
+    end,
+  },
+  {
+    "indent-blankline.nvim",
+    event = "User FileOpened",
+    after = function()
+      require("ibl").setup({
+        indent = { char = "|" },
+        scope = {
+          enabled = false,
+          show_start = false,
+          show_end = false,
+        },
+      })
+    end,
+  },
+  {
+    "render-markdown.nvim",
+    before = function()
+      require("lz.n").trigger_load({ "nvim-treesitter", "mini.nvim" })
+    end,
+    after = function()
+      require("render-markdown").setup({})
+    end,
+  },
+  {
+    "which-key.nvim",
+    event = "VimEnter",
+    before = function()
+      require("lz.n").trigger_load("nvim-web-devicons")
+    end,
+    after = function()
+      require("which-key").setup({
+        preset = "modern",
+        delay = 200,
+        win = {
+          border = "rounded",
+        },
+        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,
+  },
+  {
+    "mini.nvim",
+    after = function()
+      -- Better Around/Inside textobjects
+      require("mini.ai").setup({ n_lines = 500 })
+
+      -- Add/delete/replace surroundings (brackets, quotes, etc.)
+      require("mini.surround").setup()
+
+      -- Simple and easy statusline.
+      local statusline = require("mini.statusline")
+      statusline.setup({ use_icons = true })
+      statusline.section_location = function()
+        return "%2l:%-2v"
+      end
+
+      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(),
+        },
+      })
+
+      local indentscope = require("mini.indentscope")
+      indentscope.setup({
+        symbol = "│",
+        -- draw = { animation = indentscope.gen_animation.linear({}) },
+      })
+
+      vim.api.nvim_create_autocmd("FileType", {
+        pattern = { "help", "alpha", "dashboard", "neo-tree", "Trouble", "lazy", "mason" },
+        callback = function()
+          vim.b.miniindentscope_disable = true
+        end,
+      })
+    end,
+  },
+})