ported the lua, port is complete, I think.

lua/plugins/completion.lua

@@ -0,0 +1,156 @@
+local load_w_after = function(name)
+  vim.cmd.packadd(name)
+  vim.cmd.packadd(name .. '/after')
+end
+
+return {
+  {
+    "cmp-cmdline",
+    for_cat = "lazy",
+    on_plugin = { "blink.cmp" },
+    load = load_w_after,
+  },
+  {
+    "blink.compat",
+    for_cat = "lazy",
+    dep_of = { "cmp-cmdline" },
+  },
+  {
+    "luasnip",
+    for_cat = "lazy",
+    dep_of = { "blink.cmp" },
+    after = function(_)
+      vim.cmd.packadd("friendly-snippets")
+      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,
+  },
+  {
+    "colorful-menu.nvim",
+    for_cat = "lazy",
+    on_plugin = { "blink.cmp" },
+  },
+  {
+    "blink-emoji.nvim",
+    for_cat = "lazy",
+    on_plugin = { "blink.cmp" },
+  },
+  {
+    "blink.cmp",
+    for_cat = "lazy",
+    event = "DeferredUIEnter",
+    after = function(_)
+      require("blink.cmp").setup({
+        -- 'default' (recommended) for mappings similar to built-in completions (C-y to accept)
+        -- See :h blink-cmp-config-keymap for configuring keymaps
+        keymap = { preset = "enter", },
+        cmdline = {
+          enabled = true,
+          completion = {
+            menu = {
+              auto_show = true,
+            },
+          },
+          sources = function()
+            local type = vim.fn.getcmdtype()
+            -- Search forward and backward
+            if type == '/' or type == '?' then return { 'buffer' } end
+            -- Commands
+            if type == ':' or type == '@' then return { 'cmdline', 'cmp_cmdline' } end
+            return {}
+          end,
+        },
+        fuzzy = {
+          sorts = {
+            'exact',
+            -- defaults
+            'score',
+            'sort_text',
+          },
+        },
+        signature = {
+          enabled = true,
+          window = {
+            show_documentation = true,
+          },
+        },
+        completion = {
+          list = {
+            selection = {
+              preselect = false,
+              auto_insert = false,
+            },
+          },
+          menu = {
+            draw = {
+              treesitter = { 'lsp' },
+              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,
+                },
+              },
+            },
+          },
+          documentation = {
+            auto_show = true,
+          },
+        },
+        snippets = {
+          preset = 'luasnip',
+          active = function(filter)
+            local snippet = require "luasnip"
+            local blink = require "blink.cmp"
+            if snippet.in_snippet() and not blink.is_visible() then
+              return true
+            else
+              if not snippet.in_snippet() and vim.fn.mode() == "n" then snippet.unlink_current() end
+              return false
+            end
+          end,
+        },
+        sources = {
+          default = { 'lsp', 'path', 'snippets', 'buffer', 'omni', 'emoji', },
+          providers = {
+            path = {
+              score_offset = 50,
+            },
+            lsp = {
+              score_offset = 40,
+            },
+            snippets = {
+              score_offset = 40,
+            },
+            emoji = {
+              module = "blink-emoji",
+              name = "Emoji",
+              score_offset = 15,
+              opts = { insert = true },
+            },
+            cmp_cmdline = {
+              name = 'cmp_cmdline',
+              module = 'blink.compat.source',
+              score_offset = -100,
+              opts = {
+                cmp_name = 'cmdline',
+              },
+            },
+          },
+        },
+      })
+    end,
+  },
+}

lua/plugins/gitsigns.lua

@@ -0,0 +1,86 @@
+return {
+  {
+    "gitsigns.nvim",
+    for_cat = 'lazy',
+    event = "DeferredUIEnter",
+    -- cmd = { "" },
+    -- ft = "",
+    -- keys = "",
+    -- colorscheme = "",
+    after = function()
+      require('gitsigns').setup({
+        -- See `:help gitsigns.txt`
+        signs = {
+          add = { text = '+' },
+          change = { text = '~' },
+          delete = { text = '_' },
+          topdelete = { text = '‾' },
+          changedelete = { text = '~' },
+        },
+        on_attach = function(bufnr)
+          local gs = package.loaded.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', 'v' }, ']c', function()
+            if vim.wo.diff then
+              return ']c'
+            end
+            vim.schedule(function()
+              gs.next_hunk()
+            end)
+            return '<Ignore>'
+          end, { expr = true, desc = 'Jump to next hunk' })
+
+          map({ 'n', 'v' }, '[c', function()
+            if vim.wo.diff then
+              return '[c'
+            end
+            vim.schedule(function()
+              gs.prev_hunk()
+            end)
+            return '<Ignore>'
+          end, { expr = true, desc = 'Jump to previous hunk' })
+
+          -- Actions
+          -- visual mode
+          map('v', '<leader>hs', function()
+            gs.stage_hunk { vim.fn.line '.', vim.fn.line 'v' }
+          end, { desc = 'stage git hunk' })
+          map('v', '<leader>hr', function()
+            gs.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }
+          end, { desc = 'reset git hunk' })
+          -- normal mode
+          map('n', '<leader>gs', gs.stage_hunk, { desc = 'git stage hunk' })
+          map('n', '<leader>gr', gs.reset_hunk, { desc = 'git reset hunk' })
+          map('n', '<leader>gS', gs.stage_buffer, { desc = 'git Stage buffer' })
+          map('n', '<leader>gu', gs.undo_stage_hunk, { desc = 'undo stage hunk' })
+          map('n', '<leader>gR', gs.reset_buffer, { desc = 'git Reset buffer' })
+          map('n', '<leader>gp', gs.preview_hunk, { desc = 'preview git hunk' })
+          map('n', '<leader>gb', function()
+            gs.blame_line { full = false }
+          end, { desc = 'git blame line' })
+          map('n', '<leader>gd', gs.diffthis, { desc = 'git diff against index' })
+          map('n', '<leader>gD', function()
+            gs.diffthis '~'
+          end, { desc = 'git diff against last commit' })
+
+          -- Toggles
+          map('n', '<leader>gtb', gs.toggle_current_line_blame, { desc = 'toggle git blame line' })
+          map('n', '<leader>gtd', gs.toggle_deleted, { desc = 'toggle git show deleted' })
+
+          -- Text object
+          map({ 'o', 'x' }, 'ih', ':<C-U>Gitsigns select_hunk<CR>', { desc = 'select git hunk' })
+        end,
+      })
+      vim.cmd([[hi GitSignsAdd guifg=#04de21]])
+      vim.cmd([[hi GitSignsChange guifg=#83fce6]])
+      vim.cmd([[hi GitSignsDelete guifg=#fa2525]])
+    end,
+  },
+}

lua/plugins/init.lua

@@ -0,0 +1,39 @@
+local colorschemeName = nixInfo("retrobox", "settings", "colorscheme")
+
+vim.cmd.colorscheme(colorschemeName)
+
+require("plugins.lualine")
+require("plugins.oil")
+require("plugins.snacks")
+
+require('lze').load {
+  { import = "plugins.treesitter", },
+  { import = "plugins.gitsigns", },
+  { import = "plugins.which-key", },
+  { import = "plugins.completion", },
+  { import = "plugins.preview.markdown", },
+  { import = "plugins.preview.typst", },
+  {
+    "leap.nvim",
+    for_cat = 'always',
+    event = "DeferredUIEnter",
+    keys = {
+      { "s", "<Plug>(leap)", mode = { "n", "x", "o", "v" }, noremap = true, desc = "leap to char sequence" }
+    },
+  },
+  {
+    "nvim-surround",
+    for_cat = 'always',
+    event = "DeferredUIEnter",
+    after = function()
+      require('nvim-surround').setup()
+    end,
+  },
+  {
+    "marks.nvim",
+    for_cat = "always",
+    after = function()
+      require('marks').setup({})
+    end
+  },
+}

lua/plugins/lualine.lua

@@ -0,0 +1,36 @@
+-- lualine
+require("lualine").setup({
+  options = {
+    alwaysDivideMiddle = true,
+    icons_enabled = true,
+    component_separators = { left = "", right = "" },
+    section_separators = { left = "", right = "" },
+  },
+  inactive_sections = {
+    lualine_a = {},
+    lualine_b = {},
+    lualine_c = { "filename" },
+    lualine_x = { "filetype" },
+    lualine_y = {},
+    lualine_z = {},
+  },
+  sections = {
+    lualine_a = { "mode" },
+    lualine_b = { "branch", "diff", "diagnostics" },
+    lualine_c = { { "filename", path = 1 } },
+    lualine_x = { "encoding", "fileformat", "filetype" },
+    lualine_y = { "progress" },
+    lualine_z = { "location" },
+  },
+  tabline = {
+    lualine_a = { { "buffers", mode = 4 } },
+    lualine_b = {},
+    lualine_c = {},
+    lualine_x = {},
+    lualine_y = {},
+    lualine_z = { { "tabs", mode = 2 } }
+  },
+})
+
+-- marks.nvim
+require("marks").setup({})

lua/plugins/oil.lua

@@ -0,0 +1,45 @@
+-- oil.nvim
+vim.g.loaded_netrwPlugin = 1
+require("oil").setup({
+  default_file_explorer = false,
+  view_options = {
+    show_hidden = true
+  },
+  columns = {
+    "icon",
+    "permissions",
+    "size",
+    -- "mtime",
+  },
+  keymaps = {
+    ["g?"] = "actions.show_help",
+    ["<CR>"] = "actions.select",
+    ["<C-s>"] = "actions.select_vsplit",
+    ["<C-h>"] = "actions.select_split",
+    ["<C-t>"] = "actions.select_tab",
+    ["<C-p>"] = "actions.preview",
+    ["<C-c>"] = "actions.close",
+    ["<C-l>"] = "actions.refresh",
+    ["-"] = "actions.parent",
+    ["_"] = "actions.open_cwd",
+    ["`"] = "actions.cd",
+    ["~"] = "actions.tcd",
+    ["gs"] = "actions.change_sort",
+    ["gx"] = "actions.open_external",
+    ["g."] = "actions.toggle_hidden",
+    ["g\\"] = "actions.toggle_trash",
+  },
+})
+-- setup rename autocmds
+local prev = { new_name = "", old_name = "" } -- Prevents duplicate events
+vim.api.nvim_create_autocmd("User", {
+  pattern = "OilActionsPost",
+  callback = function(event)
+    if event.data.actions.type == "move" then
+      Snacks.rename.on_rename_file(event.data.actions.src_url, event.data.actions.dest_url)
+    end
+  end,
+})
+-- oil keybinds
+vim.keymap.set("n", "-", "<cmd>Oil<CR>", { noremap = true, desc = "Open Parent Directory" })
+vim.keymap.set("n", "<leader>-", "<cmd>Oil .<CR>", { noremap = true, desc = "Open nvim root directory" })

lua/plugins/preview/markdown.lua

@@ -0,0 +1,19 @@
+return {
+  "markdown-preview.nvim",
+  -- NOTE: for_cat is a custom handler that just sets enabled value for us,
+  -- based on result of nixCats('cat.name') and allows us to set a different default if we wish
+  -- it is defined in luaUtils template in lua/nixCatsUtils/lzUtils.lua
+  -- you could replace this with enabled = nixCats('cat.name') == true
+  -- if you didnt care to set a different default for when not using nix than the default you already set
+  for_cat = 'markdown',
+  cmd = { "MarkdownPreview", "MarkdownPreviewStop", "MarkdownPreviewToggle", },
+  ft = "markdown",
+  keys = {
+    { "<leader>Pmp", "<cmd>MarkdownPreview <CR>",       mode = { "n" }, noremap = true, desc = "markdown preview" },
+    { "<leader>Pms", "<cmd>MarkdownPreviewStop <CR>",   mode = { "n" }, noremap = true, desc = "markdown preview stop" },
+    { "<leader>Pmt", "<cmd>MarkdownPreviewToggle <CR>", mode = { "n" }, noremap = true, desc = "markdown preview toggle" },
+  },
+  before = function()
+    vim.g.mkdp_auto_close = 0
+  end,
+}

lua/plugins/preview/typst.lua

@@ -0,0 +1,14 @@
+return {
+  "typst-preview.nvim",
+  for_cat = "typst",
+  ft = "typst",
+  cmd = { "TypstPreview", "TypstPreviewStop", "TypstPreviewToggle", },
+  keys = {
+    { "<leader>ptp", "<cmd>TypstPreview <CR>",       mode = { "n" }, noremap = true, desc = "typst preview" },
+    { "<leader>pts", "<cmd>TypstPreviewStop <CR>",   mode = { "n" }, noremap = true, desc = "typst preview stop" },
+    { "<leader>ptt", "<cmd>TypstPreviewToggle <CR>", mode = { "n" }, noremap = true, desc = "typst preview toggle" },
+  },
+  after = function()
+    require('typst-preview').setup {}
+  end
+}

lua/plugins/snacks.lua

@@ -0,0 +1,87 @@
+-- snacks.nvim setup
+require("snacks").setup({
+  bufdelete = { enable = true },
+  dim = { enable = true },
+  git = { enable = true },
+  input = { enable = true },
+  notifier = { enable = true },
+  terminal = { enable = true },
+  toggle = { enable = true },
+  quickfile = { enable = true },
+  scope = { enable = true },
+  statuscolumn = { enable = true },
+
+  explorer = { replace_netrw = true },
+  picker = {
+    enabled = true,
+    ui_select = true,
+    matcher = {
+      fuzzy = true,
+      frecency = true,
+    },
+    previewers = {
+      diff = {
+        builtin = true,    -- use Neovim for previewing diffs (true) or use an external tool (false)
+        cmd = { "delta" }, -- example to show a diff with delta
+      },
+      git = {
+        builtin = true, -- use Neovim for previewing git output (true) or use git (false)
+      },
+    },
+  },
+  indent = {
+    enabled = true,
+    animate = { enabled = false },
+    scope = { enabled = true },
+    chunk = { enabled = true },
+  },
+  image = { enabled = false, inline = false, float = false },
+  lazygit = { enabled = true, configure = false },
+})
+-- setup keybinds.
+vim.keymap.set("n", "<leader>bd", Snacks.bufdelete.delete, { desc = "delete buffer" })
+vim.keymap.set("n", "<leader>t", function() Snacks.explorer() end, { desc = "File [T]ree" })
+vim.keymap.set("n", "<leader>i", Snacks.image.hover, { desc = "[I]mage preview" })
+
+-- picker keybinds
+vim.keymap.set("n", "<leader>fGb", Snacks.picker.grep_buffers, { desc = "[G]rep buffers" })
+vim.keymap.set("n", "<leader>fGl", Snacks.picker.lines, { desc = "[L]ines in buffer" })
+vim.keymap.set("n", "<leader>fb", Snacks.picker.buffers, { desc = "[B]uffers" })
+vim.keymap.set("n", "<leader>ff", Snacks.picker.files, { desc = "[F]iles" })
+vim.keymap.set("n", "<leader>fg", Snacks.picker.grep, { desc = "[G]rep all" })
+vim.keymap.set("n", "<leader>fh", Snacks.picker.help, { desc = "[H]elp" })
+vim.keymap.set("n", "<leader>fi", Snacks.picker.icons, { desc = "[I]cons" })
+vim.keymap.set("n", "<leader>fm", Snacks.picker.marks, { desc = "[M]arks" })
+vim.keymap.set("n", "<leader>fs", Snacks.picker.spelling, { desc = "[S]pelling" })
+vim.keymap.set("n", "<leader>ft", Snacks.picker.treesitter, { desc = "[T]reesitter" })
+vim.keymap.set("n", "<leader>fu", Snacks.picker.undo, { desc = "[U]ndo" })
+vim.keymap.set("n", "<leader>fz", Snacks.picker.zoxide, { desc = "[Z]oxide" })
+
+-- picker git keybinds
+vim.keymap.set("n", "<leader>gB", Snacks.git.blame_line, { desc = "[G]it [B]lame" })
+vim.keymap.set("n", "<leader>gb", Snacks.picker.git_branches, { desc = "[G]it [B]ranch" })
+vim.keymap.set("n", "<leader>gl", Snacks.picker.git_log, { desc = "[G]it [L]og" })
+vim.keymap.set("n", "<leader>gd", Snacks.picker.git_diff, { desc = "[G]it [D]iff" })
+vim.keymap.set("n", "<leader>gt", Snacks.lazygit.open, { desc = "lazy[G]it [T]UI" })
+
+-- setup toggles
+Snacks.toggle.option("spell", { name = "spelling" }):map("<leader>cs")
+Snacks.toggle.option("relativenumber", { name = "Relative Numbering" }):map("<leader>n")
+Snacks.toggle.dim():map("<leader>d")
+
+-- terminal keybinds
+vim.keymap.set("n", "<leader>s", function()
+  Snacks.terminal.toggle(nil, { win = { position = "float" } })
+end, { desc = "terminal" })
+
+-- double tap escape leaves terminal mode
+vim.keymap.set("t", "<esc>", function(self)
+  self.esc_timer = self.esc_timer or (vim.uv or vim.loop).new_timer()
+  if self.esc_timer:is_active() then
+    self.esc_timer:stop()
+    vim.cmd("stopinsert")
+  else
+    self.esc_timer:start(200, 0, function() end)
+    return "<esc>"
+  end
+end, { expr = true, desc = "Double tap to escape terminal" })

lua/plugins/treesitter.lua

@@ -0,0 +1,36 @@
+-- [[ Configure Treesitter ]]
+-- See `:help nvim-treesitter`
+return {
+  {
+    "nvim-treesitter",
+  for_cat = 'lazy',
+    event = "DeferredUIEnter",
+    load = function(name)
+      vim.cmd.packadd(name)
+      vim.cmd.packadd("rainbow-delimiters.nvim")
+    end,
+    after = function()
+      require('nvim-treesitter').setup {
+        highlight = { enable = true, },
+        indent = { enable = false, },
+      }
+    end,
+  },
+  {
+    "comment.nvim",
+  for_cat = 'lazy',
+    after = function(plugin)
+      require('Comment').setup()
+    end,
+  },
+  {
+    "treesj",
+  for_cat = 'lazy',
+    keys = { { "<leader>j", "<cmd>TSJToggle<CR>", mode = { "n" }, desc = "Treesitter join" }, },
+    after = function(_)
+      require("treesj").setup({
+        use_default_keymaps = false
+      })
+    end
+  },
+}

lua/plugins/which-key.lua

@@ -0,0 +1,22 @@
+return {
+  {
+    "which-key.nvim",
+    for_cat = 'lazy',
+    after = function()
+      require('which-key').setup({})
+      require('which-key').add {
+        { "<leader>g",  group = "[g]it" },
+        { "<leader>z",  group = "[z]ettelkasten" },
+        { "<leader>gt", group = "[t]oggle" },
+        { "<leader>p",  group = "[p]review" },
+        { "<leader>pt", group = "[p]review [t]ypst" },
+        { "<leader>pm", group = "[p]review [m]arkdown" },
+        { "<leader>f",  group = "[f]ind" },
+        { "<leader>t",  group = "[t]ree" },
+        { "<leader>c",  group = "[c]heck" },
+        { "<leader>l",  group = "[l]sp" },
+        { "<leader>lw", group = "[l]sp [w]orkspace" },
+      }
+    end,
+  },
+}