init

homes/modules/programs/neovim/lua/lsp/capabilities.lua

@@ -0,0 +1,59 @@
+local M = {}
+
+function M.on_attach(_, bufnr)
+  -- we create a function that lets us more easily define mappings specific
+  -- for LSP related items. It sets the mode, buffer and description for us each time.
+
+  local nmap = function(keys, func, desc)
+    if desc then
+      desc = 'LSP: ' .. desc
+    end
+
+    vim.keymap.set('n', keys, func, { buffer = bufnr, desc = desc })
+  end
+
+  nmap('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
+  nmap('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction')
+
+  nmap('gd', vim.lsp.buf.definition, '[G]oto [D]efinition')
+
+  -- NOTE: why are these functions that call the telescope builtin?
+  -- because otherwise they would load telescope eagerly when this is defined.
+  -- due to us using the on_require handler to make sure it is available.
+  if nixCats('general.telescope') then
+    nmap('gr', function() require('telescope.builtin').lsp_references() end, '[G]oto [R]eferences')
+    nmap('gI', function() require('telescope.builtin').lsp_implementations() end, '[G]oto [I]mplementation')
+    nmap('<leader>ds', function() require('telescope.builtin').lsp_document_symbols() end, '[D]ocument [S]ymbols')
+    nmap('<leader>ws', function() require('telescope.builtin').lsp_dynamic_workspace_symbols() end, '[W]orkspace [S]ymbols')
+    nmap('<leader>dd', "<cmd>Telescope diagnostics bufnr=0<CR>", '[D]ocument [D]iagnostics')
+    nmap('<leader>wd', "<cmd>Telescope diagnostics<CR>", '[W]orkspace [D]iagnostics')
+  end -- TODO: someone who knows the builtin versions of these to do instead help me out please.
+
+  nmap('<leader>D', vim.lsp.buf.type_definition, 'Type [D]efinition')
+  nmap('<leader>e', vim.diagnostic.open_float, 'Show [E]rror')
+
+  -- See `:help K` for why this keymap
+  nmap('K', vim.lsp.buf.hover, 'Hover Documentation')
+  nmap('<C-k>', vim.lsp.buf.signature_help, 'Signature Documentation')
+
+  -- Lesser used LSP functionality
+  nmap('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+  nmap('<leader>wa', vim.lsp.buf.add_workspace_folder, '[W]orkspace [A]dd Folder')
+  nmap('<leader>wr', vim.lsp.buf.remove_workspace_folder, '[W]orkspace [R]emove Folder')
+  nmap('<leader>wl', function()
+    print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
+  end, '[W]orkspace [L]ist Folders')
+
+  -- Create a command `:Format` local to the LSP buffer
+  vim.api.nvim_buf_create_user_command(bufnr, 'Format', function(_)
+    vim.lsp.buf.format()
+  end, { desc = 'Format current buffer with LSP' })
+
+end
+
+function M.get(server_name)
+  local capabilities = require('blink.cmp').get_lsp_capabilities()
+
+  return capabilities
+end
+return M

homes/modules/programs/neovim/lua/lsp/completion.lua

@@ -0,0 +1,88 @@
+return {
+  {
+    "friendly-snippets",
+    dep_of = { "blink.cmp" },
+  },
+  {
+    "blink.cmp",
+    event = { "InsertEnter", "CmdlineEnter" },
+    on_require = "blink",
+    load = function (name)
+      vim.cmd.packadd(name)
+    end,
+    after = function(plugin)
+      local blink = require('blink.cmp')
+
+      blink.setup({
+        keymap = {
+	  preset = 'default',
+        },
+
+        appearance = {
+	  nerd_font_variant = 'mono',
+	},
+
+	sources = {
+	  default = { 'lsp', 'path', 'snippets', 'buffer' },
+	  providers = {
+	    lsp = {
+	      name = 'LSP',
+	      module = 'blink.cmp.sources.lsp',
+	      enabled = true,
+	    },
+	    path = {
+	      name = 'Path',
+	      module = 'blink.cmp.sources.path',
+	      enabled = true,
+	    },
+	    snippets = {
+	      name = 'Snippets',
+	      module = 'blink.cmp.sources.snippets',
+	      enabled = true,
+	    },
+	    buffer = {
+	      name = 'Buffer',
+	      module = 'blink.cmp.sources.buffer',
+	      enabled = true,
+	    },
+	  },
+	},
+
+        completion = {
+	  accept = {
+	    auto_brackets = {
+	      enabled = true,
+	    },
+	  },
+
+          menu = {
+	    border = 'rounded',
+	    max_height = 12,
+	    scrolloff = 2,
+
+            draw = {
+	      columns = {
+		{ "kind_icon", gap = 1, },
+	        { "label", "label_description", gap = 1, },
+	      },
+	    },
+	  },
+
+          documentation = {
+	    auto_show = false,
+	    window = {
+	      border = 'rounded',
+	    },
+	  },
+	},
+
+        signature = {
+	  enabled = true,
+	  window = {
+	    border = 'rounded',
+	  },
+	},
+      })
+    end
+  },
+}

homes/modules/programs/neovim/lua/lsp/completion.lua.old

@@ -0,0 +1,203 @@
+---packadd + after/plugin
+---@type fun(names: string[]|string)
+local load_w_after_plugin = require('nixCatsUtils.lzUtils').make_load_with_after({ "plugin" })
+
+-- NOTE: packadd doesnt load after directories.
+-- hence, the above function that you can get from luaUtils that exists to make that easy.
+
+return {
+  {
+    "cmp-buffer",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-cmdline",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-cmdline-history",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-nvim-lsp",
+    on_plugin = { "nvim-cmp" },
+    dep_of = { "nvim-lspconfig" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-nvim-lsp-signature-help",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-nvim-lua",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp-path",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "cmp_luasnip",
+    on_plugin = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "friendly-snippets",
+    dep_of = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "lspkind.nvim",
+    dep_of = { "nvim-cmp" },
+    load = load_w_after_plugin,
+  },
+  {
+    "luasnip",
+    dep_of = { "nvim-cmp" },
+    after = function (plugin)
+      local luasnip = require 'luasnip'
+      require('luasnip.loaders.from_vscode').lazy_load()
+      luasnip.config.setup {}
+
+      local ls = require('luasnip')
+
+      vim.keymap.set({ "i", "s" }, "<M-n>", function()
+          if ls.choice_active() then
+              ls.change_choice(1)
+          end
+      end)
+    end,
+  },
+  {
+    "nvim-cmp",
+    -- cmd = { "" },
+    event = { "DeferredUIEnter" },
+    on_require = { "cmp" },
+    -- ft = "",
+    -- keys = "",
+    -- colorscheme = "",
+    after = function (plugin)
+      -- [[ Configure nvim-cmp ]]
+      -- See `:help cmp`
+      local cmp = require 'cmp'
+      local luasnip = require 'luasnip'
+      local lspkind = require 'lspkind'
+
+      cmp.setup {
+        formatting = {
+          format = lspkind.cmp_format {
+            mode = 'text',
+            with_text = true,
+            maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters)
+            ellipsis_char = '...', -- when popup menu exceed maxwidth, the truncated part would show ellipsis_char instead (must define maxwidth first)
+
+            menu = {
+              buffer = '[BUF]',
+              nvim_lsp = '[LSP]',
+              nvim_lsp_signature_help = '[LSP]',
+              nvim_lsp_document_symbol = '[LSP]',
+              nvim_lua = '[API]',
+              path = '[PATH]',
+              luasnip = '[SNIP]',
+            },
+          },
+        },
+        snippet = {
+          expand = function(args)
+            luasnip.lsp_expand(args.body)
+          end,
+        },
+        mapping = cmp.mapping.preset.insert {
+          ['<C-p>'] = cmp.mapping.scroll_docs(-4),
+          ['<C-n>'] = cmp.mapping.scroll_docs(4),
+          ['<C-Space>'] = cmp.mapping.complete {},
+          ['<CR>'] = cmp.mapping.confirm {
+            behavior = cmp.ConfirmBehavior.Replace,
+            select = true,
+          },
+          ['<Tab>'] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_next_item()
+            elseif luasnip.expand_or_locally_jumpable() then
+              luasnip.expand_or_jump()
+            else
+              fallback()
+            end
+          end, { 'i', 's' }),
+          ['<S-Tab>'] = cmp.mapping(function(fallback)
+            if cmp.visible() then
+              cmp.select_prev_item()
+            elseif luasnip.locally_jumpable(-1) then
+              luasnip.jump(-1)
+            else
+              fallback()
+            end
+          end, { 'i', 's' }),
+        },
+
+        sources = cmp.config.sources {
+          -- The insertion order influences the priority of the sources
+          { name = 'nvim_lsp'--[[ , keyword_length = 3 ]] },
+          { name = 'nvim_lsp_signature_help'--[[ , keyword_length = 3  ]]},
+          { name = 'path' },
+          { name = 'luasnip' },
+          { name = 'buffer' },
+        },
+        enabled = function()
+          return vim.bo[0].buftype ~= 'prompt'
+        end,
+        experimental = {
+          native_menu = false,
+          ghost_text = false,
+        },
+      }
+
+      cmp.setup.filetype('lua', {
+        sources = cmp.config.sources {
+          { name = 'nvim_lua' },
+          { name = 'nvim_lsp'--[[ , keyword_length = 3  ]]},
+          { name = 'nvim_lsp_signature_help'--[[ , keyword_length = 3  ]]},
+          { name = 'path' },
+          { name = 'luasnip' },
+          { name = 'buffer' },
+        },{
+          {
+            name = 'cmdline',
+            option = {
+              ignore_cmds = { 'Man', '!' },
+            },
+          },
+        },
+      })
+
+      -- Use buffer source for `/` and `?` (if you enabled `native_menu`, this won't work anymore).
+      cmp.setup.cmdline({ '/', '?' }, {
+        mapping = cmp.mapping.preset.cmdline(),
+        sources = {
+          { name = 'nvim_lsp_document_symbol'--[[ , keyword_length = 3  ]]},
+          { name = 'buffer' },
+          { name = 'cmdline_history' },
+        },
+        view = {
+          entries = { name = 'wildmenu', separator = '|' },
+        },
+      })
+
+      -- Use cmdline & path source for ':' (if you enabled `native_menu`, this won't work anymore).
+      cmp.setup.cmdline(':', {
+        mapping = cmp.mapping.preset.cmdline(),
+        sources = cmp.config.sources {
+          { name = 'cmdline' },
+          -- { name = 'cmdline_history' },
+          { name = 'path' },
+        },
+      })
+    end,
+  },
+}

homes/modules/programs/neovim/lua/lsp/init.lua

@@ -0,0 +1,5 @@
+require("lze").load {
+  { import = "lsp.completion", },
+}
+
+require("lsp.lsp")

homes/modules/programs/neovim/lua/lsp/lsp.lua

@@ -0,0 +1,123 @@
+local servers = {}
+
+servers.lua_ls = {
+  settings = {
+    Lua = {
+      formatters = {
+	ignoreComments = false,
+      },
+      signatureHelp = { enable = true },
+      diagnostics = {
+	globals = { 'nixCats', 'vim' },
+	-- disable = { 'missing-fields' },
+      },
+      workspace = {
+	-- make the server aware of the neovim runtime files
+	library = vim.api.nvim_get_runtime_file("", true),
+	checkThirdParty = false,
+      },
+    },
+    telemetry = { enabled = false },
+  },
+}
+
+local rust_analyzer_cmd = os.getenv("RUST_ANALYZER_CMD")
+servers.rust_analyzer = {
+  cmd = { rust_analyzer_cmd },
+  settings = {
+    server = {
+      -- For debugging rust-analyzer, to see log location do :LspInfo in neovim
+      -- extraEnv = { {["RA_LOG"]="project_model=debug"} },
+    },
+    cargo = {
+      allFeatures = false,
+      allTargets = false,
+      buildScripts = { enable = true },
+      target = "x86_64-unknown-linux-gnu",
+    },
+    diagnostics = {
+      enable = true,
+    },
+  },
+}
+
+servers.zls = {
+  settings = {},
+}
+
+local elixir_ls_cmd = os.getenv("ELIXIR_LS_CMD")
+servers.elixirls = {
+  cmd = { elixir_ls_cmd },
+  settings = {},
+}
+
+servers.gleam = {
+  settings = {},
+}
+
+local java_home = os.getenv("JAVA_HOME")
+servers.jdtls = {
+  settings = {
+    java = {
+      contentProvider = { preferred = 'fernflower' },
+      configuration = {
+	runtimes = {
+	  {
+	    name = "OpenJDK 17",
+	    path = os.getenv("OPENJDK_17"),
+	  },
+	  {
+	    name = "OpenJDK 21",
+	    path = os.getenv("OPENJDK_21"),
+	  },
+	}
+      }
+    },
+  }
+}
+
+-- Taken from nixCats example:
+-- If you were to comment out this autocommand
+-- and instead pass the on attach function directly to
+-- nvim-lspconfig, it would do the same thing.
+-- come to think of it, it might be better because then lspconfig doesnt have to be called before lsp attach?
+-- but you would still end up triggering on a FileType event anyway, so, it makes little difference.
+vim.api.nvim_create_autocmd('LspAttach', {
+  group = vim.api.nvim_create_augroup('nixCats-lsp-attach', { clear = true }),
+  callback = function(event)
+    require('lsp.capabilities').on_attach(vim.lsp.get_client_by_id(event.data.client_id), event.buf)
+  end
+})
+
+require("lze").load {
+  {
+    "nvim-lspconfig",
+    event = "FileType",
+    after = function(plugin)
+      -- Just register configs, don't enable yet
+      for server_name, cfg in pairs(servers) do
+        vim.lsp.config(server_name, {
+          capabilities = require('lsp.capabilities').get(server_name),
+          settings = (cfg or {}).settings,
+          filetypes = (cfg or {}).filetypes,
+          cmd = (cfg or {}).cmd,
+          root_pattern = (cfg or {}).root_pattern,
+        })
+      end
+
+      -- Enable on-demand per filetype
+      for server_name, cfg in pairs(servers) do
+        local filetypes = cfg.filetypes or vim.lsp.config[server_name].filetypes
+        if filetypes then
+          vim.api.nvim_create_autocmd('FileType', {
+            pattern = filetypes,
+            callback = function()
+              vim.lsp.enable(server_name)
+            end,
+          })
+        end
+      end
+    end,
+  },
+}
+

homes/modules/programs/neovim/lua/nixCatsUtils/lzUtils.lua

@@ -0,0 +1,135 @@
+--[[
+  This directory is the luaUtils template.
+  You can choose what things from it that you would like to use.
+  And then delete the rest.
+  Everything in this directory is optional.
+--]]
+
+local M = {}
+-- NOTE: This file contains 2 utilities for making good use of lze and lz.n with nixCats
+-- The function for loading after directories is useful for both plugins, and also for lazy loading without a plugin,
+-- but the custom handler will only work with lze.
+-- If you dont use these plugins, you probably don't need this file.
+
+---This function is useful for sourcing the after directories of lazily loaded plugins
+---because vim.cmd.packadd does not do this for you.
+---
+---This might be useful when doing lazy loading the vanilla way
+---as well as when using plugins like lz.n for lazy loading
+---It is primarily useful for lazily loading nvim-cmp sources,
+---as they often rely on the after directory to work
+---
+---Recieves the names of directories from a plugin's after directory
+---that you wish to source files from.
+---Will return a load function that can take a name, or list of names,
+---and will load a plugin and its after directories.
+---The function returned is a suitable substitute for the load field of a plugin spec.
+---
+---Only makes sense for plugins added via optionalPlugins
+---or some other opt directory on your packpath
+---
+---e.g. in the following example:
+---load_with_after_plugin will load the plugin names it is given, and their after/plugin dir
+---
+---local load_with_after_plugin = require('nixCatsUtils').make_load_with_after({ 'plugin' })
+---load_with_after_plugin('some_plugin')
+---@overload fun(dirs: string[]|string): fun(names: string|string[])
+---It also optionally recieves a function that should load a plugin and return its path
+---for if the plugin is not on the packpath, or return nil
+---to load from the packpath or nixCats list as normal
+---@overload fun(dirs: string[]|string, load: fun(name: string):string|nil): fun(names: string|string[])
+function M.make_load_with_after(dirs, load)
+    dirs = (type(dirs) == "table" and dirs) or { dirs }
+    local fromPackpath = function(name)
+        for _, packpath in ipairs(vim.opt.packpath:get()) do
+            local plugin_path = vim.fn.globpath(packpath, "pack/*/opt/" .. name, nil, true, true)
+            if plugin_path[1] then
+                return plugin_path[1]
+            end
+        end
+        return nil
+    end
+    ---@param plugin_names string[]|string
+    return function(plugin_names)
+        local names = type(plugin_names) == "table" and plugin_names or { plugin_names }
+        local to_source = {}
+        for _, name in ipairs(names) do
+            if type(name) == "string" then
+                local path = (type(load) == "function" and load(name)) or nil
+                if type(path) == "string" then
+                    table.insert(to_source, { name = name, path = path })
+                else
+                    local ok, err = pcall(vim.cmd.packadd, name)
+                    if ok then
+                        table.insert(to_source, { name = name, path = nil })
+                    else
+                        vim.notify(
+                            '"packadd '
+                                .. name
+                                .. '" failed, and path provided by custom load function (if provided) was not a string\n'
+                                .. err,
+                            vim.log.levels.WARN,
+                            { title = "nixCatsUtils.load_with_after" }
+                        )
+                    end
+                end
+            else
+                vim.notify(
+                    "plugin name was not a string and was instead of value:\n" .. vim.inspect(name),
+                    vim.log.levels.WARN,
+                    { title = "nixCatsUtils.load_with_after" }
+                )
+            end
+        end
+        for _, info in pairs(to_source) do
+            local plugpath = info.path or vim.tbl_get(package.loaded, "nixCats", "pawsible", "allPlugins", "opt", info.name) or fromPackpath(info.name)
+            if type(plugpath) == "string" then
+                local afterpath = plugpath .. "/after"
+                for _, dir in ipairs(dirs) do
+                    if vim.fn.isdirectory(afterpath) == 1 then
+                        local plugin_dir = afterpath .. "/" .. dir
+                        if vim.fn.isdirectory(plugin_dir) == 1 then
+                            local files = vim.fn.glob(plugin_dir .. "/*", false, true)
+                            for _, file in ipairs(files) do
+                                if vim.fn.filereadable(file) == 1 then
+                                    vim.cmd("source " .. file)
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+-- A nixCats specific lze handler that you can use to conditionally enable by category easier.
+-- at the start of your config, register with
+-- require('lze').register_handlers(require('nixCatsUtils.lzUtils').for_cat)
+-- before any calls to require('lze').load using the handler have been made.
+-- accepts:
+-- for_cat = { "your" "cat" }; for_cat = { cat = { "your" "cat" }, default = bool }
+-- for_cat = "your.cat"; for_cat = { cat = "your.cat", default = bool }
+-- where default is an alternate value for when nixCats was NOT used to install the config
+M.for_cat = {
+    spec_field = "for_cat",
+    set_lazy = false,
+    modify = function(plugin)
+        if type(plugin.for_cat) == "table" then
+            if plugin.for_cat.cat ~= nil then
+                if vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil then
+                    plugin.enabled = (nixCats(plugin.for_cat.cat) and true) or false
+                else
+                    plugin.enabled = nixCats(plugin.for_cat.default)
+                end
+            else
+                plugin.enabled = (nixCats(plugin.for_cat) and true) or false
+            end
+        else
+            plugin.enabled = (nixCats(plugin.for_cat) and true) or false
+        end
+        return plugin
+    end,
+}
+
+return M

homes/modules/programs/neovim/lua/plugins/dressing.lua

@@ -0,0 +1,5 @@
+return {
+  {
+    "dressing.nvim"
+  },
+}

homes/modules/programs/neovim/lua/plugins/fyler.lua

@@ -0,0 +1,15 @@
+return {
+  {
+    "fyler.nvim",
+    cmd = { "Fyler" },
+    keys = {
+      { "<leader>tf", function() return require('fyler').toggle({ kind = "split_right" }) end, mode = {"n"}, desc = 'Open [F]yler' },
+    },
+    load = function (name)
+      vim.cmd.packadd(name)
+    end,
+    after = function(plugin)
+      local fyler = require("fyler").setup()
+    end,
+  },
+}

homes/modules/programs/neovim/lua/plugins/init.lua

@@ -0,0 +1,8 @@
+require("lze").load {
+  { import = "plugins.dressing", },
+  { import = "plugins.telescope", },
+  { import = "plugins.treesitter", },
+  { import = "plugins.fyler", },
+  { import = "plugins.mini-hipatterns", },
+  --{ import = "plugins.neocord", },
+}

homes/modules/programs/neovim/lua/plugins/mini-hipatterns.lua

@@ -0,0 +1,76 @@
+return {
+  {
+    "mini.hipatterns",
+    after = function(plugin)
+      local hipatterns = require("mini.hipatterns")
+
+      -- Returns hex color group for matching short hex color.
+      --
+      ---@param match string
+      ---@return string
+      local hex_color_short = function(_, match)
+        local style = 'fg' -- 'fg' or 'bg', for extmark_opts_inline use 'fg'
+        local r, g, b = match:sub(2, 2), match:sub(3, 3), match:sub(4, 4)
+        local hex = string.format('#%s%s%s%s%s%s', r, r, g, g, b, b)
+        return hipatterns.compute_hex_color_group(hex, style)
+      end
+
+      -- Returns hex color group for matching alpha hex color.
+      --
+      ---@param match string
+      ---@return string
+      local hex_color_alpha = function(_, match)
+        local style = 'fg' -- 'fg' or 'bg', for extmark_opts_inline use 'fg'
+        local r, g, b = match:sub(2, 3), match:sub(4, 5), match:sub(6, 7)
+        local hex = string.format('#%s%s%s', r, g, b)
+        return hipatterns.compute_hex_color_group(hex, style)
+      end
+
+      -- Returns extmark opts for highlights with virtual inline text.
+      --
+      ---@param data table Includes `hl_group`, `full_match` and more.
+      ---@return table
+      local extmark_opts_inline = function(_, _, data)
+        return {
+          virt_text = { { '󰧞', data.hl_group } },
+          virt_text_pos = 'inline',
+          right_gravity = false,
+        }
+      end
+
+      -- Returns extmark opts for highlights with virtual inline text.
+      --
+      ---@param data table Includes `hl_group`, `full_match` and more.
+      ---@return table
+      local extmark_opts_inline_alpha = function(_, _, data)
+        return {
+          virt_text = { { '󱡓', data.hl_group } },
+          virt_text_pos = 'inline',
+          right_gravity = false,
+        }
+      end
+
+      hipatterns.setup({
+	highlighters = {
+          -- #rrggbb
+	  hex_color = hipatterns.gen_highlighter.hex_color({
+	    style = "inline",
+            inline_text = '󰧞',
+	  }),
+          -- #rgb
+	  hex_color_short = {
+	    pattern = "#%x%x%x%f[%X]",
+	    group = hex_color_short,
+	    extmark_opts = extmark_opts_inline,
+	  },
+          -- #rrggbbaa
+	  hex_color_alpha = {
+	    pattern = "#%x%x%x%x%x%x%x%x%f[%X]",
+	    group = hex_color_alpha,
+	    extmark_opts = extmark_opts_inline_alpha,
+	  },
+	},
+      })
+    end,
+  },
+}

homes/modules/programs/neovim/lua/plugins/neocord.lua

@@ -0,0 +1,5 @@
+return {
+  {
+    "neocord",
+  },
+}

homes/modules/programs/neovim/lua/plugins/telescope.lua

@@ -0,0 +1,36 @@
+return {
+  {
+    "telescope.nvim",
+    cmd = { "Telescope" },
+   keys = {
+      { "<leader>f", function() return require('telescope.builtin').find_files() end, mode = {"n"}, desc = 'Telescope search [F]iles' },
+      { "<leader>tr", function() return require('telescope.builtin').oldfiles() end, mode = {"n"}, desc = '[T]elescope search [R]ecent files' },
+      { "<leader>ts", function() return require('telescope.builtin').live_grep() end, mode = {"n"}, desc = '[T]elescope [S]earch cwd with grep' },
+      { "<leader>tw", function() return require('telescope.builtin').grep_string() end, mode = {"n"}, desc = '[T]elescope search current [W]ord' },
+      { "<leader>tk", function() return require('telescope.builtin').keymaps() end, mode = {"n"}, desc = '[T]elescope search [K]eymaps' },
+      { "<leader>tb", function() return require('telescope.builtin').buffers() end, mode = {"n"}, desc = '[T]elescope search [B]uffers' },
+    },
+    load = function (name)
+      vim.cmd.packadd(name)
+      vim.cmd.packadd("telescope-fzf-native.nvim")
+    end,
+    after = function(plugin)
+      local telescope = require("telescope")
+      local actions = require("telescope.actions")
+
+      telescope.setup {
+        defaults = {
+	  mappings = {
+	    i = {
+	      ["<C-k>"] = actions.move_selection_previous, -- move to prev result
+	      ["<C-j>"] = actions.move_selection_next, -- move to next result
+	      ["<C-q>"] = actions.send_selected_to_qflist + actions.open_qflist
+	    }
+	  }
+	}
+      }
+
+      pcall(telescope.load_extension, "fzf")
+    end,
+  },
+}

homes/modules/programs/neovim/lua/plugins/treesitter.lua

@@ -0,0 +1,95 @@
+-- to help me write this after nvim-treesitter updated, i used:
+-- https://github.com/BirdeeHub/nixCats-nvim/blob/3c9bc4d7123e1b48d92f25ba505b889af541e897/templates/example/lua/myLuaConf/plugins/treesitter.lua
+
+return {
+  {
+    "nvim-treesitter",
+    lazy = false,
+    after = function (plugin)
+      --@param buf integer
+      --@param language string
+      local function treesitter_try_attach(buf, language)
+	--check if parser exists and load it
+	if not vim.treesitter.language.add(language) then
+	  return
+	end
+
+	-- enables syntax highlight and other treesitter features
+	vim.treesitter.start(buf, language)
+
+	-- enables treesitter based folds
+	vim.wo.foldexpr = "v:lua.vim.treesitter.foldexpr()"
+
+	-- enables treesiter based indentation
+	vim.bo.indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"
+      end
+
+      local available_parsers = require("nvim-treesitter").get_available()
+      vim.api.nvim_create_autocmd("FileType", {
+        callback = function(args)
+	  local buf, filetype = args.buf, args.match
+	  local language = vim.treesitter.language.get_lang(filetype)
+	  if not language then
+	    return
+	  end
+
+	  local installed_parsers = require("nvim-treesitter").get_installed("parsers")
+
+	  if vim.tbl_contains(installed_parsers, language) then
+	    -- enable the parser if it is installed
+	    treesitter_try_attach(buf, language)
+	  elseif vim.tbl_contains(available_parsers, language) then
+	    -- if a parser is available in `nvim-treesitter` enable it after ensuring it is installed
+	    require("nvim-treesitter").install(language):await(function()
+	      treesitter_try_attach(buf, language)
+	    end)
+	  else
+	    -- try to enable treesitter features in case the parser exists but is not available from `nvim-treesitter`
+	    treesitter_try_attach(buf, language)
+	  end
+	end,
+      })
+    end,
+  },
+  {
+    "nvim-treesitter-textobjects",
+    lazy = false,
+    before = function(plugin)
+      vim.g.no_plugin_maps = true
+    end,
+    after = function(plugin)
+      require("nvim-treesitter-textobjects").setup {
+        select = {
+	  lookahead = true,
+	  selection_modes = {
+	    ['@parameter.outer'] = 'v', -- charwise
+	    ['@function.outer'] = 'V', -- linewise
+	  },
+	  include_surrounding_whitespace = false,
+	},
+      }
+
+      -- keymaps
+      vim.keymap.set({ "x", "o" }, "am", function()
+        require "nvim-treesitter-textobjects.select".select_textobject("@function.outer", "textobjects")
+      end)
+      vim.keymap.set({ "x", "o" }, "im", function()
+        require "nvim-treesitter-textobjects.select".select_textobject("@function.inner", "textobjects")
+      end)
+      vim.keymap.set({ "x", "o" }, "ac", function()
+        require "nvim-treesitter-textobjects.select".select_textobject("@class.outer", "textobjects")
+      end)
+      vim.keymap.set({ "x", "o" }, "ic", function()
+        require "nvim-treesitter-textobjects.select".select_textobject("@class.inner", "textobjects")
+      end)
+      -- You can also use captures from other query groups like `locals.scm`
+      vim.keymap.set({ "x", "o" }, "as", function()
+        require "nvim-treesitter-textobjects.select".select_textobject("@local.scope", "locals")
+      end)
+
+      -- NOTE: for more textobjects options, see the following link.
+      -- This template is using the new `main` branch of the repo.
+      -- https://github.com/nvim-treesitter/nvim-treesitter-textobjects/tree/main
+    end,
+  },
+}