Configuration for my NixOS based systems and Home Manager
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

Sync nvim from odin

+489 -397
+34 -25
nvim/init.lua
··· 4 4 -- These need to happend before we load plugins 5 5 -- Load Plugins 6 6 require("plugins") 7 - -- Color Scheme 8 - vim.cmd.colorscheme "catppuccin" 9 - -- vim.cmd([[colorscheme kanagawa]]) 10 7 -- Config for Nord, which I usually use 11 8 -- vim.g.nord_italic = false 12 9 -- vim.g.nord_bold = false 13 10 -- vim.opt.background = "light" 14 - vim.opt.background = "dark" 11 + --vim.opt.background = "dark" 15 12 16 13 -- Formatting and vim config 17 14 vim.opt.expandtab = true 18 15 vim.opt.tabstop = 4 19 16 vim.opt.shiftwidth = 4 20 - vim.opt.termguicolors = true 17 + --vim.opt.termguicolors = true 21 18 vim.opt.cursorcolumn = true 22 19 vim.opt.cursorline = true 23 20 vim.opt.hidden = true ··· 27 24 vim.opt.relativenumber = false 28 25 -- I don't like word wrapping 29 26 vim.opt.wrap = false 30 - vim.opt.mouse = vim.opt.mouse - "a" 31 - -- TODO: revisit this 32 - vim.opt.foldlevelstart = 20 33 - vim.opt.conceallevel = 3 34 27 -- Show whitespace as dots 35 28 vim.opt.lcs = vim.opt.lcs + "space:·" 36 29 vim.opt.list = true 37 30 vim.opt.textwidth = 88 38 31 39 32 -- LuaLine Config 40 - require("lualine").setup({options = {icons_enabled = true, theme = "auto"}}) 33 + 34 + local noirbuddy_lualine = require("noirbuddy.plugins.lualine") 35 + 36 + require("lualine").setup { 37 + options = { 38 + icons_enabled = true, 39 + --theme = "auto" 40 + theme = noirbuddy_lualine.theme 41 + }, 42 + sections = noirbuddy_lualine.sections, 43 + inactive_sections = noirbuddy_lualine.inactive_sections, 44 + } 41 45 42 46 -- CTags 43 47 vim.opt.tags = vim.opt.tags + vim.fn.expand("~/.local/tmp/ctags") + 44 - vim.fn.expand("~/repos/gerbil/src/TAGS") 48 + vim.fn.expand("~/repos/gerbil/src/TAGS") 45 49 46 50 -- Conjure 47 51 ··· 71 75 72 76 -- KEYMAPS 73 77 local keymap = vim.keymap.set 74 - local noremap = {noremap = true} 75 - local silentnoremap = {noremap = true, silent = true} 78 + local noremap = { noremap = true } 79 + local silentnoremap = { noremap = true, silent = true } 76 80 -- Easier breaking from edit modes 77 81 keymap("n", ";;", "<Esc>", noremap) 78 82 keymap("v", ";;", "<Esc>", noremap) ··· 102 106 103 107 -- Toggle Line Numbers 104 108 keymap("n", "<leader>n", "<cmd>set number! number?<CR>", silentnoremap) 109 + keymap("n", "<leader>N", "<cmd>set relativenumber! relativenumber?<CR>", silentnoremap) 105 110 106 111 -- Edit this file 107 112 keymap("n", "<leader>ec", "<cmd>e $MYVIMRC<CR>", silentnoremap) ··· 124 129 keymap("n", "<Right>", "zl", silentnoremap) 125 130 126 131 -- Telescope 127 - keymap({"n", "i", "v"}, "<C-t>", "<cmd>Telescope<CR>", silentnoremap) 132 + keymap({ "n", "i", "v" }, "<C-t>", "<cmd>Telescope<CR>", silentnoremap) 128 133 129 134 -- LSP Documentation viewer 130 135 keymap("n", "K", "<cmd>lua vim.lsp.buf.hover()<CR>", silentnoremap) 131 136 137 + -- Lf 138 + keymap("n", "<leader>L", "<cmd>Lf<CR>", silentnoremap) 139 + 140 + -- Neogit 141 + keymap("n", "<leader>g", "<cmd>Neogit<CR>", silentnoremap) 142 + 132 143 -- Autoformat! 133 144 vim.api.nvim_create_user_command("Format", function(args) 134 - local range = nil 135 - if args.count ~= -1 then 136 - local end_line = vim.api.nvim_buf_get_lines(0, args.line2 - 1, args.line2, true)[1] 137 - range = { 138 - start = { args.line1, 0 }, 139 - ["end"] = { args.line2, end_line:len() }, 140 - } 141 - end 142 - require("conform").format({ async = true, lsp_format = "fallback", range = range }) 145 + local range = nil 146 + if args.count ~= -1 then 147 + local end_line = vim.api.nvim_buf_get_lines(0, args.line2 - 1, args.line2, true)[1] 148 + range = { 149 + start = { args.line1, 0 }, 150 + ["end"] = { args.line2, end_line:len() }, 151 + } 152 + end 153 + require("conform").format({ async = true, lsp_format = "fallback", range = range }) 143 154 end, { range = true }) 144 155 keymap("n", "<C-n>", "<cmd>Format<CR>", silentnoremap) 145 156 ··· 151 162 -- ######################## 152 163 -- LSP 153 164 require("lsp") 154 - -- Completion 155 - require("completion")
+42 -40
nvim/lua/completion.lua
··· 1 1 -- Copied from https://github.com/hrsh7th/nvim-cmp/?tab=readme-ov-file#recommended-configuration 2 - local cmp = require('cmp') 3 - cmp.setup({ 4 - snippet = { 5 - -- REQUIRED - you must specify a snippet engine 6 - expand = function(args) 7 - vim.fn["vsnip#anonymous"](args.body) -- For `vsnip` users. 8 - end 9 - }, 10 - window = { 11 - completion = cmp.config.window.bordered(), 12 - documentation = cmp.config.window.bordered() 13 - }, 14 - mapping = cmp.mapping.preset.insert({ 15 - ['<C-b>'] = cmp.mapping.scroll_docs(-4), 16 - ['<C-f>'] = cmp.mapping.scroll_docs(4), 17 - ['<C-Space>'] = cmp.mapping.complete(), 18 - ['<C-e>'] = cmp.mapping.abort(), 19 - ['<CR>'] = cmp.mapping.confirm({ select = true }) -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items. 20 - }), 21 - sources = cmp.config.sources({ 22 - { name = 'lazydev', group_index = 0}, 23 - { name = 'nvim_lsp' }, 24 - { name = 'vsnip' }, -- For vsnip users. 25 - { name = 'supermaven' }, 26 - { name = 'conjure' }, 27 - }, 28 - {{ name = 'buffer' }}) 29 - }) 30 - require("cmp_git").setup() 31 - -- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore). 32 - cmp.setup.cmdline({ '/', '?' }, { 33 - mapping = cmp.mapping.preset.cmdline(), 34 - sources = { { name = 'buffer' } } 35 - }) 2 + return function() 3 + local cmp = require('cmp') 4 + cmp.setup({ 5 + snippet = { 6 + -- REQUIRED - you must specify a snippet engine 7 + expand = function(args) 8 + vim.fn["vsnip#anonymous"](args.body) -- For `vsnip` users. 9 + end 10 + }, 11 + window = { 12 + completion = cmp.config.window.bordered(), 13 + documentation = cmp.config.window.bordered() 14 + }, 15 + mapping = cmp.mapping.preset.insert({ 16 + ['<C-b>'] = cmp.mapping.scroll_docs(-4), 17 + ['<C-f>'] = cmp.mapping.scroll_docs(4), 18 + ['<C-Space>'] = cmp.mapping.complete(), 19 + ['<C-e>'] = cmp.mapping.abort(), 20 + ['<CR>'] = cmp.mapping.confirm({ select = true }) -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items. 21 + }), 22 + sources = cmp.config.sources({ 23 + { name = 'lazydev', group_index = 0 }, 24 + { name = 'nvim_lsp' }, 25 + { name = 'vsnip' }, -- For vsnip users. 26 + { name = 'supermaven' }, 27 + { name = 'conjure' }, 28 + }, 29 + { { name = 'buffer' } }) 30 + }) 31 + require("cmp_git").setup() 32 + -- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore). 33 + cmp.setup.cmdline({ '/', '?' }, { 34 + mapping = cmp.mapping.preset.cmdline(), 35 + sources = { { name = 'buffer' } } 36 + }) 36 37 37 - -- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore). 38 - cmp.setup.cmdline(':', { 39 - mapping = cmp.mapping.preset.cmdline(), 40 - sources = cmp.config.sources({ { name = 'path' } }, { { name = 'cmdline' } }), 41 - matching = { disallow_symbol_nonprefix_matching = false } 42 - }) 38 + -- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore). 39 + cmp.setup.cmdline(':', { 40 + mapping = cmp.mapping.preset.cmdline(), 41 + sources = cmp.config.sources({ { name = 'path' } }, { { name = 'cmdline' } }), 42 + matching = { disallow_symbol_nonprefix_matching = false } 43 + }) 44 + end
+16 -12
nvim/lua/lsp.lua
··· 15 15 "pants.toml", "pyproject.toml", "setup.py", "setup.cfg", "Pipfile" 16 16 } 17 17 return util.find_git_ancestor(fname) or 18 - util.root_pattern(unpack(root_files))(fname) 18 + util.root_pattern(unpack(root_files))(fname) 19 19 end 20 20 }) 21 21 nvim_lsp.lua_ls.setup { ··· 27 27 }, 28 28 diagnostics = { 29 29 -- Get the language server to recognize the `vim` global 30 - globals = {"vim"} 30 + globals = { "vim" } 31 31 }, 32 32 workspace = { 33 33 -- Make the server aware of Neovim runtime files 34 34 library = vim.api.nvim_get_runtime_file("", true) 35 35 }, 36 36 -- Do not send telemetry data containing a randomized but unique identifier 37 - telemetry = {enable = false} 37 + telemetry = { enable = false } 38 38 } 39 39 } 40 40 } ··· 42 42 nvim_lsp.janet_lsp.setup { 43 43 cmd = { 44 44 "janet", 45 - "/home/noah/repos/janet-lsp/src/main.janet", 46 - "--stdio" 45 + "-i", 46 + "/home/noah/repos/janet-lsp/jpm_tree/lib/janet-lsp.jimage", 47 + "--stdio", 47 48 } 48 49 } 49 50 50 51 -- LSPs that just use default config 51 52 local simple_lsps = { 52 - "nil_ls", "htmx", "bzl", "bufls", "crystalline", "dockerls", 53 + --"htmx", 54 + "nil_ls", "bzl", "bufls", "crystalline", "dockerls", 53 55 "erlangls", "elixirls", "fortls", "gleam", "gopls", "hls", "jsonls", 54 56 "vimls", "asm_lsp", "ccls", "pyright", -- ruff", idk if this is wrong? 55 57 "ruff_lsp", "clojure_lsp", "guile_ls", ··· 57 59 "kotlin_language_server", "java_language_server", "jsonls", "pest_ls", 58 60 "ocamllsp", "reason_ls", "racket_langserver", "rust_analyzer", 59 61 "scheme_langserver", "sqls", "thriftls", "typst_lsp", "vhdl_ls", "yamlls", 60 - "zls", "tsserver", "eslint", "metals", "futhark_lsp", "roc_ls", 62 + "zls", "ts_ls", "eslint", "metals", "futhark_lsp", "roc_ls", 61 63 -- disabled because it's broken 62 64 -- "scheme_langserver", 63 65 } 64 66 -- #simple_lsps is the length of the table when treated as a list... funky! 65 - for _, v in pairs(simple_lsps) do nvim_lsp[v].setup { 66 - capabilities = capabilities 67 - } end 67 + for _, v in pairs(simple_lsps) do 68 + nvim_lsp[v].setup { 69 + capabilities = capabilities 70 + } 71 + end 68 72 69 73 nvim_lsp.fennel_ls.setup({ 70 74 capabilities = capabilities, ··· 76 80 -- Enable completion triggered by <c-x><x-o> 77 81 vim.bo[ev.buf].omnifunc = 'v:lua.vim.lsp.omnifunc' 78 82 79 - local opts = {noremap = true, silent = true, buffer = ev.buf} 83 + local opts = { noremap = true, silent = true, buffer = ev.buf } 80 84 local protocol = require("vim.lsp.protocol") 81 85 -- Mappings. 82 86 -- See `:help vim.lsp.*` for documentation on any of the below functions ··· 99 103 vim.keymap.set("n", "]d", vim.diagnostic.goto_next, opts) 100 104 vim.keymap.set("n", "<space>q", vim.diagnostic.setloclist, opts) 101 105 vim.keymap.set("n", "<space>f", 102 - function() vim.lsp.buf.format {async = true} end, opts) 106 + function() vim.lsp.buf.format { async = true } end, opts) 103 107 vim.keymap.set("n", "<space>s", vim.lsp.buf.workspace_symbol, opts) 104 108 105 109 -- require'completion'.on_attach(client, bufnr)
+397 -320
nvim/lua/plugins.lua
··· 15 15 if lazy_bootstrap then print("Bootstrapped lazy.nvim") end 16 16 17 17 require("lazy").setup({ 18 - -- Color themes 19 - "shaunsingh/nord.nvim", "shaunsingh/moonlight.nvim", 20 - "folke/tokyonight.nvim", "cranberry-clockworks/coal.nvim", 21 - "hardselius/warlock", 22 - { "catppuccin/nvim", name = "catppuccin", priority = 1000 }, 23 - { 24 - "neanias/everforest-nvim", 25 - version = false, 26 - lazy = false, 27 - priority = 500, -- make sure to load this before all the other start plugins 28 - main = "everforest", 29 - opts = { background = "hard" } 30 - }, 31 - { "rebelot/kanagawa.nvim", opts = { compile = true } }, 32 - -- show indents and whitespace characters 33 - "lukas-reineke/indent-blankline.nvim", -- Completion 34 - -- Completion 35 - { 36 - "hrsh7th/nvim-cmp", 37 - dependencies = { 38 - "hrsh7th/cmp-nvim-lsp", 39 - "hrsh7th/cmp-buffer", 40 - "hrsh7th/cmp-path", 41 - "hrsh7th/cmp-vsnip", 42 - "hrsh7th/vim-vsnip", 43 - "petertriho/cmp-git", 44 - "hrsh7th/cmp-cmdline" 45 - } 46 - }, -- nvim lsp plugins 47 - { 48 - "neovim/nvim-lspconfig", 49 - }, 50 - { 51 - "nvimdev/lspsaga.nvim", 52 - dependencies = { 53 - "nvim-tree/nvim-web-devicons", "nvim-treesitter/nvim-treesitter" 18 + install = { colorscheme = { "noirbuddy" } }, 19 + checker = { enabled = true }, 20 + spec = { 21 + -- Color themes 22 + { "shaunsingh/nord.nvim", priority = 1000, lazy = true }, 23 + { "shaunsingh/moonlight.nvim", priority = 1000, lazy = true }, 24 + { "folke/tokyonight.nvim", priority = 1000, lazy = true }, 25 + { "cranberry-clockworks/coal.nvim", priority = 1000, lazy = true }, 26 + { "hardselius/warlock", priority = 1000, lazy = true }, 27 + { "sontungexpt/witch", priority = 1000, lazy = true, config = true }, 28 + { "catppuccin/nvim", name = "catppuccin", priority = 1000, lazy = true }, 29 + { 30 + "neanias/everforest-nvim", 31 + version = false, 32 + lazy = true, 33 + priority = 1000, -- make sure to load this before all the other start plugins 34 + main = "everforest", 35 + opts = { background = "hard" } 54 36 }, 55 - opts = { lightbulb = { enable = false } }, 56 - event = "LspAttach" 57 - }, 58 - { 59 - -- Syntax Highlighting from the future 60 - "nvim-treesitter/nvim-treesitter", 61 - --init = function() vim.cmd([[":TSUpdate"]]) end, 62 - main = "nvim-treesitter.configs", 63 - opts = { 64 - ensure_installed = 'all', 65 - ignore_install = { 'norg' }, 66 - sync_intall = true, 67 - highlight = { 68 - enable = true, 37 + { "rebelot/kanagawa.nvim", opts = { compile = true }, priority = 1000, lazy = true }, 38 + { 39 + 'jesseleite/nvim-noirbuddy', 40 + dependencies = { 41 + 'tjdevries/colorbuddy.nvim', 69 42 }, 70 - indent = { 71 - enable = false, 43 + lazy = true, 44 + priority = 1000, 45 + opts = { 46 + -- All of your `setup(opts)` will go here 47 + preset = "oxide", 48 + colors = { 49 + noir_8 = "#3A4649" 50 + } 72 51 }, 73 52 }, 74 - build = ":TSUpdate", 75 - version = false, 76 - dependencies = { 77 - "nvim-treesitter/nvim-treesitter-textobjects", 53 + -- Completion 54 + { 55 + "hrsh7th/nvim-cmp", 56 + dependencies = { 57 + "hrsh7th/cmp-nvim-lsp", 58 + "hrsh7th/cmp-buffer", 59 + "hrsh7th/cmp-path", 60 + "hrsh7th/cmp-vsnip", 61 + "hrsh7th/vim-vsnip", 62 + "petertriho/cmp-git", 63 + "hrsh7th/cmp-cmdline" 64 + }, 65 + config = require('completion') 66 + }, -- nvim lsp plugins 67 + { 68 + "neovim/nvim-lspconfig", 78 69 }, 79 - }, -- Git stuff 80 - -- GitGutter, shows inline difs 81 - "airblade/vim-gitgutter", -- "tpope/vim-fugitive", -- old git command 82 - { 83 - "NeogitOrg/neogit", 84 - dependencies = { 85 - "nvim-lua/plenary.nvim", -- required 86 - "sindrets/diffview.nvim", -- optional - Diff integration 87 - "nvim-telescope/telescope.nvim" 70 + -- LSP Goodness 71 + { 72 + "ray-x/navigator.lua", 73 + dependencies = { 74 + { 'ray-x/guihua.lua', build = 'cd lua/fzy && make' }, 75 + { 'neovim/nvim-lspconfig' }, 76 + } 77 + 88 78 }, 89 - config = true 90 - }, 91 - -- Auto format tool 92 - { 93 - "stevearc/conform.nvim", 94 - lazy = true, 95 - opt = { 96 - python = { "isort", "black" }, 97 - lua = { "lua-format" }, 98 - clojure = { "cljfmt" }, 99 - rust = { "rustfmt" }, 100 - haskell = { "ormolu", "stylish-haskell" }, 101 - go = { "goimports", "gofmt" }, 102 - java = { "google-java-format" }, 103 - javascript = { "prettier" }, 104 - html = { "prettier" }, 105 - yaml = { "prettier" }, 106 - sh = { "shfmt" }, 107 - c = { "clang-format" }, 108 - } 109 - }, 110 - { 111 - "hedyhli/outline.nvim", 112 - lazy = true, 113 - cmd = { "Outline", "OutlineOpen" }, 114 - config = true, 115 - keys = { 116 - { "<leader>o", "<cmd>Outline<cr>", desc = "Toggle outline" }, 79 + { 80 + -- Syntax Highlighting from the future 81 + "nvim-treesitter/nvim-treesitter", 82 + --init = function() vim.cmd([[":TSUpdate"]]) end, 83 + main = "nvim-treesitter.configs", 84 + opts = { 85 + ensure_installed = 'all', 86 + ignore_install = { 'norg' }, 87 + sync_intall = true, 88 + highlight = { 89 + enable = true, 90 + }, 91 + indent = { 92 + enable = false, 93 + }, 94 + }, 95 + build = ":TSUpdate", 96 + version = false, 97 + dependencies = { 98 + "nvim-treesitter/nvim-treesitter-textobjects", 99 + "nvim-treesitter/nvim-treesitter-context", 100 + }, 101 + }, -- Git stuff 102 + -- GitGutter, shows inline difs 103 + "airblade/vim-gitgutter", 104 + { 105 + "NeogitOrg/neogit", 106 + dependencies = { 107 + "nvim-lua/plenary.nvim", -- required 108 + "sindrets/diffview.nvim", -- optional - Diff integration 109 + "nvim-telescope/telescope.nvim" 110 + }, 111 + config = true 112 + }, 113 + -- Auto format tool 114 + { 115 + "stevearc/conform.nvim", 116 + lazy = true, 117 + opts = { 118 + python = { "isort", "black" }, 119 + lua = { "lua-format" }, 120 + clojure = { "cljfmt" }, 121 + rust = { "rustfmt" }, 122 + haskell = { "ormolu", "stylish-haskell" }, 123 + go = { "goimports", "gofmt" }, 124 + java = { "google-java-format" }, 125 + javascript = { "prettier" }, 126 + html = { "prettier" }, 127 + yaml = { "prettier" }, 128 + sh = { "shfmt" }, 129 + c = { "clang-format" }, 130 + } 117 131 }, 118 - }, 119 - { 120 - "ray-x/go.nvim", 121 - ft = "go", 122 - lazy = true, 123 - dependencies = { 124 - "ray-x/guihua.lua", "neovim/nvim-lspconfig", 125 - "nvim-treesitter/nvim-treesitter" 126 - } 127 - }, 128 - { 129 - "nvim-lualine/lualine.nvim", 130 - dependencies = { "nvim-tree/nvim-web-devicons" } 131 - }, 132 - "junegunn/fzf.vim", 133 - { 134 - dir = "~/.fzf", 135 - build = function() vim.fn["fzf#install"](0) end, 136 - dependencies = { "junegunn/fzf.vim" } 137 - }, 138 - -- Telescope, find anything fast 139 - "nvim-lua/plenary.nvim", 140 - { 141 - "nvim-telescope/telescope.nvim", 142 - dependencies = { 143 - "nvim-lua/plenary.nvim", 144 - "nvim-telescope/telescope-symbols.nvim", 145 - } 146 - }, 147 - { 148 - "folke/trouble.nvim", 149 - dependencies = "nvim-tree/nvim-web-devicons" 150 - }, 151 - -- Which key is bound? 152 - -- literally the best plugin ever 153 - { 154 - "folke/which-key.nvim", 155 - init = function() 156 - vim.o.timeout = true 157 - vim.o.timeoutlen = 300 158 - end, 159 - config = true 160 - }, 161 - -- Developing my neovim 162 - { 163 - "folke/lazydev.nvim", 164 - config = true, 165 - ft = "lua", 166 - opts = { 167 - library = { 168 - path = "luvit-meta/library", words = { "vim%.uv" }, 132 + { 133 + "hedyhli/outline.nvim", 134 + lazy = true, 135 + cmd = { "Outline", "OutlineOpen" }, 136 + config = true, 137 + keys = { 138 + { "<leader>o", "<cmd>Outline<cr>", desc = "Toggle outline" }, 169 139 }, 170 140 }, 171 - dependencies = { 172 - "Bilal2453/luvit-meta" 141 + { 142 + "ray-x/go.nvim", 143 + ft = "go", 144 + lazy = true, 145 + dependencies = { 146 + "ray-x/guihua.lua", "neovim/nvim-lspconfig", 147 + "nvim-treesitter/nvim-treesitter" 148 + } 149 + }, 150 + { 151 + "nvim-lualine/lualine.nvim", 152 + config = function(_spec, _opt) 153 + local noirbuddy_lualine = require("noirbuddy.plugins.lualine") 154 + require("lualine").setup { 155 + options = { 156 + icons_enabled = true, 157 + -- when not using noirbuddy, uncomment this 158 + --theme = "auto" 159 + theme = noirbuddy_lualine.theme 160 + }, 161 + sections = noirbuddy_lualine.sections, 162 + inactive_sections = noirbuddy_lualine.inactive_sections, 163 + } 164 + end, 165 + dependencies = { "nvim-tree/nvim-web-devicons", "jesseleite/nvim-noirbuddy" } 166 + }, 167 + -- Fuzzy finding stuff 168 + "junegunn/fzf.vim", 169 + { 170 + dir = "~/.fzf", 171 + build = function() vim.fn["fzf#install"](0) end, 172 + dependencies = { "junegunn/fzf.vim" } 173 + }, 174 + -- A lua + nvim stdlib sort of thing 175 + { "nvim-lua/plenary.nvim", lazy = true, }, 176 + -- Telescope, find anything fast 177 + { 178 + "nvim-telescope/telescope.nvim", 179 + config = true, 180 + dependencies = { 181 + "nvim-lua/plenary.nvim", 182 + "nvim-telescope/telescope-symbols.nvim", 183 + } 184 + }, 185 + { 186 + "folke/trouble.nvim", 187 + dependencies = "nvim-tree/nvim-web-devicons", 188 + config = true, 189 + }, 190 + -- Which key is bound? 191 + -- literally the best plugin ever 192 + { 193 + "folke/which-key.nvim", 194 + init = function() 195 + vim.o.timeout = true 196 + vim.o.timeoutlen = 300 197 + end, 198 + config = true 173 199 }, 174 - }, 175 - -- Lithsps 176 - --{ "m4xshen/autoclose.nvim" }, 177 - { 178 - "windwp/nvim-autopairs", 179 - event = "InsertEnter", 180 - config = function() 181 - local pairs = require("nvim-autopairs") 200 + -- Developing my neovim 201 + { 202 + "folke/lazydev.nvim", 203 + config = true, 204 + ft = "lua", 205 + lazy = true, 206 + opts = { 207 + library = { 208 + path = "luvit-meta/library", words = { "vim%.uv" }, 209 + }, 210 + }, 211 + dependencies = { 212 + "Bilal2453/luvit-meta" 213 + }, 214 + }, 215 + -- Lithsps 216 + { 217 + "windwp/nvim-autopairs", 218 + event = "InsertEnter", 219 + config = function() 220 + local pairs = require("nvim-autopairs") 182 221 183 - pairs.setup({ 184 - check_ts = true, 185 - enable_check_bracket_line = false, 186 - }) 222 + pairs.setup({ 223 + check_ts = true, 224 + enable_check_bracket_line = false, 225 + }) 187 226 188 - pairs.get_rules("`")[1].not_filetypes = { "clojure", "scheme", "scm", "janet" } 189 - pairs.get_rules("'")[1].not_filetypes = { "clojure", "scheme", "scm", "janet", "rust" } 190 - end, 191 - }, 192 - { 193 - "gpanders/nvim-parinfer", 194 - ft = { "hy", "scheme", "scm", "clojure", "fennel", "janet", "lisp", "python", "lua" }, 195 - config = function() 196 - vim.g.parinfer_comment_chars = { ";", "#" } 197 - vim.g.parinfer_force_balance = true 198 - end 199 - }, 200 - -- )))))) 201 - { 202 - "julienvincent/nvim-paredit", 203 - config = function() 204 - local paredit = require('nvim-paredit') 205 - paredit.setup({ 206 - indent = { 207 - enabled = true, 208 - }, 209 - --filetypes = {"clojure", "fennel", "janet"}, 210 - keys = { 211 - ["<localleader>w"] = { 212 - function() 213 - -- place cursor and set mode to `insert` 214 - paredit.cursor.place_cursor( 215 - -- wrap element under cursor with `( ` and `)` 216 - paredit.wrap.wrap_element_under_cursor("( ", ")"), 217 - -- cursor placement opts 218 - { placement = "inner_start", mode = "insert" } 219 - ) 220 - end, 221 - "Wrap element insert head", 227 + pairs.get_rules("`")[1].not_filetypes = { "clojure", "scheme", "scm", "janet" } 228 + pairs.get_rules("'")[1].not_filetypes = { "clojure", "scheme", "scm", "janet", "rust" } 229 + end, 230 + }, 231 + -- This gives me the paredit engine, it's pretty nifty 232 + { 233 + "gpanders/nvim-parinfer", 234 + ft = { "hy", "scheme", "scm", "clojure", "fennel", "janet", "lisp", "python", "lua" }, 235 + lazy = true, 236 + config = function() 237 + vim.g.parinfer_comment_chars = { ";", "#" } 238 + vim.g.parinfer_force_balance = true 239 + end 240 + }, -- )))))) 241 + -- This one gives me vim-sexp like structural editing 242 + { 243 + "julienvincent/nvim-paredit", 244 + config = function() 245 + local paredit = require('nvim-paredit') 246 + paredit.setup({ 247 + indent = { 248 + enabled = true, 222 249 }, 250 + --filetypes = {"clojure", "fennel", "janet"}, 251 + keys = { 252 + ["<localleader>w"] = { 253 + function() 254 + -- place cursor and set mode to `insert` 255 + paredit.cursor.place_cursor( 256 + -- wrap element under cursor with `( ` and `)` 257 + paredit.wrap.wrap_element_under_cursor("( ", ")"), 258 + -- cursor placement opts 259 + { placement = "inner_start", mode = "insert" } 260 + ) 261 + end, 262 + "Wrap element insert head", 263 + }, 223 264 224 - ["<localleader>W"] = { 225 - function() 226 - paredit.cursor.place_cursor( 227 - paredit.wrap.wrap_element_under_cursor("(", ")"), 228 - { placement = "inner_end", mode = "insert" } 229 - ) 230 - end, 231 - "Wrap element insert tail", 265 + ["<localleader>W"] = { 266 + function() 267 + paredit.cursor.place_cursor( 268 + paredit.wrap.wrap_element_under_cursor("(", ")"), 269 + { placement = "inner_end", mode = "insert" } 270 + ) 271 + end, 272 + "Wrap element insert tail", 273 + }, 274 + -- same as above but for enclosing form 275 + ["<localleader>i"] = { 276 + function() 277 + paredit.cursor.place_cursor( 278 + paredit.wrap.wrap_enclosing_form_under_cursor("( ", ")"), 279 + { placement = "inner_start", mode = "insert" } 280 + ) 281 + end, 282 + "Wrap form insert head", 283 + }, 284 + ["<localleader>I"] = { 285 + function() 286 + paredit.cursor.place_cursor( 287 + paredit.wrap.wrap_enclosing_form_under_cursor("(", ")"), 288 + { placement = "inner_end", mode = "insert" } 289 + ) 290 + end, 291 + "Wrap form insert tail", 292 + }, 293 + ["<localleader>["] = { 294 + function() 295 + paredit.cursor.place_cursor( 296 + paredit.wrap.wrap_enclosing_form_under_cursor("[", "]"), 297 + { placement = "inner_start", mode = "insert" } 298 + ) 299 + end, 300 + }, 301 + ["<localleader>{"] = { 302 + function() 303 + paredit.cursor.place_cursor( 304 + paredit.wrap.wrap_enclosing_form_under_cursor("{", "}"), 305 + { placement = "inner_end", mode = "insert" } 306 + ) 307 + end, 308 + }, 232 309 }, 233 - -- same as above but for enclosing form 234 - ["<localleader>i"] = { 235 - function() 236 - paredit.cursor.place_cursor( 237 - paredit.wrap.wrap_enclosing_form_under_cursor("( ", ")"), 238 - { placement = "inner_start", mode = "insert" } 239 - ) 240 - end, 241 - "Wrap form insert head", 242 - }, 243 - ["<localleader>I"] = { 244 - function() 245 - paredit.cursor.place_cursor( 246 - paredit.wrap.wrap_enclosing_form_under_cursor("(", ")"), 247 - { placement = "inner_end", mode = "insert" } 248 - ) 249 - end, 250 - "Wrap form insert tail", 251 - }, 252 - ["<localleader>["] = { 253 - function() 254 - paredit.cursor.place_cursor( 255 - paredit.wrap.wrap_enclosing_form_under_cursor("[", "]"), 256 - { placement = "inner_start", mode = "insert" } 257 - ) 258 - end, 259 - }, 260 - ["<localleader>{"] = { 261 - function() 262 - paredit.cursor.place_cursor( 263 - paredit.wrap.wrap_enclosing_form_under_cursor("{", "}"), 264 - { placement = "inner_end", mode = "insert" } 265 - ) 266 - end, 267 - }, 268 - }, 269 - }) 270 - end, 271 - ft = { "hy", "scheme", "scm", "clojure", "fennel", "janet", "lisp", "python", "lua" } 272 - }, 273 - { 274 - "chiefnoah/nvim-paredit-janet", 275 - dependencies = { "julienvincent/nvim-paredit" }, 276 - lazy = true, 277 - ft = { "janet" }, 278 - config = function() 279 - require("nvim-paredit-janet").setup() 280 - end, 281 - }, 282 - { 283 - "julienvincent/nvim-paredit-fennel", 284 - dependencies = { "julienvincent/nvim-paredit" }, 285 - ft = { "fennel" }, 286 - config = true, 287 - }, 288 - { "hiphish/rainbow-delimiters.nvim" }, 289 - --{ "gpanders/nvim-parinfer", ft = { "scheme", "scm", "lisp", "fennel", "clojure", "lua", "janet" } }, 290 - -- Conjure, lisp is magical 291 - { 292 - "Olical/conjure", 293 - ft = { "scheme", "scm", "lisp", "fennel", "clojure", "lua", "janet" }, 294 - config = function() 295 - vim.g["conjure#client#scheme#stdio#command"] = "gxi" 296 - vim.g["conjure#client#scheme#stdio#prompt_pattern"] = "%d*> $?" 297 - end, 298 - dependencies = { "PaterJason/cmp-conjure" } 299 - }, 300 - { "PaterJason/cmp-conjure", lazy = true }, 301 - { "p1xelHer0/gerbil.nvim", ft = "scheme" }, -- Fennel, Luasthp 302 - { "jaawerth/fennel.vim", lazy = true, ft = "fennel" }, 303 - { "rktjmp/hotpot.nvim", lazy = true, ft = "fennel" }, 304 - { "Olical/nfnl", ft = "fennel" }, -- Rust stuff 305 - { 306 - "simrat39/rust-tools.nvim", 307 - ft = { "rust" }, 308 - config = function() 309 - local rt = require("rust-tools") 310 - rt.setup({ 311 - server = { 312 - on_attach = function(_, bufnr) 313 - -- Hover actions 314 - vim.keymap.set("n", "<C-space>", 315 - rt.hover_actions.hover_actions, 316 - { buffer = bufnr }) 317 - -- Code action groups 318 - vim.keymap.set("n", "<Leader>a", 319 - rt.code_action_group.code_action_group, 320 - { buffer = bufnr }) 321 - end 310 + }) 311 + end, 312 + lazy = true, 313 + ft = { "hy", "scheme", "scm", "clojure", "fennel", "janet", "lisp", "python", "lua" } 314 + }, 315 + { 316 + "chiefnoah/nvim-paredit-janet", 317 + dependencies = { "julienvincent/nvim-paredit" }, 318 + lazy = true, 319 + ft = { "janet" }, 320 + config = function() 321 + require("nvim-paredit-janet").setup() 322 + end, 323 + }, 324 + { 325 + "julienvincent/nvim-paredit-fennel", 326 + dependencies = { "julienvincent/nvim-paredit" }, 327 + lazy = true, 328 + ft = { "fennel" }, 329 + config = true, 330 + }, 331 + { 332 + "ekaitz-zarraga/nvim-paredit-scheme", 333 + lazy = true, 334 + ft = { "scheme" }, 335 + config = function() 336 + require("nvim-paredit-scheme").setup(require("nvim-paredit")) 337 + end, 338 + }, 339 + { "hiphish/rainbow-delimiters.nvim", priority = 1050, }, 340 + -- Conjure, lisp is magical 341 + { 342 + "Olical/conjure", 343 + dependencies = { "PaterJason/cmp-conjure" }, 344 + config = function() 345 + vim.g["conjure#client#scheme#stdio#command"] = "gxi" 346 + vim.g["conjure#client#scheme#stdio#prompt_pattern"] = "%d*> $?" 347 + end, 348 + lazy = true, 349 + ft = { "scheme", "scm", "lisp", "fennel", "clojure", "lua", "janet" }, 350 + }, 351 + { "PaterJason/cmp-conjure", lazy = true }, 352 + { "p1xelHer0/gerbil.nvim", lazy = true, ft = "scheme", config = true }, -- Fennel, Luasthp 353 + { "jaawerth/fennel.vim", lazy = true, ft = "fennel", config = true }, 354 + { "rktjmp/hotpot.nvim", lazy = true, ft = "fennel", config = true }, 355 + { "Olical/nfnl", lazy = true, ft = "fennel", config = true }, -- Rust stuff 356 + { 357 + "simrat39/rust-tools.nvim", 358 + lazy = true, 359 + ft = { "rust" }, 360 + config = function() 361 + local rt = require("rust-tools") 362 + rt.setup({ 363 + server = { 364 + on_attach = function(_, bufnr) 365 + -- Hover actions 366 + vim.keymap.set("n", "<C-space>", 367 + rt.hover_actions.hover_actions, 368 + { buffer = bufnr }) 369 + -- Code action groups 370 + vim.keymap.set("n", "<Leader>a", 371 + rt.code_action_group.code_action_group, 372 + { buffer = bufnr }) 373 + end 374 + } 375 + }) 376 + end, 377 + dependencies = { "nvim-lua/plenary.nvim" } 378 + }, 379 + { "mfussenegger/nvim-dap", lazy = true, ft = { "c", "rust" }, config = true }, 380 + { 381 + "saecki/crates.nvim", 382 + tag = "v0.4.0", 383 + dependencies = { "nvim-lua/plenary.nvim" }, 384 + config = function() require("crates").setup() end, 385 + lazy = true, 386 + ft = { "rust" } 387 + }, -- RISC-V Assembly syntax highlighting 388 + { "kylelaker/riscv.vim", ft = "riscv" }, -- Hare Stuff 389 + -- Hare stuff 390 + -- Haredoc 391 + { 392 + url = "https://git.sr.ht/~torresjrjr/vim-haredoc", 393 + lazy = true, 394 + ft = { "hare" }, 395 + branch = "dev" 396 + }, 397 + { url = "https://git.sr.ht/~sircmpwn/hare.vim", ft = { "hare" } }, 398 + -- TCL 399 + { "lewis6991/tree-sitter-tcl", lazy = true, build = "make" }, 400 + -- LF 401 + { 402 + "ptzz/lf.vim", 403 + lazy = true, 404 + cmd = { "Lf" }, 405 + dependencies = { "voldikss/vim-floaterm" } 406 + }, 407 + -- SuperMaven, another AI coding tool 408 + { 409 + "supermaven-inc/supermaven-nvim", 410 + opts = { keymaps = { accept_suggestion = "<C-f>" } }, 411 + lazy = true, 412 + cmd = "SupermavenStart" 413 + }, 414 + { "imsnif/kdl.vim", lazy = true, ft = "kdl" }, 415 + { 416 + "epwalsh/obsidian.nvim", 417 + lazy = true, 418 + ft = "markdown", 419 + dependencies = { "nvim-lua/plenary.nvim" }, 420 + opts = { 421 + workspaces = { 422 + { name = "Athenaeum", path = "~/Documents/Athenaeum" }, 423 + -- Mage, the Awakening and other Chronicles of Darkness 424 + { name = "Celestial Grimoire", path = "~/Documents/Celestial Grimoire" }, 425 + { name = "Infleqtion", path = "~/Documents/infleqtion-vault" }, 322 426 } 323 - }) 324 - end, 325 - dependencies = { "nvim-lua/plenary.nvim" } 326 - }, 327 - { "mfussenegger/nvim-dap", lazy = true, ft = { "c", "rust" } }, 328 - { 329 - "saecki/crates.nvim", 330 - tag = "v0.4.0", 331 - dependencies = { "nvim-lua/plenary.nvim" }, 332 - config = function() require("crates").setup() end, 333 - ft = { "rust" } 334 - }, -- RISC-V Assembly syntax highlighting 335 - { "kylelaker/riscv.vim", ft = "riscv" }, -- Hare Stuff 336 - -- Haredoc 337 - { 338 - url = "https://git.sr.ht/~torresjrjr/vim-haredoc", 339 - ft = { "hare" }, 340 - branch = "dev" 341 - }, -- Hare.vim 342 - { url = "https://git.sr.ht/~sircmpwn/hare.vim", ft = { "hare" } }, -- TCL 343 - { "lewis6991/tree-sitter-tcl", build = "make" }, -- LF 344 - { "ptzz/lf.vim", cmd = { "Lf" }, dependencies = { "voldikss/vim-floaterm" } }, 345 - -- SuperMaven, another AI coding tool 346 - { 347 - "supermaven-inc/supermaven-nvim", 348 - opts = { keymaps = { accept_suggestion = "<C-f>" } }, 349 - lazy = true, 350 - cmd = "SupermavenStart" 351 - }, 352 - "imsnif/kdl.vim" 353 - }, nil) 427 + } 428 + }, 429 + } 430 + })