add marks.nvim

.gitignore

@@ -4,6 +4,7 @@ undodir
 lua/config/
 lua/plugins/
 lua/lisp-school.lua
+lua/supermaven-blink.lua
 
 # Clojure/LSP tooling
 .clj-kondo/

CLAUDE.md

@@ -13,7 +13,7 @@ Neovim config using Fennel (a Lisp that compiles to Lua) via nfnl.
 **After editing ANY `.fnl` file, you MUST compile it to Lua:**
 
 ```bash
-cd ~/.config/nvim && nvim --headless -c "NfnlCompileAllFiles" -c "qa"
+~/.config/nvim/script/build
 ```
 
 If compilation says "destination-exists", delete the target lua file first:
@@ -54,7 +54,7 @@ Mason auto-installs: clojure-lsp, clj-kondo, fennel-ls, lua-language-server
 Uses Neovim 0.11+ built-in LSP (`vim.lsp.config` / `vim.lsp.enable`), NOT nvim-lspconfig:
 - **clojure_lsp** - .clj/.edn files
 - **lua_ls** - .lua files
-- **fennel_language_server** - .fnl files
+- **fennel_ls** - .fnl files
 
 ## Leader Keys
 

fnl/config/init.fnl

@@ -80,15 +80,31 @@
    :settings {:Lua {:runtime {:version :LuaJIT}
                     :workspace {:library (vim.api.nvim_get_runtime_file "" true)}}}})
 
-(vim.lsp.config :fennel_language_server
+(vim.lsp.config :fennel_ls
-  {:cmd [:fennel-language-server]
+  {:cmd [:fennel-ls]
    :filetypes [:fennel]
    :root_markers [:.nfnl.fnl :fnl :.git]
    :settings {:fennel {:workspace {:library (vim.api.nvim_get_runtime_file "" true)}
                        :diagnostics {:globals [:vim]}}}})
 
-;; Enable the configured LSP servers
+;; rust-analyzer: prefer nightly toolchain (version-matched to proc-macro server),
-(vim.lsp.enable [:clojure_lsp :lua_ls :fennel_language_server])
+;; then PATH, then Mason
+(local rust-analyzer-bin
+  (let [nightly-ra (.. (vim.fn.expand "~") "/.rustup/toolchains/nightly-aarch64-apple-darwin/bin/rust-analyzer")]
+    (if (= (vim.fn.executable nightly-ra) 1)
+        nightly-ra
+        (= (vim.fn.executable "rust-analyzer") 1)
+        "rust-analyzer"
+        (.. (vim.fn.stdpath "data") "/mason/bin/rust-analyzer"))))
+
+(vim.lsp.config :rust_analyzer
+  {:cmd [rust-analyzer-bin]
+   :filetypes [:rust]
+   :root_markers [:Cargo.toml :Cargo.lock :.git]
+   :settings {:rust-analyzer {:checkOnSave {:command "clippy"}}}})
+
+;; Enable the configured LSP servers (roslyn handled by roslyn.nvim plugin)
+(vim.lsp.enable [:clojure_lsp :lua_ls :fennel_ls :rust_analyzer])
 
 ;; LSP keymaps (set on attach)
 (autocmd "LspAttach"
@@ -107,8 +123,8 @@
                  opts)
                (keymap :n "<leader>rn" vim.lsp.buf.rename opts)
                (keymap :n "<leader>ca" vim.lsp.buf.code_action opts)
-               (keymap :n "[d" (fn [] (vim.diagnostic.jump {:count -1})) opts)
+               (keymap :n "[d" (fn [] (vim.diagnostic.jump {:count -1 :float true})) opts)
-               (keymap :n "]d" (fn [] (vim.diagnostic.jump {:count 1})) opts)
+               (keymap :n "]d" (fn [] (vim.diagnostic.jump {:count 1 :float true})) opts)
                (keymap :n "<leader>e" vim.diagnostic.open_float opts)
                (keymap :n "<leader>F" vim.lsp.buf.format opts))})
 
@@ -123,9 +139,9 @@
   (fn [opts]
     (if (and opts.args (> (length opts.args) 0))
         (vim.lsp.enable opts.args)
-        (vim.lsp.enable [:clojure_lsp :lua_ls :fennel_language_server])))
+        (vim.lsp.enable [:clojure_lsp :lua_ls :fennel_ls :rust_analyzer])))
   {:nargs "?"
-   :complete (fn [] [:clojure_lsp :lua_ls :fennel_language_server])
+   :complete (fn [] [:clojure_lsp :lua_ls :fennel_ls :rust_analyzer])
    :desc "Start LSP server"})
 
 (usercmd "LspStop"

fnl/config/parinfer.fnl

@@ -1,45 +0,0 @@
-;; config/parinfer.fnl - Parinfer + vim-sexp insert mode coordination
-;;
-;; Single source of truth for whether parinfer is on/off by default
-;; and what that means for vim-sexp's auto-insert bracket mappings.
-;;
-;; When parinfer is ON:  it manages closing parens via indentation,
-;;                       so vim-sexp auto-insert is disabled.
-;; When parinfer is OFF: vim-sexp auto-insert is re-enabled so you
-;;                       get closing brackets when typing openers.
-
-;; ── Configuration ────────────────────────────────────────────────
-;; Change this single flag to flip the default for all sexp filetypes.
-
-(local default-enabled false)
-
-;; ── Implementation ───────────────────────────────────────────────
-
-(local sexp-insert-keys ["(" ")" "[" "]" "{" "}" "\"" "<BS>"])
-
-(fn enable-sexp-insert []
-  "Restore vim-sexp insert-mode bracket mappings in the current buffer."
-  (vim.cmd "imap <silent><buffer> (    <Plug>(sexp_insert_opening_round)")
-  (vim.cmd "imap <silent><buffer> )    <Plug>(sexp_insert_closing_round)")
-  (vim.cmd "imap <silent><buffer> [    <Plug>(sexp_insert_opening_square)")
-  (vim.cmd "imap <silent><buffer> ]    <Plug>(sexp_insert_closing_square)")
-  (vim.cmd "imap <silent><buffer> {    <Plug>(sexp_insert_opening_curly)")
-  (vim.cmd "imap <silent><buffer> }    <Plug>(sexp_insert_closing_curly)")
-  (vim.cmd "imap <silent><buffer> \"   <Plug>(sexp_insert_double_quote)")
-  (vim.cmd "imap <silent><buffer> <BS> <Plug>(sexp_insert_backspace)"))
-
-(fn disable-sexp-insert []
-  "Remove vim-sexp insert-mode bracket mappings from the current buffer."
-  (each [_ key (ipairs sexp-insert-keys)]
-    (pcall vim.api.nvim_buf_del_keymap 0 "i" key)))
-
-(fn toggle []
-  "Toggle parinfer in the current buffer and sync vim-sexp insert mappings."
-  (vim.cmd "ParinferToggle")
-  (let [on (= (vim.api.nvim_buf_get_var 0 "parinfer_enabled") 1)]
-    (if on
-      (disable-sexp-insert)
-      (enable-sexp-insert))))
-
-{:default-enabled default-enabled
- :toggle toggle}

fnl/plugins/init.fnl

@@ -46,72 +46,34 @@
                   (fn [] (vim.cmd "ConjureLogTab"))
                   {:desc "Conjure log tab"})))}
 
- ;; nvim-parinfer - Automatic parenthesis balancing
+ ;; vim-sexp + tpope's mappings - Structural editing for S-expressions
- ;; See fnl/config/parinfer.fnl for default-enabled flag and toggle logic
+ ;; Loaded eagerly so VimEnter fires before plugin sources, letting
- {repo "gpanders/nvim-parinfer"
+ ;; vim-sexp-mappings-for-regular-people register its FileType autocmds.
-  :ft ["fennel" "clojure" "lisp" "scheme" "racket" "carp" "timl"]
+ {repo "tpope/vim-sexp-mappings-for-regular-people"  :lazy false
-  :init (fn []
-          (let [par (require :config.parinfer)]
-            (set vim.g.parinfer_enabled par.default-enabled)))
-  :keys [{lhs "<leader>tpi"
-          rhs (fn [] (let [par (require :config.parinfer)] (par.toggle)))
-          :desc "Toggle Parinfer"}]}
-
- ;; vim-sexp - Structural editing for S-expressions
- ;; with tpope's vim-sexp-mappings-for-regular-people
- {repo "guns/vim-sexp"
-  :ft ["fennel" "clojure" "lisp" "scheme" "racket"]
   :dependencies ["tpope/vim-repeat"
-                 "tpope/vim-sexp-mappings-for-regular-people"]
+                 "guns/vim-sexp"]
-  :init (fn []
-          (set vim.g.sexp_filetypes "clojure,scheme,lisp,timl,fennel,racket")
-          ;; Sync sexp auto-insert with parinfer default
-          (let [par (require :config.parinfer)]
-            (set vim.g.sexp_enable_insert_mode_mappings
-                 (if par.default-enabled 0 1))))
   :config (fn []
-            ;; vim-sexp-mappings-for-regular-people's setup is VimEnter-gated.
+          (set vim.g.sexp_filetypes "clojure,scheme,lisp,timl,fennel,racket")
-            ;; Under lazy.nvim :ft loading, VimEnter has already fired by the
+          (set vim.g.sexp_enable_insert_mode_mappings 0))}
-            ;; time the plugin sources, so its FileType autocmd never registers
+
-            ;; and the slurp/barf/swap mappings never attach. Register our own
+ ;; vim-surround - Add/change/delete surrounding pairs (quotes, brackets, tags)
-            ;; FileType autocmd that maps the <Plug>s directly.
+ {repo "tpope/vim-surround"
-            (let [fts (or vim.g.sexp_filetypes "clojure,scheme,lisp,timl,fennel,racket")
+  :dependencies ["tpope/vim-repeat"]
-                  attach (fn []
+  :event "VeryLazy"}
-                           (let [m (fn [lhs rhs]
-                                     (vim.keymap.set :n lhs rhs
-                                       {:buffer 0 :silent true :remap true}))]
-                             (m "<I" "<Plug>(sexp_insert_at_list_head)")
-                             (m ">I" "<Plug>(sexp_insert_at_list_tail)")
-                             (m "<f" "<Plug>(sexp_swap_list_backward)")
-                             (m ">f" "<Plug>(sexp_swap_list_forward)")
-                             (m "<e" "<Plug>(sexp_swap_element_backward)")
-                             (m ">e" "<Plug>(sexp_swap_element_forward)")
-                             (m ">(" "<Plug>(sexp_emit_head_element)")
-                             (m "<)" "<Plug>(sexp_emit_tail_element)")
-                             (m "<(" "<Plug>(sexp_capture_prev_element)")
-                             (m ">)" "<Plug>(sexp_capture_next_element)")
-                             (m "dsf" "<Plug>(sexp_splice_list)")))]
-              (vim.api.nvim_create_augroup "sexp_regular_people_fix" {:clear true})
-              (vim.api.nvim_create_autocmd "FileType"
-                {:group "sexp_regular_people_fix"
-                 :pattern (vim.split fts ",")
-                 :callback attach})
-              ;; Attach to current buffer (the FileType that triggered lazy load
-              ;; already fired before this autocmd was registered).
-              (when (vim.tbl_contains (vim.split fts ",") vim.bo.filetype)
-                (attach))))}
 
  ;; Mason - Package manager for LSP servers, DAP servers, linters, formatters
  {repo "williamboman/mason.nvim"
   :lazy false
   :build ":MasonUpdate"
-  :opts {:ui {:border "rounded"}}}
+  :opts {:ui {:border "rounded"}
+         :registries ["github:mason-org/mason-registry"
+                      "github:Crashdummyy/mason-registry"]}}
 
  ;; Auto-install LSP servers and tools via Mason
  {repo "WhoIsSethDaniel/mason-tool-installer.nvim"
   :lazy false
   :dependencies ["williamboman/mason.nvim"]
-  :opts {:ensure_installed ["clojure-lsp" "clj-kondo" "fennel-language-server" "lua-language-server"]}}
+  :opts {:ensure_installed ["clojure-lsp" "clj-kondo" "fennel-ls" "lua-language-server" "rust-analyzer" "roslyn"]}}
 
  ;; Hop - EasyMotion-like word jumping
  {repo "smoka7/hop.nvim"
@@ -151,15 +113,63 @@
                {lhs "<leader>c" :group "code"}
                {lhs "<leader>h" :group "hunk"}
                {lhs "<leader>t" :group "toggle"}
-               {lhs "<leader>l" :group "log"}]))}
+               {lhs "<leader>l" :group "log"}
+               {lhs "<leader>a" :group "AI/Claude"}]))}
+
+ ;; claudecode.nvim - Claude Code AI assistant integration
+ {repo "coder/claudecode.nvim"
+  :dependencies ["folke/snacks.nvim"]
+  :config true
+  :keys [{lhs "<leader>a" :desc "AI/Claude Code"}
+         {lhs "<leader>ac" rhs "<cmd>ClaudeCode<cr>" :desc "Toggle Claude"}
+         {lhs "<leader>af" rhs "<cmd>ClaudeCodeFocus<cr>" :desc "Focus Claude"}
+         {lhs "<leader>ar" rhs "<cmd>ClaudeCode --resume<cr>" :desc "Resume Claude"}
+         {lhs "<leader>aC" rhs "<cmd>ClaudeCode --continue<cr>" :desc "Continue Claude"}
+         {lhs "<leader>am" rhs "<cmd>ClaudeCodeSelectModel<cr>" :desc "Select Claude model"}
+         {lhs "<leader>ab" rhs "<cmd>ClaudeCodeAdd %<cr>" :desc "Add current buffer"}
+         {lhs "<leader>as" rhs "<cmd>ClaudeCodeSend<cr>" :mode "v" :desc "Send to Claude"}
+         {lhs "<leader>as" rhs "<cmd>ClaudeCodeTreeAdd<cr>" :desc "Add file"
+          :ft ["NvimTree" "neo-tree" "oil" "minifiles" "netrw"]}
+         {lhs "<leader>aa" rhs "<cmd>ClaudeCodeDiffAccept<cr>" :desc "Accept diff"}
+         {lhs "<leader>ad" rhs "<cmd>ClaudeCodeDiffDeny<cr>" :desc "Deny diff"}]}
+
+ ;; Supermaven - AI code completion
+ {repo "supermaven-inc/supermaven-nvim"
+  :event "InsertEnter"
+  :opts {:disable_inline_completion true}}
 
  ;; blink.cmp - Fast completion engine with LSP support
  {repo "saghen/blink.cmp"
   :version "*"
   :event ["InsertEnter" "CmdlineEnter"]
-  :opts {:keymap {:preset "super-tab"}
+  :dependencies ["supermaven-inc/supermaven-nvim"]
-         :completion {:documentation {:auto_show true}}
+  :opts {:keymap {:preset "super-tab"
-         :sources {:default ["lsp" "path" "buffer"]}}}
+                  "<C-Space>" [(fn [cmp] (cmp.show {:providers ["supermaven"]})) :fallback]
+                  "<Tab>" [:select_and_accept :snippet_forward :fallback]
+                  "<Esc>" [(fn [cmp] (cmp.cancel) false) :fallback]}
+         :completion {:list {:selection {:preselect true :auto_insert false}}
+                      :documentation {:auto_show true}}
+         :sources {:default ["lsp" "path" "buffer"]
+                   :providers {:supermaven {:name "Supermaven"
+                                            :module "supermaven-blink"}}}}}
+
+ ;; roslyn.nvim - C# and Blazor/Razor LSP via Roslyn language server
+ ;; Must not be ft-gated: plugin/roslyn.lua calls vim.lsp.enable which needs to
+ ;; run before the FileType event fires, or existing .cs buffers won't attach.
+ {repo "seblj/roslyn.nvim"
+  :lazy false
+  :config (fn []
+            (let [roslyn (require :roslyn)]
+              (roslyn.setup {})))}
+
+ ;; marks.nvim - Show mark letters in the sign column
+ {repo "chentoast/marks.nvim"
+  :event "VeryLazy"
+  :opts {:default_mappings true
+         :builtin_marks []
+         :cyclic true
+         :force_write_shada true
+         :sign_priority 10}}
 
  ;; gitsigns.nvim - Git diff signs in the sign column
  {repo "lewis6991/gitsigns.nvim"

fnl/supermaven-blink.fnl

@@ -0,0 +1,38 @@
+(local M {})
+
+(fn M.new []
+  (setmetatable {} {:__index M}))
+
+(fn M.get_completions [self ctx callback]
+  (let [(ok preview) (pcall require :supermaven-nvim.completion_preview)]
+    (if (not ok)
+        (callback {:is_incomplete_backward false :is_incomplete_forward false :items []})
+        (let [inst (preview:get_inlay_instance)]
+          (if (or (= inst nil) (= inst.is_active false))
+              (callback {:is_incomplete_backward false :is_incomplete_forward false :items []})
+              (let [text inst.completion_text
+                    lines (vim.split text "\n" {:plain true})
+                    raw-label (: (. lines 1) :gsub "^%s*" "")
+                    label (if (> (length raw-label) 40)
+                              (.. (raw-label:sub 1 20) " ... " (raw-label:sub -15))
+                              raw-label)
+                    row (- (. ctx.cursor 1) 1)
+                    col-start (math.max (- (. ctx.cursor 2) (or inst.prior_delete 0)) 0)
+                    col-end (vim.fn.col "$")
+                    range {:start {:line row :character col-start}
+                           :end   {:line row :character col-end}}]
+                (callback {:is_incomplete_backward false
+                           :is_incomplete_forward false
+                           :items [{:label label
+                                    :kind (. vim.lsp.protocol.CompletionItemKind :Text)
+                                    :insertTextFormat (if (> (length lines) 1) 2 1)
+                                    :textEdit {:newText text :insert range :replace range}
+                                    :documentation {:kind :markdown
+                                                    :value (.. "```" vim.bo.filetype "\n" text "\n```")}}]})))))))
+
+(fn M.execute [self ctx item resolve default-impl]
+  (pcall (fn [] (: (require :supermaven-nvim.completion_preview) :dispose_inlay)))
+  (default-impl)
+  (resolve))
+
+M

lazy-lock.json

@@ -1,19 +1,24 @@
 {
-  "blink.cmp": { "branch": "main", "commit": "4b18c32adef2898f95cdef6192cbd5796c1a332d" },
+  "blink.cmp": { "branch": "main", "commit": "78336bc89ee5365633bcf754d93df01678b5c08f" },
-  "conjure": { "branch": "main", "commit": "403639610bcb9b6a5dfc494dc3179cc19773a471" },
+  "claudecode.nvim": { "branch": "main", "commit": "102d835c964069c9c5e37abaf05ae4f9c3ee6f00" },
-  "gitsigns.nvim": { "branch": "main", "commit": "7c4faa3540d0781a28588cafbd4dd187a28ac6e3" },
+  "conjure": { "branch": "main", "commit": "f7a375995a19fbf085707ea0fdb1f9c167e27e27" },
+  "gitsigns.nvim": { "branch": "main", "commit": "dd3f588bacbeb041be6facf1742e42097f62165d" },
   "hop.nvim": { "branch": "master", "commit": "08ddca799089ab96a6d1763db0b8adc5320bf050" },
   "lazy.nvim": { "branch": "main", "commit": "306a05526ada86a7b30af95c5cc81ffba93fef97" },
+  "marks.nvim": { "branch": "master", "commit": "f353e8c08c50f39e99a9ed474172df7eddd89b72" },
   "mason-tool-installer.nvim": { "branch": "main", "commit": "443f1ef8b5e6bf47045cb2217b6f748a223cf7dc" },
-  "mason.nvim": { "branch": "main", "commit": "44d1e90e1f66e077268191e3ee9d2ac97cc18e65" },
+  "mason.nvim": { "branch": "main", "commit": "e54f5bf5f12c560da31c17eee5b3e1bd369f3ff9" },
-  "nfnl": { "branch": "main", "commit": "fecf731e02bc51d88372c4f992fe1ef0c19c02ae" },
+  "nfnl": { "branch": "main", "commit": "ac0177c5549df7abba7a19554c18a7765386c894" },
-  "nvim-parinfer": { "branch": "master", "commit": "3968e669d9f02589aa311d33cb475b16b27c5fbb" },
+  "nvim-treesitter": { "branch": "main", "commit": "4916d6592ede8c07973490d9322f187e07dfefac" },
-  "nvim-treesitter": { "branch": "main", "commit": "f8bbc3177d929dc86e272c41cc15219f0a7aa1ac" },
+  "plenary.nvim": { "branch": "master", "commit": "74b06c6c75e4eeb3108ec01852001636d85a932b" },
-  "plenary.nvim": { "branch": "master", "commit": "b9fd5226c2f76c951fc8ed5923d85e4de065e509" },
+  "roslyn.nvim": { "branch": "main", "commit": "b62d1a588765f0aa1b46ed260252c9e456408835" },
-  "telescope.nvim": { "branch": "master", "commit": "a0bbec21143c7bc5f8bb02e0005fa0b982edc026" },
+  "snacks.nvim": { "branch": "main", "commit": "ad9ede6a9cddf16cedbd31b8932d6dcdee9b716e" },
-  "tokyonight.nvim": { "branch": "main", "commit": "5da1b76e64daf4c5d410f06bcb6b9cb640da7dfd" },
+  "supermaven-nvim": { "branch": "main", "commit": "07d20fce48a5629686aefb0a7cd4b25e33947d50" },
+  "telescope.nvim": { "branch": "master", "commit": "f04ab730b8f9c6bf3f54a206d0dcddfd70c52d59" },
+  "tokyonight.nvim": { "branch": "main", "commit": "cdc07ac78467a233fd62c493de29a17e0cf2b2b6" },
   "vim-repeat": { "branch": "master", "commit": "65846025c15494983dafe5e3b46c8f88ab2e9635" },
-  "vim-sexp": { "branch": "master", "commit": "2fc0a7c7e44fe94e48156d6a5b5fea28538430eb" },
+  "vim-sexp": { "branch": "master", "commit": "c6e7180781c5603f5ea0e2305adb0c117e4f8284" },
   "vim-sexp-mappings-for-regular-people": { "branch": "master", "commit": "4debb74b0a3e530f1b18e5b7dff98a40b2ad26f1" },
+  "vim-surround": { "branch": "master", "commit": "3d188ed2113431cf8dac77be61b842acb64433d9" },
   "which-key.nvim": { "branch": "main", "commit": "3aab2147e74890957785941f0c1ad87d0a44c15a" }
 }

lua/bootstrap.lua

@@ -19,7 +19,7 @@ return {
     branch = "main",
     build = ":TSUpdate",
     config = function()
-      local langs = { "clojure", "fennel", "lua", "vim", "vimdoc", "query" }
+      local langs = { "clojure", "fennel", "lua", "vim", "vimdoc", "query", "c_sharp", "html" }
 
       -- Install parsers asynchronously on first load
       vim.schedule(function()
@@ -32,16 +32,22 @@ return {
       -- Enable treesitter highlighting for supported filetypes
       -- This is required for nvim-paredit to work (needs vim.treesitter.get_node())
       vim.api.nvim_create_autocmd("FileType", {
-        pattern = { "clojure", "fennel", "lua", "vim", "query", "scheme", "lisp" },
+        pattern = { "clojure", "fennel", "lua", "vim", "query", "scheme", "lisp", "cs", "razor", "html" },
         callback = function()
           pcall(vim.treesitter.start)
         end,
       })
+
+      -- Filetype detection for Blazor/Razor files
+      vim.filetype.add({ extension = { razor = "razor" } })
+
+      -- Use html parser for razor files (no razor parser exists; LSP covers C# parts)
+      vim.treesitter.language.register("html", "razor")
     end,
   },
   {
     "nvim-telescope/telescope.nvim",
-    tag = "0.1.8",
+    branch = "master",
     dependencies = { "nvim-lua/plenary.nvim" },
     keys = {
       { "<leader>ff", "<cmd>Telescope find_files<cr>", desc = "Find files" },

script/build

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+nvim --headless -c "NfnlCompileAllFiles" -c "qa"