ajet/dotfiles
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Convert nvim config to submodule

Browse Source 
- Remove individual tracked files from .config/nvim
- Add as submodule pointing to git@git.ajet.fyi:ajet/nvim-config.git
This commit is contained in:
Adam Jeniski
2026-01-29 15:08:07 -05:00
parent 90c655e8e4
commit 7d8f27e056
10 changed files with 5 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.config/nvim
Submodule
+1
Submodule .config/nvim added at 9f25569788
.config/nvim/.gitignore
-5
View File
@@ -1,5 +0,0 @@
undodir
# Generated Lua files (compiled from Fennel by nfnl)
lua/config/
lua/plugins/
.config/nvim/.nfnl.fnl
-1
View File
@@ -1 +0,0 @@
{}
.config/nvim/CLAUDE.md
-78
View File
@@ -1,78 +0,0 @@
# Claude Code Context
This is a Neovim configuration using Fennel (a Lisp that compiles to Lua) via nfnl.
## Key Concepts
- **nfnl** compiles `.fnl` files to `.lua` on save
- **lazy.nvim** is the plugin manager
- Bootstrap files are in Lua; user config is in Fennel
## File Structure
```
init.lua - Entry point (Lua, do not convert to Fennel)
lua/bootstrap.lua - Core plugins in Lua (nfnl, treesitter, telescope)
lua/config/ - AUTO-GENERATED from fnl/config/ - do not edit
lua/plugins/ - AUTO-GENERATED from fnl/plugins/ - do not edit
fnl/config/ - User config in Fennel (options, keymaps, autocmds)
fnl/plugins/ - Plugin specs in Fennel
.nfnl.fnl - nfnl configuration
```
## Editing Rules
1. **Never edit files in `lua/config/` or `lua/plugins/`** - they are auto-generated
2. **Edit Fennel files in `fnl/`** - they compile to `lua/` on save
3. **`init.lua` and `lua/bootstrap.lua` stay as Lua** - they bootstrap nfnl
**IMPORTANT FOR CLAUDE:** After editing any `.fnl` file, compile all Fennel files to Lua:
```bash
cd ~/.config/nvim && nvim --headless -c "NfnlCompileAllFiles" -c "qa"
```
## Fennel Syntax Quick Reference
```fennel
;; Set vim option
(set vim.opt.number true)
;; Define keymap
(vim.keymap.set :n "<leader>x" ":cmd<CR>" {:desc "Description"})
;; Local variable
(local foo (require :foo))
;; Let binding
(let [x 1 y 2] (+ x y))
;; Function
(fn my-func [arg] (print arg))
;; Lambda
(fn [x] (* x 2))
;; Plugin spec (lazy.nvim format)
{:1 "author/plugin"
:ft ["fennel" "lua"]
:config (fn [] (setup-code))}
```
## Common Tasks
### Add a plugin
Edit `fnl/plugins/init.fnl`, add spec to the vector, save.
### Add a keymap
Edit `fnl/config/init.fnl`, add `(vim.keymap.set ...)`, save.
### Add an option
Edit `fnl/config/init.fnl`, add `(set vim.opt.foo value)`, save.
### Force recompile all Fennel
Run `:NfnlCompileAllFiles` in Neovim.
## Leader Keys
- Leader: `<Space>`
- Local leader: `<Space>` (same as leader, used by Conjure and paredit)
.config/nvim/README.md
-441
View File
@@ -1,441 +0,0 @@
# Neovim Fennel/Clojure Configuration
A Neovim configuration optimized for Lisp development (Fennel, Clojure, Scheme, Racket) using [Fennel](https://fennel-lang.org/) as the configuration language.
## Prerequisites
- **Neovim 0.11+** (uses built-in LSP configuration)
- **Git** (for plugin installation)
### Optional but Recommended
Install language servers for full IDE features:
```bash
# Clojure LSP (for Clojure/ClojureScript)
brew install clojure-lsp/brew/clojure-lsp
# Fennel Language Server (for Fennel)
cargo install fennel-language-server
# Lua Language Server (for Lua/Neovim plugin development)
brew install lua-language-server
```
Or use Mason inside Neovim: `:MasonInstall clojure-lsp lua-language-server`
## Quick Start
1. Clone this repo to `~/.config/nvim`
2. Open Neovim - plugins install automatically on first launch
3. Open a `.fnl` or `.clj` file and start editing
## Understanding Lisp Editing
If you're new to Lisp, here are the key concepts that make editing different from other languages.
### S-Expressions (Sexps)
All Lisp code is made of nested parenthesized expressions called **s-expressions** or **sexps**:
```clojure
(defn greet [name] ; <- this whole thing is a "form" or "sexp"
(str "Hello, " name)) ; <- this is a nested form
```
- **Form**: A complete s-expression (anything in balanced parens/brackets/braces)
- **Element**: A single item - either an atom (`name`, `42`, `:keyword`) or a form
### Structural Editing
Instead of editing text character-by-character, Lisp programmers edit **structures**. The paredit plugin keeps your parentheses balanced automatically and lets you manipulate code by its structure.
**Example - Slurping:**
```clojure
;; Before: cursor inside the (+ 1 2) form
(foo (+ 1 2) 3 4)
;; After pressing >) (slurp forward) - pulls 3 into the form
(foo (+ 1 2 3) 4)
```
**Example - Barfing:**
```clojure
;; Before: cursor inside the (+ 1 2 3) form
(foo (+ 1 2 3) 4)
;; After pressing <) (barf forward) - pushes 3 out of the form
(foo (+ 1 2) 3 4)
```
### Interactive Development (REPL)
Lisp development is **interactive**. You connect to a running program (REPL) and evaluate code as you write it. Conjure handles this - you can evaluate any expression and see results immediately.
---
## Keybindings Reference
**Leader key: `Space`**
Press `Space` and wait to see available options via which-key.
### General Navigation
| Key | Action |
|-----|--------|
| `Ctrl-h/j/k/l` | Move between windows |
| `Space f f` | Find files (Telescope) |
| `Space f g` | Live grep in project |
| `Space f b` | List open buffers |
| `Space f h` | Search help tags |
| `Space b n` | Next buffer |
| `Space b p` | Previous buffer |
| `Space b d` | Delete buffer |
### General Editing
| Key | Action |
|-----|--------|
| `jk` | Escape insert mode |
| `Space w` | Save file |
| `Space f s` | Save all files |
| `Space q` | Quit |
| `Esc` | Clear search highlight |
### LSP (Language Server)
Available when editing files with LSP support (Clojure, Fennel, Lua):
| Key | Action |
|-----|--------|
| `gd` | Go to definition |
| `gD` | Go to declaration |
| `gr` | Find references |
| `gi` | Go to implementation |
| `K` | Show hover documentation |
| `Space r n` | Rename symbol |
| `Space c a` | Code actions |
| `Space e` | Show diagnostic popup |
| `Space F` | Format buffer |
| `[d` | Previous diagnostic |
| `]d` | Next diagnostic |
**Commands:** `:LspInfo`, `:LspStart`, `:LspStop`, `:LspRestart`, `:LspLog`
---
## Conjure - REPL Integration
Conjure connects your editor to a running REPL, allowing you to evaluate code interactively.
### Starting a REPL
**Clojure:**
```bash
# In your project directory
clj -M:repl # or however your project starts a REPL
```
**Fennel:**
```bash
fennel --repl
```
Conjure auto-connects when you open a Lisp file and a REPL is running.
### Evaluation Keybindings
All Conjure bindings start with `Space` (local leader):
| Key | Action |
|-----|--------|
| `Space e e` | Evaluate form under cursor |
| `Space e r` | Evaluate root (top-level) form |
| `Space e b` | Evaluate entire buffer |
| `Space e f` | Evaluate file |
| `Space e !` | Evaluate form and replace with result |
| `Space e w` | Evaluate word under cursor |
### Log Buffer
Results appear in a floating HUD window. To interact with the full log:
| Key | Action |
|-----|--------|
| `Space l v` | Open log in vertical split |
| `Space l s` | Open log in horizontal split |
| `Space l t` | Open log in new tab |
| `Space l q` | Close log windows |
| `Space l r` | Reset/clear the log |
### Documentation
| Key | Action |
|-----|--------|
| `K` | Show documentation for symbol under cursor |
### Tip: Learn Interactively
Run `:ConjureSchool` for an interactive tutorial inside Neovim.
---
## nvim-paredit - Structural Editing
Paredit keeps parentheses balanced and provides structural editing commands.
### Navigation
Move by **elements** (atoms or forms) rather than words:
| Key | Action |
|-----|--------|
| `W` | Next element head |
| `B` | Previous element head |
| `E` | Next element tail |
| `gE` | Previous element tail |
| `(` | Jump to parent form's opening paren |
| `)` | Jump to parent form's closing paren |
| `T` | Jump to top-level form's head |
### Slurp and Barf
**Slurp**: Pull the next/previous element INTO the current form
**Barf**: Push the last/first element OUT OF the current form
| Key | Action |
|-----|--------|
| `>)` | Slurp forward (pull next element in) |
| `<(` | Slurp backward (pull previous element in) |
| `<)` | Barf forward (push last element out) |
| `>(` | Barf backward (push first element out) |
**Visual example - forward operations:**
```clojure
;; Cursor inside: (+ 1 2)
(foo (+ 1 2) 3 4)
;; >) slurp forward - pull 3 into the form
(foo (+ 1 2 3) 4)
;; >) again - pull 4 in
(foo (+ 1 2 3 4))
;; <) barf forward - push 4 back out
(foo (+ 1 2 3) 4)
```
**Visual example - backward operations:**
```clojure
;; Cursor inside: (+ 1 2)
(a b (+ 1 2))
;; <( slurp backward - pull b into the form
(a (b + 1 2))
;; >( barf backward - push b back out
(a b (+ 1 2))
```
### Dragging Elements
Move elements/forms left and right within their parent:
| Key | Action |
|-----|--------|
| `>e` | Drag element right |
| `<e` | Drag element left |
| `>f` | Drag form right |
| `<f` | Drag form left |
**Example:**
```clojure
;; Cursor on 'a'
(foo a b c)
;; >e drag element right - swap a and b
(foo b a c)
```
### Wrapping
Wrap an element in delimiters:
| Key | Action |
|-----|--------|
| `cse(` or `cse)` | Wrap element in `()` |
| `cse[` or `cse]` | Wrap element in `[]` |
| `cse{` or `cse}` | Wrap element in `{}` |
### Splice (Unwrap)
| Key | Action |
|-----|--------|
| `dsf` | Splice - delete surrounding form, keeping contents |
**Example:**
```clojure
;; Before (cursor inside the when form)
(when true (println "hello"))
;; dsf - splice, removing the surrounding parens
when true (println "hello")
```
### Raise
Replace the parent form with the current form/element:
| Key | Action |
|-----|--------|
| `Space o` | Raise form (replace parent with current form) |
| `Space O` | Raise element (replace parent with current element) |
**Example:**
```clojure
;; Before: cursor on (inner value)
(outer (inner value))
;; Space o - raise form, replacing parent with current form
(inner value)
```
### Text Objects
Use with operators like `d`, `c`, `y`, `v`:
| Text Object | Meaning |
|-------------|---------|
| `af` | Around form (including parens) |
| `if` | Inside form (excluding parens) |
| `aF` | Around top-level form |
| `iF` | Inside top-level form |
| `ae` | Around element |
| `ie` | Inside element |
**Examples:**
- `daf` - Delete around form (delete entire form including parens)
- `cif` - Change inside form (replace form contents)
- `yae` - Yank around element
---
## Workflow Examples
### Editing a Clojure Function
1. Start your REPL: `clj` in terminal
2. Open your `.clj` file
3. Write a function:
```clojure
(defn add [a b]
(+ a b))
```
4. `Space e r` to evaluate the top-level form
5. Test it: type `(add 1 2)` and `Space e e` to evaluate
6. See `3` appear in the HUD
### Refactoring with Paredit
Transform `(if test a b)` to `(when test a)`:
1. Position cursor on `if`
2. `ciw` to change word, type `when`
3. Move to `b`, `dae` to delete the element
4. Done: `(when test a)`
### Wrapping Code in a Let
```clojure
;; Start with:
(+ x y)
;; Position on the form, then: cse(
((+ x y))
;; Now you have wrapped parens. Type your let:
(let [z 1] (+ x y))
```
---
## File Structure
```
~/.config/nvim/
├── init.lua # Entry point (Lua)
├── lua/
│ ├── bootstrap.lua # Core plugins (nfnl, treesitter, telescope)
│ ├── config/ # AUTO-GENERATED from fnl/config/
│ └── plugins/ # AUTO-GENERATED from fnl/plugins/
└── fnl/
├── config/init.fnl # Your settings, keymaps, LSP config
└── plugins/init.fnl # Plugin specifications
```
**Important:** Edit files in `fnl/`, not `lua/config/` or `lua/plugins/` - those are auto-generated.
---
## Customization
### Add a Plugin
Edit `fnl/plugins/init.fnl`, add a spec to the vector:
```fennel
{:1 "author/plugin-name"
:config (fn [] (setup-code-here))}
```
### Add a Keymap
Edit `fnl/config/init.fnl`:
```fennel
(vim.keymap.set :n "<leader>x" ":SomeCommand<CR>" {:desc "Do something"})
```
### Change the Colorscheme
Edit the tokyonight config in `fnl/plugins/init.fnl`, or add a different colorscheme plugin.
---
## Troubleshooting
### LSP not working?
1. Check if the server is installed: `:LspInfo`
2. Check the log: `:LspLog`
3. Ensure you're in a project with root markers (`.git`, `deps.edn`, etc.)
### Conjure not connecting?
1. Make sure your REPL is running before opening the file
2. For Clojure: ensure nREPL is exposed (default port 7888 or `.nrepl-port` file)
3. Check `:ConjureLog` for connection errors
### Paredit feels wrong?
Structural editing takes practice. Start with just `>)` and `<)` for slurp/barf, then gradually add more commands. The `:help nvim-paredit` documentation is excellent.
---
## Learning Resources
- **Conjure Interactive Tutorial**: `:ConjureSchool`
- **Fennel Language**: https://fennel-lang.org/tutorial
- **Clojure for the Brave and True**: https://www.braveclojure.com/
- **Paredit Guide** (Emacs, but concepts apply): https://www.emacswiki.org/emacs/ParEdit
---
## Credits
- [nfnl](https://github.com/Olical/nfnl) - Fennel to Lua compiler for Neovim
- [Conjure](https://github.com/Olical/conjure) - Interactive REPL environment
- [nvim-paredit](https://github.com/julienvincent/nvim-paredit) - Structural editing
- [lazy.nvim](https://github.com/folke/lazy.nvim) - Plugin manager
- [tokyonight.nvim](https://github.com/folke/tokyonight.nvim) - Colorscheme
.config/nvim/fnl/config/init.fnl
-139
View File
@@ -1,139 +0,0 @@
;; Main Fennel configuration
;; This file is compiled to lua/config/init.lua by nfnl
;; Options
(set vim.opt.number true)
(set vim.opt.relativenumber true)
(set vim.opt.tabstop 2)
(set vim.opt.shiftwidth 2)
(set vim.opt.expandtab true)
(set vim.opt.smartindent true)
(set vim.opt.wrap false)
(set vim.opt.ignorecase true)
(set vim.opt.smartcase true)
(set vim.opt.termguicolors true)
(set vim.opt.signcolumn "yes")
(set vim.opt.updatetime 250)
(set vim.opt.undofile true)
(set vim.opt.clipboard "unnamedplus")
;; Keymaps
(local keymap vim.keymap.set)
;; Window navigation
(keymap :n "<C-h>" "<C-w>h" {:desc "Move to left window"
:silent true})
(keymap :n "<C-j>" "<C-w>j" {:desc "Move to lower window"
:silent true})
(keymap :n "<C-k>" "<C-w>k" {:desc "Move to upper window"
:silent true})
(keymap :n "<C-l>" "<C-w>l" {:desc "Move to right window"
:silent true})
;; Buffer navigation
(keymap :n "<leader>bn" ":bnext<CR>" {:desc "Next buffer"})
(keymap :n "<leader>bp" ":bprevious<CR>" {:desc "Previous buffer"})
(keymap :n "<leader>bd" ":bdelete<CR>" {:desc "Delete buffer"})
;; Clear search highlight
(keymap :n "<Esc>" ":noh<CR>" {:desc "Clear search highlight"})
;; Better escape
(keymap :i "jk" "<Esc>" {:desc "Escape insert mode"})
;; Save file
(keymap :n "<leader>w" ":w<CR>" {:desc "Save file"})
(keymap :n "<leader>fs" ":wa<CR>" {:desc "Save all files" :silent true})
;; Quit
(keymap :n "<leader>q" ":q<CR>" {:desc "Quit"})
;; Autocommands
(local augroup vim.api.nvim_create_augroup)
(local autocmd vim.api.nvim_create_autocmd)
;; Highlight on yank
(let [yank-group (augroup "YankHighlight" {:clear true})]
(autocmd "TextYankPost" {:group yank-group
:callback (fn [] (vim.highlight.on_yank))}))
;; Remove trailing whitespace on save
(let [whitespace-group (augroup "TrimWhitespace" {:clear true})]
(autocmd "BufWritePre" {:group whitespace-group
:pattern "*"
:command "%s/\\s\\+$//e"}))
;; LSP Configuration (Neovim 0.11+ built-in)
;; Configure servers using vim.lsp.config
(vim.lsp.config :clojure_lsp
{:cmd [:clojure-lsp]
:filetypes [:clojure :edn]
:root_markers [:deps.edn :project.clj :build.boot :shadow-cljs.edn :.git]})
(vim.lsp.config :lua_ls
{:cmd [:lua-language-server]
:filetypes [:lua]
:root_markers [:.luarc.json :.luarc.jsonc :.git]
:settings {:Lua {:runtime {:version :LuaJIT}
:workspace {:library (vim.api.nvim_get_runtime_file "" true)}}}})
(vim.lsp.config :fennel_language_server
{:cmd [:fennel-language-server]
: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
(vim.lsp.enable [:clojure_lsp :lua_ls :fennel_language_server])
;; LSP keymaps (set on attach)
(autocmd "LspAttach"
{:callback (fn [ev]
(local opts {:buffer ev.buf})
(keymap :n "gd" vim.lsp.buf.definition opts)
(keymap :n "gD" vim.lsp.buf.declaration opts)
(keymap :n "gr" vim.lsp.buf.references opts)
(keymap :n "gi" vim.lsp.buf.implementation opts)
(keymap :n "K" vim.lsp.buf.hover 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})) opts)
(keymap :n "<leader>e" vim.diagnostic.open_float opts)
(keymap :n "<leader>F" vim.lsp.buf.format opts))})
;; LSP commands (lspconfig-style)
(local usercmd vim.api.nvim_create_user_command)
(usercmd "LspInfo"
(fn [] (vim.cmd "checkhealth vim.lsp"))
{:desc "Show LSP info"})
(usercmd "LspStart"
(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])))
{:nargs "?"
:complete (fn [] [:clojure_lsp :lua_ls :fennel_language_server])
:desc "Start LSP server"})
(usercmd "LspStop"
(fn []
(each [_ client (ipairs (vim.lsp.get_clients))]
(vim.lsp.stop_client client.id)))
{:desc "Stop all LSP clients"})
(usercmd "LspRestart"
(fn []
(each [_ client (ipairs (vim.lsp.get_clients))]
(vim.lsp.stop_client client.id))
(vim.defer_fn (fn [] (vim.cmd "edit")) 100))
{:desc "Restart LSP clients"})
(usercmd "LspLog"
(fn [] (vim.cmd (.. "edit " (vim.lsp.get_log_path))))
{:desc "Open LSP log file"})
{}
.config/nvim/fnl/plugins/init.fnl
-74
View File
@@ -1,74 +0,0 @@
;; Plugin specs in Fennel
;; This file is compiled to lua/plugins/init.lua by nfnl
(local repo 1) ;; lazy.nvim spec index for the git repo (e.g., "folke/plugin")
(local lhs 1) ;; which-key spec index for the key sequence (see which-key below)
[;; Tokyonight - Colorscheme
{repo "folke/tokyonight.nvim"
:lazy false
:priority 1000
:config (fn []
(let [tokyonight (require :tokyonight)]
(tokyonight.setup
{:style "night" ; storm, moon, night, or day
:transparent false
:terminal_colors true}))
(vim.cmd.colorscheme "tokyonight"))}
;; Conjure - Interactive REPL for Fennel, Clojure, Lisp, etc.
{repo "Olical/conjure"
:ft ["fennel" "clojure" "lisp" "scheme" "racket" "lua"]
:config (fn []
;; Enable HUD floating window
(set vim.g.conjure#log#hud#enabled true))}
;; nvim-paredit - Structural editing for Lisp
;; Default keybindings: >)/<) slurp/barf forward, <(/>( slurp/barf backward
;; >e/<e drag element, >f/<f drag form, E/W/B element motions
{repo "julienvincent/nvim-paredit"
:ft ["fennel" "clojure" "lisp" "scheme" "racket"]
:config (fn []
(local paredit (require :nvim-paredit))
;; Use default keybindings (>), <), <(, >(, etc.)
(paredit.setup {})
;; Additional vim-sexp compatible bindings
(local keymap vim.keymap.set)
(local api paredit.api)
;; dsf - Splice (delete surrounding form)
(keymap :n "dsf" api.unwrap_form_under_cursor {:desc "Splice (delete surrounding form)"})
;; cse( cse) - Wrap in parens
(keymap :n "cse(" #(api.wrap_element_under_cursor "(" ")") {:desc "Wrap element in ()"})
(keymap :n "cse)" #(api.wrap_element_under_cursor "(" ")") {:desc "Wrap element in ()"})
;; cse[ cse] - Wrap in brackets
(keymap :n "cse[" #(api.wrap_element_under_cursor "[" "]") {:desc "Wrap element in []"})
(keymap :n "cse]" #(api.wrap_element_under_cursor "[" "]") {:desc "Wrap element in []"})
;; cse{ cse} - Wrap in braces
(keymap :n "cse{" #(api.wrap_element_under_cursor "{" "}") {:desc "Wrap element in {}"})
(keymap :n "cse}" #(api.wrap_element_under_cursor "{" "}") {:desc "Wrap element in {}"}))}
;; Mason - Package manager for LSP servers, DAP servers, linters, formatters
;; Run :MasonInstall clojure_lsp lua_ls to install servers
{repo "williamboman/mason.nvim"
:cmd ["Mason" "MasonInstall" "MasonUpdate"]
:build ":MasonUpdate"
:opts {:ui {:border "rounded"}}}
;; which-key - Shows keybinding hints
;; lhs constant defined at top - which-key specs use index [1] for the key sequence
{repo "folke/which-key.nvim"
:event "VeryLazy"
:opts {}
:config (fn [_ opts]
(local wk (require :which-key))
(wk.setup opts)
(wk.add
[{lhs "<leader>f" :group "find"}
{lhs "<leader>b" :group "buffer"}
{lhs "<leader>r" :group "refactor"}
{lhs "<leader>c" :group "code"}]))}]
.config/nvim/init.lua
-26
View File
@@ -1,26 +0,0 @@
-- Set leader keys before lazy loads
vim.g.mapleader = " "
vim.g.maplocalleader = " "
-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
vim.fn.system({
"git",
"clone",
"--filter=blob:none",
"https://github.com/folke/lazy.nvim.git",
"--branch=stable",
lazypath,
})
end
vim.opt.rtp:prepend(lazypath)
-- Setup lazy.nvim
require("lazy").setup({
{ import = "bootstrap" },
{ import = "plugins" },
})
-- Load Fennel config (compiled from fnl/config/init.fnl)
pcall(require, "config.init")
.config/nvim/lua/bootstrap.lua
-54
View File
@@ -1,54 +0,0 @@
-- Core plugins that must be in Lua (nfnl compiles Fennel, so it can't be in Fennel)
return {
{
"Olical/nfnl",
lazy = false,
config = function()
-- Create global commands that work without opening a fennel file first
local api = require("nfnl.api")
vim.api.nvim_create_user_command("NfnlCompileAllFiles", function(opts)
api["compile-all-files"](opts.args ~= "" and opts.args or nil)
end, { desc = "Compile all Fennel files", nargs = "?", complete = "dir" })
vim.api.nvim_create_user_command("NfnlCompileFile", function(opts)
api["compile-file"]({ path = opts.args ~= "" and opts.args or nil })
end, { desc = "Compile current or specified Fennel file", nargs = "?", complete = "file" })
end,
},
{
"nvim-treesitter/nvim-treesitter",
build = ":TSUpdate",
config = function()
local langs = { "clojure", "fennel", "lua", "vim", "vimdoc", "query" }
-- Install parsers asynchronously on first load
vim.schedule(function()
local installed = require("nvim-treesitter").get_installed()
for _, lang in ipairs(langs) do
if not vim.list_contains(installed, lang) then
require("nvim-treesitter").install(lang)
end
end
end)
-- 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" },
callback = function()
pcall(vim.treesitter.start)
end,
})
end,
},
{
"nvim-telescope/telescope.nvim",
tag = "0.1.8",
dependencies = { "nvim-lua/plenary.nvim" },
keys = {
{ "<leader>ff", "<cmd>Telescope find_files<cr>", desc = "Find files" },
{ "<leader>fg", "<cmd>Telescope live_grep<cr>", desc = "Live grep" },
{ "<leader>fb", "<cmd>Telescope buffers<cr>", desc = "Buffers" },
{ "<leader>fh", "<cmd>Telescope help_tags<cr>", desc = "Help tags" },
},
},
}
.gitmodules
+4
View File
@@ -0,0 +1,4 @@
[submodule ".config/nvim"]
path = .config/nvim
url = git@git.ajet.fyi:ajet/nvim-config.git
branch = main