look into language eval with Conjure in Markdown Language blocks

2026-01-28 12:49:56 -06:00 · 2022-07-07 14:41:27 -05:00
78 changed files with 591 additions and 1896 deletions
--- a/.bash_profile
+++ b/.bash_profile
@@ -1,4 +1,3 @@
-shopt -s globstar

 [[ -f ~/.bashrc ]] && . ~/.bashrc

@@ -6,8 +5,6 @@ PATH=/usr/local/sbin:/usr/local/bin:~/bin:/usr/local/share/npm/bin:$PATH
 PATH=$PATH:$HOME
 MANPATH=$MANPATH:/usr/local/opt/erlang/lib/erlang/man

-export XDG_CONFIG_HOME=$HOME/.config
-
 set -o vi
 export EDITOR='nvim'

@@ -113,6 +110,4 @@ export LESS_TERMCAP_us=$'\e'"[1;32m"
 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" # Load RVM into a shell session *as a function*
 [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion

-[ -s "$HOME/.config/broot/launcher/bash/br" ] && source "$HOME/.config/broot/launcher/bash/br"
-
-# source /Users/proctor/.config/broot/launcher/bash/br
+[ -s ".config/broot/launcher/bash/br" ] && source /Users/sproctor/.config/broot/launcher/bash/br
--- a/.bashrc
+++ b/.bashrc
@@ -39,5 +39,3 @@ export XML_CATALOG_FILES=/usr/local/etc/xml/catalog

 # Add RVM to PATH for scripting. Make sure this is the last PATH variable change.
 export PATH="$PATH:$HOME/.rvm/bin"
-
-# source ~/.config/broot/launcher/bash/br
--- a/.gitignore
+++ b/.gitignore
--- a/bash/aliases
+++ b/bash/aliases
@@ -4,14 +4,11 @@ alias ll='ls -l'
 alias la='ls -a'
 alias lhal='ls -hal'

-#curl
-alias curltime="curl -w \"@$HOME/utils/curl-time-format.txt\" -o /dev/null -s "
-
 #git aliases
 alias ?='git status'
 alias ga='git add'
 alias gaa='git add .'
-alias gbc="git branch -vv | grep -e '[origin/[^:]*: gone]' | awk '{print \$1}' | xargs --no-run-if-empty git branch -D"
+alias gbc="git branch -vv | grep -e '[origin/[^:]*: gone]' | awk '{print \$1}' | xargs git branch -D"
 alias gbd='git branch -d'
 alias gc='git commit'
 alias gcb='git branch --show-current'
@@ -22,7 +19,6 @@ alias gmerge='git merge --ff-only'
 alias gpull='git pull --rebase'
 alias gpush='git push'
 alias gpush!='git push -u origin `git rev-parse --abbrev-ref HEAD`'
-alias gr='cd $(git rev-parse --show-toplevel)'
 alias master!='git checkout master'
 alias main!='git checkout main'
 alias merged?='git branch --merged'
--- a/git/.gitconfig
+++ b/git/.gitconfig
@@ -1,32 +0,0 @@
-# This is Git's per-user configuration file.
-[user]
-	email = steven.proctor@gmail.com
-	name = Proctor
-
-[core]
-	editor = nvim
-	excludesFile = ~/.gitignore.global
-[init]
-	defaultBranch = main
-
-[alias] ; Command aliases for the git[1] command wrapper
-	last = cat-file commit HEAD
-[branch]
-  autoSetupRebase = always
-[checkout]
-  defaultRemote = origin
-[merge]
-  ff = only
-[push]
-  autoSetupRemote = true
-  default = upstream
-[rerere]
-	enabled = true
-[remote]
-	pushDefault = origin
-
-;; This is last, take in any other local file overrides
-[include]
-	path = ~/.gitconfig.local ; find ".gitconfig.local" in your `$HOME` directory
-[pull]
-	ff = only
--- a/nvim/.config/nvim/.nfnl.fnl
+++ b/nvim/.config/nvim/.nfnl.fnl
@@ -1 +0,0 @@
-{}
--- a/nvim/.config/nvim/fnl/config/macros.fnl
+++ b/nvim/.config/nvim/fnl/config/macros.fnl
@@ -1,14 +0,0 @@
-;; [nfnl-macro]
-
-(fn tx [& args]
-  "Mixed sequential and associative tables at compile time. Because the Neovim ecosystem loves them but Fennel has no neat way to express them (which I think is fine, I don't like the idea of them in general)."
-  (let [to-merge (when (table? (. args (length args)))
-                   (table.remove args))]
-    (if to-merge
-        (do
-          (each [key value (pairs to-merge)]
-            (tset args key value))
-          args)
-        args)))
-
-{: tx}
--- a/nvim/.config/nvim/fnl/dotfiles/conceal.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/conceal.fnl
@@ -1,58 +1,61 @@
-(local u (require :dotfiles.util))
+(module dotfiles.conceal
+  {autoload {nvim aniseed.nvim
+             nu aniseed.nvim.util
+             u dotfiles.util}})

-(local conceals {:defn "𝑓"
-                 ;; :defn- :
-                 :fn "λ"
-                 :lambda "λ"
-                 :and "∧"
-                 :&& "∧"
-                 :or "∨"
-                 :|| "∨"
-                 :not "¬"
-                 :! "¬"
-                 :for "∀"
-                 :in "∈"
-                 ; "\\<not\\> \\<in\\>" :∉
-                 :true "⊤"
-                 :false "⊥"
-                 ;; and
-                 ;; or
-                 ;; if-not
-                 ;; when-not
-                 ;; (not
-                 ;; None        | ∅
-                 ;; true, false | ⊤, ⊥ (top and bottom from logic)
-                 ;; 
-                 ;; for         | ∀
-                 ;; in          | ∈
-                 ;; not in      | ∉
-                 })

-(fn setup-conceals []
-  (vim.fn.clearmatches)
+(def conceals {:defn :𝑓
+               ;; :defn- :
+               :fn :λ
+               :lambda :λ
+               :and :∧
+               :&& :∧
+               :or :∨
+               :|| :∨
+               :not :¬
+               :! :¬
+               :for :∀
+               :in :∈
+               ; "\\<not\\> \\<in\\>" :∉
+               :true :⊤
+               :false :⊥
+;; and
+;; or
+;; (not
+;; None        | ∅
+;; true, false | ⊤, ⊥ (top and bottom from logic)
+;; 
+;; for         | ∀
+;; in          | ∈
+;; not in      | ∉
+               })
+
+
+(defn setup-conceals []
+  (nvim.fn.clearmatches)
  (each [the-match replacement (pairs conceals)]
-    (let [the-match (.. "\\<" the-match "\\>")]
-      (vim.fn.matchadd :Conceal the-match 0 -1 {:conceal replacement})))
-  (set vim.wo.conceallevel 2)
-  (set vim.wo.concealcursor :nvc))
+    (let [the-match (.. "\\<" the-match "\\>" )]
+      (nvim.fn.matchadd :Conceal the-match 0 -1 {:conceal replacement})))

-(fn toggle-conceal []
-  (if (= 0 vim.wo.conceallevel)
-      (set vim.wo.conceallevel 2)
-      (set vim.wo.conceallevel 0)))
+  (set nvim.wo.conceallevel 2)
+  (set nvim.wo.concealcursor :nvc))
+
+
+(defn toggle-conceal []
+  ( if (= 0 nvim.wo.conceallevel)
+    (set nvim.wo.conceallevel 2)
+    (set nvim.wo.conceallevel 0)))

-;(setup-conceals)
-;(toggle-conceal)
 ;(if true true false)

-(vim.api.nvim_create_user_command :ToggleConceal toggle-conceal {})
-(vim.api.nvim_create_user_command :SetupConceals setup-conceals {})
-(u.nnoremap :<leader>ts "call ToggleConceal()")

-(local pretty-filetypes [:fennel :clojure])
+(nu.fn-bridge :ToggleConceal :dotfiles.conceal :toggle-conceal {:return false})
+(nu.fn-bridge :SetupConceals :dotfiles.conceal :setup-conceals {:return false})
+(u.nnoremap :<leader>ct "call ToggleConceal()")

-(each [_ ftype (pairs pretty-filetypes)]
-  (vim.api.nvim_create_autocmd [:FileType]
-                               {:pattern ftype :callback setup-conceals}))
+(def pretty-filetypes [:fennel
+                       :clojure])

-{: setup-conceals}
+; (each [_ ftype (pairs pretty-filetypes)]
+;   (nvim.ex.autocmd :FileType ftype :call "SetupConceals()"))
+; 
--- a/nvim/.config/nvim/fnl/dotfiles/core.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/core.fnl
@@ -1,119 +1,121 @@
-(local a (require :nfnl.core))
-(local u (require :dotfiles.util))
+(module dotfiles.core
+  {autoload
+   {a aniseed.core}
+   require
+   {anenv aniseed.env
+    nvim aniseed.nvim
+    nu aniseed.nvim.util
+    u dotfiles.util
+    }})

-(vim.cmd.set :shortmess+=c)

-; don't give |ins-completion-menu| messages.
-(vim.cmd.set :path+=**)
-(vim.cmd.set "wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/*")
+(nvim.ex.set "shortmess+=c") ; don't give |ins-completion-menu| messages.
+(nvim.ex.set "path+=**")
+(nvim.ex.set "wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/*")

-(fn safe-source [filename]
-  (let [glob (vim.fn.glob filename)]
+(defn- safe-source
+  [filename]
+  (let [glob (nvim.fn.glob filename)]
    (if (not (a.empty? glob))
-        (vim.fn.source filename))))
+      (nvim.ex.source filename))))

-; (a.map safe-source ["~/.vimrc" "~/.vimrc.local"])
+(a.map safe-source ["~/.vimrc" "~/.vimrc.local"])

-(local backup-dir (.. (vim.fn.glob :$HOME) :/.vim/backup))
-(local undo-dir (.. (vim.fn.glob :$HOME) :/.vim/backup))

-(local on-opts [:autoindent
-                :autoread
-                :expandtab
-                :exrc
-                ; allow project level (neo)vim files
-                :hlsearch
-                :ignorecase
-                :incsearch
-                :number
-                :ruler
-                :secure
-                :shiftround
-                ; When at 3 spaces and I hit >>, go to 4, not 5.
-                :showcmd
-                ; shows (parital) command in the status line
-                :showmatch
-                :smartcase
-                :splitbelow
-                :splitright
-                :termguicolors
-                :title
-                :undofile
-                :wildmenu])
+(def- backup-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))
+(def- undo-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))

-(local val-based-opts {; :t_Co 256
-                       :laststatus 2
-                       :encoding :utf-8
-                       :history 500
-                       :redrawtime 5000
-                       :scrolloff 3
-                       :guifont :Hasklig
-                       :guifontwide :Hasklig
-                       :background :dark
-                       :backupdir backup-dir
-                       :directory backup-dir
-                       ;Don't clutter my dirs up with swp and tmp files
-                       :grepprg "ag --vimgrep"
-                       ; Use Silver Searcher instead of grep
-                       :tags :tags
-                       :updatetime 300
-                       ; per coc.vim for diagnostic messages
-                       :signcolumn "auto:1-3"
-                       :colorcolumn [81 100]
-                       :cmdheight 2
-                       ; Better display for messages
-                       :undodir undo-dir
-                       :undolevels 1000
-                       :undoreload 10000
-                       :foldmethod :expr
-                       :foldexpr "nvim_treesitter#foldexpr()"
-                       :foldlevelstart 100
-                       :foldlevel 99
-                       :tabstop 2
-                       :shiftwidth 2
-                       :softtabstop 2
-                       :mouse ""
-                       :list true
-                       :listchars "tab:➥\\ ,trail:·,nbsp:■"
-                       :backspace "indent,eol,start"
-                       ;allow backspacing over everything in insert mode
-                       :wildmode "list:longest,list:full"
-                       :wrap false})
+(def- on-opts [
+           :autoindent
+           :autoread
+           :expandtab
+           :exrc ; allow project level (neo)vim files
+           :hlsearch
+           :ignorecase
+           :incsearch
+           :number
+           :ruler
+           :secure
+           :shiftround ; When at 3 spaces and I hit >>, go to 4, not 5.
+           :showcmd ; shows (parital) command in the status line
+           :showmatch
+           :smartcase
+           :splitbelow
+           :splitright
+           :termguicolors
+           :title
+           :undofile
+           :wildmenu
+           ])

-(local append-val-opts {:diffopt "algorithm:patience"})

-(fn set-opt [[opt val]] (tset vim.opt (a.str opt) val))
+(def- val-based-opts
+  {
+    ; :t_Co 256
+    :laststatus 2
+    :encoding "utf-8"
+    :history 500
+    :redrawtime 5000
+    :scrolloff 3
+    :guifont "Hasklig"
+    :background "dark"
+    :backupdir backup-dir
+    :directory backup-dir      ;Don't clutter my dirs up with swp and tmp files
+    :grepprg "ag" ; Use Silver Searcher instead of grep
+    :tags "tags"
+    :updatetime 300 ; per coc.vim for diagnostic messages
+    :signcolumn "auto:1-3"
+    :cmdheight 2 ; Better display for messages
+    :undodir undo-dir
+    :undolevels 1000
+    :undoreload 10000
+    :foldmethod "expr"
+    :foldexpr "nvim_treesitter#foldexpr()"
+    :foldlevelstart 100
+    :foldlevel 99
+    :tabstop 2
+    :shiftwidth 2
+    :softtabstop 2
+    :list true
+    :listchars "tab:➥\\ ,trail:·"
+    :backspace "indent,eol,start"    ;allow backspacing over everything in insert mode
+    :wildmode "list:longest,list:full"
+    :wrap false
+   })

-(fn set-opt+ [[opt val]]
-  (let [existing-opt-val (a.get vim.o opt)]
-    (tset vim.opt (a.str opt) (a.str existing-opt-val "," val))))
+(defn- set-opt
+  [[opt val]]
+  (tset vim.opt (a.str opt) val))

-(fn set-opt-on [opt] (set-opt [opt true]))
+(defn- set-opt-on
+  [opt]
+  (set-opt [opt true]))

 (a.map set-opt-on on-opts)

 (a.map-indexed set-opt val-based-opts)

-(a.map-indexed set-opt+ append-val-opts)
+(nvim.ex.syntax "on")
+(nvim.ex.colorscheme :soluarized)

-(vim.cmd.syntax :on)
-;; (nvim.ex.colorscheme :soluarized)
-(vim.cmd.colorscheme :solarized8)

-;; (nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "soluarized")
-
-(vim.api.nvim_create_autocmd [:vimenter]
-                             {:pattern "*"
-                              :command "colorscheme solarized8"
-                              :nested true})

+(nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "solarized8")
 ;(nvim.ex.autocmd "vimenter" "*"  "luafile" "treesitter.lua")
-;
+; 
 ; (nvim.fn.glob "~/.vimrc.local")

-(fn make-fennel-scratch []
-  (vim.cmd "new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel"))
-
-(vim.api.nvim_create_user_command :FennelScratchBuffer make-fennel-scratch {})
+(defn make-fennel-scratch
+  []
+  (nvim.command "new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel"))

+(nu.fn-bridge :FennelScratchBuffer :dotfiles.core :make-fennel-scratch {:return false})
 (u.nnoremap :<leader>fsb ":call FennelScratchBuffer ()<CR>")
+
+(defn compile-fnl []
+  (print :recompiling)
+  (anenv.init
+    {:force true
+     :init :dotfiles.init}))
+
+(nu.fn-bridge :AniseedCompile :dotfiles.core :compile-fnl {:return false})
--- a/nvim/.config/nvim/fnl/dotfiles/init.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/init.fnl
@@ -1,22 +1,15 @@
-(local a (require :nfnl.core))
-(local str (require :nfnl.string))
-(local fs (require :nfnl.fs))
+(module dotfiles.init
+  {autoload
+   {a aniseed.core}
+   require
+   {nvim aniseed.nvim}})

-(fn require-all []
-  (let [require-exclusions (a.->set [:init])]
-    (->> (fs.relglob :fnl/dotfiles :*.fnl)
-         (a.map #(a.first (str.split $ :.fnl)))
-         (a.filter #(not (a.contains? require-exclusions $)))
-         (a.map #(.. :dotfiles. $))
-         ;(a.map #(require $))
-         )))

-;; (require-all)
-(require :dotfiles.core)
 (require :dotfiles.plugins)
+(require :dotfiles.core)
 (require :dotfiles.mapping)
 (require :dotfiles.conceal)
 (require :dotfiles.zoom-toggle)

 ;(nvim.ex.source "~/.vimrc")
-(a.println "(re)loaded")
+
--- a/nvim/.config/nvim/fnl/dotfiles/mapping.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/mapping.fnl
@@ -1,43 +1,39 @@
-(local util (require :dotfiles.util))
-(local nfnl (require :nfnl.api))
+(module dotfiles.mapping
+  {autoload {nvim aniseed.nvim
+             nu aniseed.nvim.util
+             core aniseed.core}})

-
-(fn noremap [mode from to]
+(defn- noremap [mode from to]
  "Sets a mapping with {:noremap true}."
-  (vim.keymap.set mode from to {:noremap true}))
+  (nvim.set_keymap mode from to {:noremap true}))

 ; (set nvim.g.mapleader "\\")

-(vim.keymap.set :n "<leader>`"
-                (fn []
-                  (nfnl.compile-all-files (vim.fn.stdpath :config))
-                  (vim.cmd.source (.. (vim.fn.stdpath :config) :/init.lua))))
-
-; (noremap :n "<leader>`" ":source ~/.config/nvim/init.lua<CR>")
+(noremap :n "<leader>`" ":source ~/.config/nvim/init.lua<CR>")
+(noremap :n "<leader>!" ":call AniseedCompile()<CR>")

 (noremap :n :<Enter> ":nohlsearch<Enter>/<BS>")

 ;; Correct to first spelling suggestion.
 (noremap :n :<leader>zz ":normal! 1z=<cr>")

+
 ;; nice paste from clipboard in insert mode
 (noremap :i :<C-V><C-O> ":set paste<CR><C-R><C-R>+<C-O>:set nopaste<CR>")

+
 ; Insert Date
 (noremap :n :<F5> "\"=strftime(\"%F\")<CR>p")
 (noremap :i :<F5> "<C-R>=strftime(\"%F\")<CR>")
-(noremap :n :<M-5> "\"=trim(system('date -u'))<CR>p")
-(noremap :i :<M-5> "<C-R>=trim(system('date -u'))<CR>")

 ; Make markdown link with empty url
 ;map <Leader>ah S<a href="" target="_blank" rel="noopener noreferrer"><CR>
-(noremap :v :<leader>ah
-         "S<a href=\"\" target=\"_blank\" rel=\"nopener noreferrer\"><CR>")
-
+(noremap :v :<leader>ah "S<a href=\"\" target=\"_blank\" rel=\"nopener noreferrer\"><CR>")
 (noremap :v :<leader>ml "xi[<c-r>\"]()<esc>")

-(noremap :n :<C-e> :3<C-e>)
-(noremap :n :<C-y> :3<C-y>)
+
+(noremap :n :<C-e> "3<C-e>")
+(noremap :n :<C-y> "3<C-y>")

 ; Unimpaired configuration
 ; Bubble single lines
@@ -58,57 +54,8 @@
 (noremap :n :gsh ":GitGutterStageHunk<CR>")

 ; Open file in Marked 2 (markdown viewer)
-(noremap :n :<leader>mv ":AsyncRun -mode=bang open -a Marked\\ 2.app '%:p'<cr>")
+(noremap :n :<leader>mv ":AsyncRun -mode=bang open -a Marked\\ 2.app \'%:p\'<cr>")

 ; Run current statement in DadBod-UI
-;; (nvim.ex.autocmd :FileType :sql :nmap :<leader>s :vap<leader>S)
-(vim.api.nvim_create_autocmd [:FileType]
-                             {:pattern :sql
-                              :command "nmap <leader>s vap<leader>S"})
+(nvim.ex.autocmd :FileType :sql :nmap :<leader>s "vap<leader>S")

-(noremap :n :Q ":.!bash <CR>")
-
-; Ruby old hash syntax to new hash syntax
-;(util/lvnoremap :uhs "<C-U>s/\\([a-z][^ \\t]*\\) =>/\\1:/ge" )
-;(util/lnnoremap :uhs "<C-U>s/\\([a-z][^ \\t]*\\) =>/\\1:/ge" )
-
-; Trim trailing Whitespace in visual selection
-(util.lvnoremap :tw "<C-U>s/\\s\\+$//ge<CR>:nohlsearch<Enter>/<BS>")
-
-; Trim trailing Whitespace in current line
-(util.lnnoremap :tw "<C-U>.s/\\s\\+$//ge<CR>:nohlsearch<Enter>/<BS>")
-
-;; <Leader><C-l> in terminal to clear scrollback buffer
-;; nmap <silent> <leader><C-l> :set scrollback=1 \| set scrollback=100000<cr>
-(util.lnnoremap :<C-k> ":set scrollback=1 | :set scrollback 100000<cr>"
-                {:silent true})
-
-;; tmap <silent> <leader><C-l> <C-\><C-n><leader><C-l>i
-(util.ltnoremap :<C-k> "<C-\\><C-n><leader><C-l>i" {:silent true})
-
-;; (noremap :n :<C-A-l> ":echo \"test\"\n")
-; Window switching
-; ˙ -> alt-h
-; ∆ -> alt-j
-; ˚ -> alt-k
-; ¬ -> alt-l
-;; Terminal mode
-;; (noremap :t "˙" "<c-\\><c-n><c-w>h")
-;; (noremap :t "∆" "<c-\\><c-n><c-w>j")
-;; (noremap :t "˚" "<c-\\><c-n><c-w>k")
-;; (noremap :t "¬" "<c-\\><c-n><c-w>l")
-;; ;; Insert mode:
-;; (noremap :i "˙" :<Esc><c-w>h)
-;; (noremap :i "∆" :<Esc><c-w>j)
-;; (noremap :i "˚" :<Esc><c-w>k)
-;; (noremap :i "¬" :<Esc><c-w>l)
-;; ;; Visual mode:
-;; (noremap :v "˙" :<Esc><c-w>h)
-;; (noremap :v "∆" :<Esc><c-w>j)
-;; (noremap :v "˚" :<Esc><c-w>k)
-;; (noremap :v "¬" :<Esc><c-w>l)
-;; ;; Normal mode:
-;; (noremap :n "˙" :<c-w>h)
-;; (noremap :n "∆" :<c-w>j)
-;; (noremap :n "˚" :<c-w>k)
-;; (noremap :n "¬" :<c-w>l)
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/cmp.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/cmp.fnl
@@ -1,38 +1,42 @@
-(local cmp (require :cmp))
-(local luasnip (require :luasnip))
+(module dotfiles.plugin.cmp
+  {autoload {nvim aniseed.nvim}})

-(local cmp-src-menu-items {:buffer :buff :conjure :conj :nvim_lsp :lsp})

-(local cmp-srcs [{:name :nvim_lsp}
-                 {:name :nvim_lua}
-                 {:name :luasnip}
-                 {:name :vsnip}
-                 {:name :conjure}
-                 {:name :buffer}
-                 {:name :orgmode}
-                 {:name :emoji :max_item_count 8}])
+(module config.plugin.cmp
+  {autoload {nvim aniseed.nvim
+             cmp cmp}})
+
+(def- cmp-src-menu-items
+  {:buffer "buff"
+   :conjure "conj"
+   :nvim_lsp "lsp"})
+
+(def- cmp-srcs
+  [{:name :nvim_lsp}
+   {:name :vsnip}
+   {:name :conjure}
+   {:name :buffer}])

 ;; Setup cmp with desired settings
 (let [cmp (require :cmp)]
-  (cmp.setup {:formatting {:format (fn [entry item]
-                                     (set item.menu
-                                          (or (. cmp-src-menu-items
-                                                 entry.source.name)
-                                              ""))
-                                     item)}
+  (cmp.setup {:formatting
+              {:format (fn [entry item]
+                         (set item.menu (or (. cmp-src-menu-items entry.source.name) ""))
+                         item)}
              :mapping {:<C-p> (cmp.mapping.select_prev_item)
                        :<C-n> (cmp.mapping.select_next_item)
                        :<C-b> (cmp.mapping.scroll_docs (- 4))
                        :<C-f> (cmp.mapping.scroll_docs 4)
                        :<C-Space> (cmp.mapping.complete)
                        :<C-e> (cmp.mapping.close)
-                        :<C-y> (cmp.mapping.confirm {;; :behavior cmp.ConfirmBehavior.Insert
-                                                     :select true})}
+                        :<CR> (cmp.mapping.confirm {:behavior cmp.ConfirmBehavior.Insert
+                                                    :select true})}
+
              :snippet {:expand (fn [args]
-                                  (if args
-                                      (luasnip.lsp_expand args.body)))}
+                                  (nvim.fn.vsnip#anonymous args.body))}
              :sources cmp-srcs}))

+
 ;;; imap <expr> <C-j>   vsnip#available(1)  ? '<Plug>(vsnip-expand)'         : '<C-j>'
 ;;; imap <expr> <C-l>   vsnip#available(1)  ? '<Plug>(vsnip-expand-or-jump)' : '<C-l>'
 ;;; smap <expr> <C-l>   vsnip#available(1)  ? '<Plug>(vsnip-expand-or-jump)' : '<C-l>'
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/colorizer.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/colorizer.fnl
@@ -1,18 +1,13 @@
-(let [colorizer (require :colorizer)]
-  (colorizer.setup ["*"] {:RGB true
-                          ; #RGB hex codes, like #F00
-                          :RRGGBB true
-                          ; #RRGGBB hex codes, like #00FF00
-                          :names true
-                          ; "Name" codes like Blue
-                          :RRGGBBAA true
-                          ; #RRGGBBAA hex codes
-                          :rgb_fn true
-                          ; CSS rgb() and rgba() functions
-                          :hsl_fn true
-                          ; CSS hsl() and hsla() functions
-                          :css true
-                          ; Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
-                          :css_fn true
-                          ; Enable all CSS *functions*: rgb_fn, hsl_fn
-                          }))
+(module dotfiles.plugin.colorizer
+  {autoload {colorizer colorizer}})
+
+(colorizer.setup {"*" {}}
+                 {:RGB      true ; #RGB hex codes, like #F00
+                  :RRGGBB   true ; #RRGGBB hex codes, like #00FF00
+                  :names    true ; "Name" codes like Blue
+                  :RRGGBBAA true ; #RRGGBBAA hex codes
+                  :rgb_fn   true ; CSS rgb() and rgba() functions
+                  :hsl_fn   true ; CSS hsl() and hsla() functions
+                  :css      true ; Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
+                  :css_fn   true ; Enable all CSS *functions*: rgb_fn, hsl_fn
+                  })
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/compe.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/compe.fnl
@@ -0,0 +1,35 @@
+(module dotfiles.plugin.compe
+  {autoload {nvim aniseed.nvim}})
+
+(set nvim.o.completeopt "menuone,noselect")
+
+(let [compe (require :compe)]
+  (when compe
+    (compe.setup
+      {:enabled true
+       :autocomplete true
+       :debug false
+       :min_length 1
+       :preselect "enable"
+       :throttle_time 80
+       :source_timeout 200
+       :incomplete_delay 400
+       :max_abbr_width 100
+       :max_kind_width 100
+       :max_menu_width 100
+       :documentation true
+       :source {:path true
+                :buffer true
+                :calc true
+                :emoji true
+                :nvim_lsp true
+                :nvim_lua true
+                :conjure true
+                :vsnip true
+                :vim_dadbod_completion true}})))
+
+(nvim.ex.inoremap "<silent><expr> <C-Space> compe#complete()")
+(nvim.ex.inoremap "<silent><expr> <CR> compe#confirm('<CR>')")
+(nvim.ex.inoremap "<silent><expr> <C-e> compe#close('<C-e>')")
+(nvim.ex.inoremap "<silent><expr> <C-f> compe#scroll({ 'delta': +4 })")
+(nvim.ex.inoremap "<silent><expr> <C-d> compe#scroll({ 'delta': -4 })")
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/conjure.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/conjure.fnl
@@ -1,13 +1,12 @@
-(local core (require :nfnl.core))
-(local conjure-config (require :conjure.config))
+(module dotfiles.plugin.conjure
+  {autoload {a aniseed.core
+             conjure-config conjure.config
+             nvim aniseed.nvim}})

 ; (set nvim.g.conjure#eval#result_register "*")
 ; (set nvim.g.conjure#log#botright true)
-(set vim.g.conjure#mapping#doc_word :gk)
-(set vim.g.conjure#client#clojure#nrepl#mapping#session_clone :sC)
-(set vim.g.conjure#extract#tree_sitter#enabled true)
+(set nvim.g.conjure#mapping#doc_word "gk")
+(set nvim.g.conjure#extract#tree_sitter#enabled true)

-(conjure-config.assoc-in [:filetypes]
-                         (core.concat (conjure-config.filetypes) [:markdown]))
-
-(conjure-config.assoc-in [:filetype :markdown] :conjure.client.clojure.nrepl)
+(conjure-config.assoc-in [:filetypes] (a.concat (conjure-config.filetypes) [:markdown] ))
+(conjure-config.assoc-in [:filetype :markdown] "conjure.client.clojure.nrepl")
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/dadbodui.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/dadbodui.fnl
@@ -0,0 +1,4 @@
+(module dotfiles.plugin.dadbodui
+  {autoload { nvim aniseed.nvim }})
+
+
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/easyalign.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/easyalign.fnl
@@ -1,2 +1,5 @@
-(let [util (require :dotfiles.util)]
-  (util.noremap :v :<leader><bslash> :EasyAlign*<Bar>))
+(module dotfiles.plugin.easyalign
+  {autoload {nvim aniseed.nvim
+             util dotfiles.util }})
+
+(util.noremap :v :<leader><bslash> "EasyAlign*<Bar>")
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/fugitive.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/fugitive.fnl
@@ -1,13 +0,0 @@
-(local util (require :dotfiles.util))
-;; Determine load time of fugitive
-;; (vim.api.nvim_create_autocmd [:FileType] {:pattern ftype :callback setup-conceals})
-
-(fn bufmap [mode from to] (util.noremap mode from to {:local? true}))
-
-(fn map-fugitive-keys []
-  (bufmap :n :<leader>gp ":Git pull<CR>")
-  (bufmap :n :<leader>gP ":Git push<CR>")
-  (bufmap :n :<leader>gF ":Git push -f<CR>"))
-
-(vim.api.nvim_create_autocmd [:FileType]
-                             {:pattern :fugitive :callback map-fugitive-keys})
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/headlines.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/headlines.fnl
@@ -1 +0,0 @@
-(local headlines (require :headlines))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/hex.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/hex.fnl
@@ -1,3 +0,0 @@
-(let [hex (require :hex)]
-  (when hex
-    (hex.setup)))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/lspconfig.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/lspconfig.fnl
@@ -1,192 +1,195 @@
-(local a (require :nfnl.core))
-(local u (require :dotfiles.util))
-(local lsp (require :vim.lsp))
-(local lspconfig (require :lspconfig))
-(local cmp_nvim_lsp (require :cmp_nvim_lsp))
+(module dotfiles.plugin.lspconfig
+  {autoload
+   {a aniseed.core
+    u dotfiles.util
+    nvim aniseed.nvim
+    nu aniseed.nvim.util
+    }
+   })

-(fn bufmap [mode from to opts]
-  (u.noremap mode from to (a.merge {:local? true} opts)))
+(defn bufmap [mode from to]
+  (u.noremap mode from to {:local? true}))

-(fn nbufmap [from to opts] (bufmap :n from to opts))
+(defn nbufmap [from to]
+  (bufmap :n from to))

-(fn xbufmap [from to opts] (bufmap :x from to opts))
+(defn xbufmap [from to]
+  (bufmap :x from to))

-(fn lsp-execute-command [client cmd ...]
-  (let [buf-uri (vim.uri_from_bufnr 0)
-        cursor (vim.api.nvim_win_get_cursor 0)
-        r (- (a.first cursor) 1)
-        c (a.second cursor)
-        opts [buf-uri r c]
-        args (a.concat opts [...])]
-    ;;(client.exec_cmd {:command cmd :arguments args} {:bufnr 0})
-    (client.request_sync :workspace/executeCommand
-                         {:command cmd :arguments args} nil 0)))

-(vim.diagnostic.config {:signs {:text {vim.diagnostic.severity.ERROR "☢️"
-                                       vim.diagnostic.severity.WARN "⚠️"
-                                       vim.diagnostic.severity.INFO "ℹ️"
-                                       vim.diagnostic.severity.HINT "🔎"}
-                                ;; :linehl {vim.diagnostic.severity.ERROR :ErrorMsg}
-                                ;; :numhl {vim.diagnostic.severity.WARN :WarningMsg}
-                                }})
+(defn define-sign [level sign]
+  (let [sign-level (.. "DiagnosticSign" level)]
+    (nvim.fn.sign_define sign-level
+                     {:texthl sign-level
+                      :text sign
+                      :numhl sign-level})))

-(local core-nmappings
-       {:gd "lua vim.lsp.buf.definition()"
-        :gD "lua vim.lsp.buf.declaration()"
-        :gi "lua vim.lsp.buf.implementation()"
-        :gr "lua vim.lsp.buf.references()"
-        :K "lua vim.lsp.buf.hover()"
-        "[g" "lua vim.diagnostic.goto_prev()"
-        "]g" "lua vim.diagnostic.goto_next()"
-        ;:<c-k> "lua vim.lsp.buf.signature_help()"
-        :<leader>ca "lua vim.lsp.buf.code_action()"
-        :<leader>cl "lua vim.lsp.codelens.run()"
-        :<leader>ic "lua vim.lsp.buf.incoming_calls()"
-        ;; TODO: think of new mapping; conficts with org mode
-        ;; :<leader>oc "lua vim.lsp.buf.outgoing_calls()"
-        :<leader>sld "lua vim.diagnostic.open_float(nil, {source = 'always'})"
-        :<leader>rn "lua vim.lsp.buf.rename()"
-        :<leader>fa "lua vim.lsp.buf.format()"})
+; (define-sign :Error "☢️")
+; (define-sign :Warn  "⚠️")
+; (define-sign :SignHint "🔎")
+; (define-sign :Info  "ℹ️")
+(define-sign :Error "X")
+(define-sign :Warn  "!")
+(define-sign :SignHint "?")
+(define-sign :Info  "i")

-(local client-nmappings {:clojure_lsp {;;:<leader>cn "call LspExecuteCommand('clean-ns')"
-                                       ;; :<leader>ref "call LspExecuteCommand('extract-function', input('Function name: '))"
-                                       ;; :<leader>id "call LspExecuteCommand('inline-symbol')"
-                                       ;; :<leader>il "call LspExecuteCommand('introduce-let', input('Binding name: '))"
-                                       ;;:<leader>m2l "call LspExecuteCommand('move-to-let', input('Binding name: '))"
-                                       }})
+(def core-nmappings
+  {
+  :gd "lua vim.lsp.buf.definition()"
+  :gD "lua vim.lsp.buf.declaration()"
+  :gi "lua vim.lsp.buf.implementation()"
+  :gr "lua vim.lsp.buf.references()"
+  :K "lua vim.lsp.buf.hover()"
+  "[g" "lua vim.diagnostic.goto_prev()"
+  "]g" "lua vim.diagnostic.goto_next()"
+  :<c-k> "lua vim.lsp.buf.signature_help()"
+  :<leader>ca "lua vim.lsp.buf.code_action()"
+  :<leader>cl "lua vim.lsp.codelens.run()"
+  :<leader>ic "lua vim.lsp.buf.incoming_calls()"
+  :<leader>oc "lua vim.lsp.buf.outgoing_calls()"
+  :<leader>sld "lua vim.diagnostic.open_float(nil, {source = 'always'})"
+  :<leader>rn "lua vim.lsp.buf.rename()"
+  :<leader>fa "lua vim.lsp.buf.formatting_sync()"
+  })

-;;(vim.fn.input "foo: ")
+(def client-nmappings
+  {:clojure_lsp
+   {
+    :<leader>cn "call LspExecuteCommand('clean-ns')"
+    :<leader>ref "call LspExecuteCommand('extract-function', input('Function name: '))"
+    :<leader>id "call LspExecuteCommand('inline-symbol')"
+    :<leader>il "call LspExecuteCommand('introduce-let', input('Binding name: '))"
+    :<leader>m2l "call LspExecuteCommand('move-to-let', input('Binding name: '))"
+   }
+  })

-(local client-command-lnmappings
-       {:clojure_lsp {:ai [:add-import-to-namespace
-                           [(lambda [] (vim.fn.input "Namespace name: "))]]
-                      :am [:add-missing-libspec []]
-                      :as [:add-require-suggestion
-                           [(lambda [] (vim.fn.input "Namespace name: "))
-                            (lambda [] (vim.fn.input "Namespace as: "))
-                            (lambda [] (vim.fn.input "Namespace name: "))]]
-                      :cc [:cycle-coll []]
-                      :cn [:clean-ns []]
-                      :cp [:cycle-privacy []]
-                      :ct [:create-test []]
-                      :df [:drag-forward []]
-                      :db [:drag-backward []]
-                      :df [:drag-forward []]
-                      :dk [:destructure-keys []]
-                      :ed [:extract-to-def
-                           [(lambda [] (vim.fn.input "Definition name: "))]]
-                      :ref [:extract-function
-                            [(lambda [] (vim.fn.input "Function name: "))]]
-                      :el [:expand-let []]
-                      :fe [:create-function []]
-                      :il [:introduce-let
-                           [(lambda [] (vim.fn.input "Binding name: "))]]
-                      :is [:inline-symbol []]
-                      :ma [:resolve-macro-as []]
-                      :mf [:move-form
-                           [(lambda [] (vim.fn.input "File name: "))]]
-                      :ml [:move-to-let
-                           [(lambda [] (vim.fn.input "Binding name: "))]]
-                      :pf [:promote-fn
-                           [(lambda [] (vim.fn.input "Function name: "))]]
-                      :sc [:change-collection
-                           [(lambda [] (vim.fn.input ""))
-                            "input('Collection type: ')"]]
-                      :sm [:sort-map []]
-                      :tf [:thread-first-all []]
-                      :tF [:thread-first []]
-                      :tl [:thread-last-all []]
-                      :tL [:thread-last []]
-                      :ua [:unwind-all []]
-                      :uw [:unwind-thread []]}})

-(local server-specific-opts {})
-
-(fn bind-client-mappings [client]
+(defn bind-client-mappings [client]
  (let [client-name (a.get client :name)
-        mappings (a.get client-nmappings client-name)
-        command-lnmappings (a.get client-command-lnmappings client-name)]
+        mappings (a.get client-nmappings client-name)]
    (when mappings
      (each [mapping cmd (pairs mappings)]
-        (nbufmap mapping cmd {})))
-    (when command-lnmappings
-      (each [lnmapping command-mapping (pairs command-lnmappings)]
-        (let [lsp-cmd (a.first command-mapping)
-              ;;lsp-cmd (.. client-name "." (a.first command-mapping))
-              ;;opts (a.second command-mapping)
-              mapping (.. :<leader> lnmapping)
-              cmd (lambda []
-                    (let [opts (accumulate [s "" _i opt (ipairs (a.second command-mapping))]
-                                 (.. s
-                                     (if (= :function (type opt))
-                                         (opt)
-                                         opt)))]
-                      (lsp-execute-command client lsp-cmd opts)))]
-          (nbufmap mapping cmd {:desc (.. "LSP command `" lsp-cmd "`")}))))))
+        (nbufmap mapping cmd)))))

-(fn on_attach [client bufnr]
+(defn on_attach [client bufnr]
  (each [mapping cmd (pairs core-nmappings)]
-    (nbufmap mapping cmd {})) ; x mode mappings
-  (xbufmap :<leader>fa "lua vim.lsp.buf.format()" {:desc "Format buffer"}) ; --   buf_set_keymap('n', 'gs', '<Cmd>lua vim.lsp.buf.document_symbol()<CR>', opts)
-  ; --   buf_set_keymap('n', 'gS', '<Cmd>lua vim.lsp.buf.workspace_symbol()<CR>', opts)
-  ; --   buf_set_keymap('n', 'gt', '<cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
-  ; --   buf_set_keymap('n', '<leader>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
-  ; --   buf_set_keymap('n', '<leader>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
-  ; --   buf_set_keymap('n', '<leader>wl', '<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>', opts)
-  ; --   buf_set_keymap('n', '<leader>q', '<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>', opts)
-  ; --   buf_set_keymap('n', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
-  ; --   buf_set_keymap('x', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
-  (vim.api.nvim_set_option_value :omnifunc "v:lua.vim.lsp.omnifunc" {:buf 0})
+    (nbufmap mapping cmd))
+
+  ; x mode mappings
+  (xbufmap :<leader>fa "lua vim.lsp.buf.formatting_sync()")
+
+; --   buf_set_keymap('n', 'gs', '<Cmd>lua vim.lsp.buf.document_symbol()<CR>', opts)
+; --   buf_set_keymap('n', 'gS', '<Cmd>lua vim.lsp.buf.workspace_symbol()<CR>', opts)
+; --   buf_set_keymap('n', 'gt', '<cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
+; --   buf_set_keymap('n', '<leader>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
+; --   buf_set_keymap('n', '<leader>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
+; --   buf_set_keymap('n', '<leader>wl', '<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>', opts)
+; --   buf_set_keymap('n', '<leader>q', '<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>', opts)
+; --   buf_set_keymap('n', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
+; --   buf_set_keymap('x', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
+
+  (nvim.buf_set_option 0 :omnifunc "v:lua.vim.lsp.omnifunc")
+
  (bind-client-mappings client)
-  (when client.server_capabilities.documentHighlightProvider
-    (each [hlgroup base-group (pairs {:LspReferenceRead :SpecialKey
-                                      :LspReferenceText :SpecialKey
-                                      :LspReferenceWrite :SpecialKey})]
-      (vim.api.nvim_set_hl 0 hlgroup
-                           (a.merge (vim.api.nvim_get_hl_by_name base-group
-                                                                 true)
-                                    {:italic true
-                                     :foreground "#6c71c4"
-                                     :background :NONE})))
-    (let [group (vim.api.nvim_create_augroup :LspDocumentHighlight
-                                             {:clear true})]
-      (vim.api.nvim_create_autocmd [:CursorHold :CursorHoldI]
-                                   {: group
-                                    :pattern :<buffer>
-                                    :callback (lambda []
-                                                (vim.lsp.buf.document_highlight))})
-      (vim.api.nvim_create_autocmd [:CursorMoved]
-                                   {: group
-                                    :pattern :<buffer>
-                                    :callback (lambda []
-                                                (vim.lsp.buf.clear_references))})))
-  (if client.server_capabilities.documentFormattingProvider
-      (vim.api.nvim_create_autocmd [:BufWritePre]
-                                   {:pattern :<buffer>
-                                    :callback (lambda [] (vim.lsp.buf.format))}))
+  (nvim.ex.autocmd :BufWritePre :<buffer> :lua "vim.lsp.buf.formatting_sync()")
+;  (nvim.ex.autocmd "BufEnter,CursorHold,InsertLeave" :<buffer> :lua "vim.lsp.codelens.refresh()")
+
+  ; client autocmds
+;  -- vim.api.nvim_command[[autocmd BufWritePre <buffer> lua vim.lsp.buf_request_sync(vim.api.nvim_get_current_buf(), 'workspace/executeCommand', {command = 'clean-ns', arguments = {vim.uri_from_bufnr(1), vim.api.nvim_win_get_cursor(0)[1], vim.api.nvim_win_get_cursor(0)[2]}, title = 'Clean Namespace'})]]
+
  (print "LSP Client Attached."))

-(local base-server-opts
-       (let [capabilities (cmp_nvim_lsp.default_capabilities (lsp.protocol.make_client_capabilities))]
-         {: on_attach : capabilities :flags {:debounce_text_changes 150}}))
+(let [lspi (require :nvim-lsp-installer)]
+  (when lspi

-(fn default-server-handler [server-name]
-  (let [specific-opts (a.get server-specific-opts server-name {})
-        server-opts (a.merge base-server-opts specific-opts)]
-    (vim.lsp.config server-name server-opts)))
+    (defn lsp-execute-command [cmd ...]
+      (let [buf-uri (vim.uri_from_bufnr 0)
+            cursor (vim.api.nvim_win_get_cursor 0)
+            r (- (a.first cursor) 1)
+            c (a.second cursor)
+            opts [buf-uri r c]
+            args (a.concat opts [...])]
+        (vim.lsp.buf.execute_command {:command cmd
+                                      :arguments args})))

-(fn setup-handlers [language_servers]
-  (each [_ server-name (pairs language_servers)]
-    (default-server-handler server-name)))
+    (defn setup-servers []
+      (lspi.on_server_ready (fn [server]
+                              (let [opts {:on_attach on_attach :flags {:debounce_text_changes 150} }]
+                                (server:setup opts))))
+      ;; (let [lspconfig (require :lspconfig)
+      ;;       servers (lspi.get_installed_servers)]
+      ;;   (each [_ server (pairs servers)]
+      ;;     (server.setup {:on_attach on_attach :flags {:debounce_text_changes 150} })))
+      )

-(u.nnoremap :<leader>li :LspInfo)
+    (defn on-post-install []
+      (setup-servers)
+      (nvim.ex.bufdo :e))

-(vim.api.nvim_create_user_command :LspExecuteCommand lsp-execute-command
-                                  {:nargs "+"})
+    (setup-servers)

-; (let [mason-lspconfig (require :mason-lspconfig)]
-;   (when mason-lspconfig
-;     (mason-lspconfig.setup)
-;     (mason-lspconfig.setup_handlers [default-server-handler])))
+    (set lspi.post_install_hook on-post-install)
+    (nu.fn-bridge :LspExecuteCommand :dotfiles.plugin.lspconfig :lsp-execute-command {:return false})

-{: on_attach : default-server-handler : setup-handlers}
+    (u.nnoremap :<leader>li "LspInfo")))
+
+
+;; (let [eval (require :conjure.eval)
+;;       client (require :conjure.client)
+;;       ts-utils (require :nvim-treesitter.ts_utils)
+;;       parsers (require :nvim-treesitter.parsers)
+;;       ]
+;; 
+;;     ; client["with-filetype"]("fennel", eval["eval-str"], {
+;;     ;   origin = "my-awesome-plugin",
+;;     ;   code = "(+ 10 20)",
+;;     ;   ["passive?"] = true,
+;;     ;   ["on-result"] = function (r)
+;;     ;     print("RESULT:", r)
+;;     ;   end
+;;     ; })
+;; 
+;;     (defn ts-node-descendent-of? [node ancestor-type]
+;;       (print node)
+;;       (if (= nil node)
+;;         false
+;;         (let [node-type (node:type)]
+;;           (print node-type)
+;;           (if (= ancestor-type node-type)
+;;             true
+;;             (ts-node-descendent-of? (node:parent) ancestor-type)))))
+;; 
+;;     (defn in-fenced-code-block? []
+;;       (let [cursor (vim.api.nvim_win_get_cursor 0)
+;;             lnum (a.first cursor)
+;;             col (a.second cursor)
+;;             root_lang_tree (parsers.get_parser)
+;;             range [ lnum - 1 col lnum - 1 col ]
+;;             (node root lang-tree) (ts-utils.get_root_for_position (- lnum 1) col root_lang_tree) ]
+;;         (a.pr "language" (a.get lang-tree :_lang :err))
+;;         )
+;;       (let [node-at-cursor (ts-utils.get_node_at_cursor)]
+;;         (print "node at cursor" node-at-cursor)
+;;         (a.pr "root for node at cursor " (ts-utils.get_root_for_node node-at-cursor))
+;;         (print (ts-node-descendent-of? node-at-cursor :fenced_code_block))))
+;; 
+;;     (defn markdown-code-to-repl []
+;;       ; (let [buf-uri (vim.uri_from_bufnr 0)
+;;       ;       cursor (vim.api.nvim_win_get_cursor 0)
+;;       ;       r (- (a.first cursor) 1)
+;;       ;       c (a.second cursor)
+;;       ;       opts [buf-uri r c]
+;;       ;       args (a.concat opts [...])]
+;;       ;   (vim.lsp.buf.execute_command {:command cmd
+;;       ;                                 :arguments args}))
+;;       )
+;; 
+;;     (nu.fn-bridge :MarkdownCodeToRepl :dotfiles.plugin.lspconfig :markdown-code-to-repl {:return false})
+;; 
+;;     (nu.fn-bridge :IsInFencedCodeBlock :dotfiles.plugin.lspconfig :in-fenced-code-block? {:return false})
+;; 
+;;     ;; If file type is Markdown
+;;     ;(u.nnoremap :<leader>ee "call MarkdownCodeToRepl")
+;;     
+;;   )
+;; 
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/luasnip.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/luasnip.fnl
@@ -1,17 +0,0 @@
-(let [luasnip (require :luasnip)
-      select_choice (require :luasnip.extras.select_choice)]
-  (when luasnip
-    (vim.keymap.set [:i :s] :<C-k>
-                    (fn []
-                      (if (luasnip.expand_or_jumpable)
-                          (luasnip.expand_or_jump)))
-                    {:silent true})
-    (vim.keymap.set [:i :s] :<C-j>
-                    (fn []
-                      (if (luasnip.jumpable -1)
-                          (luasnip.jump -1))) {:silent true})
-    (vim.keymap.set :i :<C-l>
-                    (fn []
-                      (if (luasnip.choice_active)
-                          (luasnip.choice 1))))
-    (vim.keymap.set :i :<C-u> select_choice)))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/mason.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/mason.fnl
@@ -1,16 +0,0 @@
-(local mason (require :mason))
-(local mason-lspconf (require :mason-lspconfig))
-(local lspconfig (require :dotfiles.plugin.lspconfig))
-
-(fn setup []
-  (mason.setup {:ui {:icons {:package_installed "✓"}}})
-  (when mason-lspconf
-    (mason-lspconf.setup {:ensure_installed [:lua_ls] :automatic_enable true})
-    (lspconfig.setup-handlers (mason-lspconf.get_installed_servers))))
-
-(setup)
-;; (mason.setup)
-;; 
-;; (when-let [mason-lspconfig (require :mason-lspconfig)]
-;;   (mason-lspconfig.setup)
-;;           (mason-lspconfig.setup_handlers {1 default-server-handler}))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/nfnl.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/nfnl.fnl
@@ -1,2 +0,0 @@
-(local nfnl (require :nfnl))
-(nfnl.setup {:compile_on_write true})
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/null-ls.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/null-ls.fnl
@@ -1,8 +0,0 @@
-(let [null-ls (require :null-ls)
-      lspconfig (require :dotfiles.plugin.lspconfig)]
-  (when null-ls
-    (local null-ls-server-options
-           {:sources [null-ls.builtins.formatting.stylua
-                      null-ls.builtins.formatting.fnlfmt]
-            :on_attach lspconfig.on_attach})
-    (null-ls.setup null-ls-server-options)))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/orgbullets.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/orgbullets.fnl
@@ -1,45 +0,0 @@
-(local core (require :nfnl.core))
-(local conceal (require :dotfiles.conceal))
-(local ts-utils (require :dotfiles.ts-utils))
-(local stars ["◉" "⦾" "○" "✸" "✿" "✶" "•" "‣"])
-
-(local stars-query "(headline (stars) @stars)")
-
-(fn star-index [heading-level]
-  (let [star-count (core.count stars)
-        idx (math.fmod heading-level star-count)]
-    (if (< 0 idx)
-        idx
-        star-count)))
-
-(local extmark-namespace (vim.api.nvim_create_namespace :HeaderStars))
-
-(local star-captures (ts-utils.make-query :org stars-query))
-
-(fn gen-star-extmarks []
-  (when (= :org vim.bo.filetype)
-    (let [bufnr (vim.api.nvim_get_current_buf)
-          star-count (core.count stars)]
-      (vim.api.nvim_buf_clear_namespace bufnr extmark-namespace 0 -1)
-      (each [id node metadata (star-captures bufnr)]
-        (let [[start-line start-col end-row end-col] [(node:range)]
-              heading-level (if (= start-line end-row)
-                                (- end-col start-col))
-              star (core.get stars (star-index heading-level))
-              replacement (string.format (core.str "%" (+ 2 heading-level) :s)
-                                         star)]
-          (vim.api.nvim_buf_set_extmark bufnr extmark-namespace start-line
-                                        start-col
-                                        {:end_col end-col
-                                         :end_row end-row
-                                         :virt_text [[replacement []]]
-                                         :virt_text_pos :overlay
-                                         :hl_mode :combine}))))))
-
-(let [group (vim.api.nvim_create_augroup :HeaderStars {:clear true})]
-  (vim.api.nvim_create_autocmd [:FileChangedShellPost
-                                :Syntax
-                                :TextChanged
-                                :InsertLeave
-                                :WinScrolled]
-                               {: group :callback conceal.setup-conceals}))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/orgmode.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/orgmode.fnl
@@ -1,6 +0,0 @@
-(let [orgmode (require :orgmode)]
-  ;;(orgmode.setup_ts_grammar)
-  (orgmode.setup {:org_agenda_files ["~/Dropbox/org/*" "~/my-orgs/**/*"]
-                  :org_default_notes_file "~/Dropbox/org/refile.org"
-                  :mappings {:org {:org_toggle_checkbox :<C-.>}}})
-  (require :dotfiles.plugin.orgbullets))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/packer.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/packer.fnl
@@ -1,4 +1,8 @@
-(local u (require :dotfiles.util))
+(module dotfiles.plugin.packer
+  {autoload
+   {u dotfiles.util}
+   require
+   {nvim aniseed.nvim}})

 (u.nnoremap :<leader>pi :PackerInstall)
 (u.nnoremap :<leader>pu :PackerUpdate)
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/paredit.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/paredit.fnl
@@ -1,77 +0,0 @@
-(local a (require :nfnl.core))
-(local treesitter (require :dotfiles.plugin.treesitter))
-(local ts-parsers (require :nvim-treesitter.parsers))
-(local ts-utils (require :nvim-treesitter.ts_utils))
-(local languagetree (require :vim.treesitter.languagetree))
-
-(set vim.g.paredit_smartjump 1)
-
-(fn list-member? [xs x]
-  (a.some #(= x $1) (a.vals xs)))
-
-(fn bool->int [bool] (if bool 1 0))
-
-(fn int->bool [x] (if (= 0 x) false true))
-
-(fn toggle-global! [x]
-  (->> (a.get vim.g x)
-       (int->bool)
-       (not)
-       (bool->int)
-       (tset vim.g x)))
-
-(fn language-at-cursor []
-  (let [parser (ts-parsers.get_parser)
-        current-node (ts-utils.get_node_at_cursor)
-        range (if current-node [(current-node:range)])
-        lang (if range
-                 (languagetree.language_for_range parser range))]
-    (if lang
-        (lang:lang))))
-
-(fn parser-language []
-  (let [parser (ts-parsers.get_parser)]
-    (when parser
-      (parser:lang))))
-
-(local paredit-langs [:clojure
-                      :fennel
-                      :hy
-                      :janet
-                      :julia
-                      :lfe
-                      :lisp
-                      :racket
-                      :scheme
-                      :shen])
-
-(local paredit-host-langs [:org :markdown :asciidoc])
-
-(fn host-lang-in? [langs] (list-member? langs (parser-language)))
-
-(fn paredit-lang? [lang] (list-member? paredit-langs lang))
-
-(fn TreeSitterLangParedit []
-  (when (host-lang-in? paredit-host-langs)
-    (let [cursor-lang (language-at-cursor)]
-      (when cursor-lang
-        (->> cursor-lang
-             (paredit-lang?)
-             (bool->int)
-             (set vim.g.paredit_mode))
-        (vim.fn.PareditInitBuffer)))))
-
-(vim.api.nvim_create_autocmd [:FileType]
-                             {:pattern :ruby
-                              :callback (lambda []
-                                          (vim.fn.PareditInitBalancingAllBracketsBuffer))})
-
-(vim.api.nvim_create_autocmd [:FileType]
-                             {:pattern :javascript
-                              :callback (lambda []
-                                          (vim.fn.PareditInitBalancingAllBracketsBuffer))})
-
-(vim.api.nvim_create_autocmd [:FileType]
-                             {:pattern :terraform
-                              :callback (lambda []
-                                          (vim.fn.PareditInitBalancingAllBracketsBuffer))})
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/smartsplits.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/smartsplits.fnl
@@ -1,19 +0,0 @@
-(let [smart-splits (require :smart-splits)]
-  (when smart-splits
-    (smart-splits.setup)
-    ;; recommended mappings
-    ;; resizing splits
-    ;; these keymaps will also accept a range,
-    ;; for example `10<A-h>` will `resize_left` by `(10 * config.default_amount)`
-    (vim.keymap.set :n :<M-S-h> smart-splits.resize_left)
-    (vim.keymap.set :n :<M-S-j> smart-splits.resize_down)
-    (vim.keymap.set :n :<M-S-k> smart-splits.resize_up)
-    (vim.keymap.set :n :<M-S-l> smart-splits.resize_right) ; ; moving between splits
-    (vim.keymap.set :n :<M-h> smart-splits.move_cursor_left)
-    (vim.keymap.set :n :<M-j> smart-splits.move_cursor_down)
-    (vim.keymap.set :n :<M-k> smart-splits.move_cursor_up)
-    (vim.keymap.set :n :<M-l> smart-splits.move_cursor_right) ; ; swapping buffers between windows
-    (vim.keymap.set :n :<leader><leader>h smart-splits.swap_buf_left)
-    (vim.keymap.set :n :<leader><leader>j smart-splits.swap_buf_down)
-    (vim.keymap.set :n :<leader><leader>k smart-splits.swap_buf_up)
-    (vim.keymap.set :n :<leader><leader>l smart-splits.swap_buf_right)))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/telescope.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/telescope.fnl
@@ -1,45 +1,33 @@
-(local util (require :dotfiles.util))
-(local telescope (require :telescope))
+(module dotfiles.plugin.telescope
+  {autoload {nvim aniseed.nvim
+             util dotfiles.util
+             telescope telescope}})

-(local vimgrep_arguments [:ag
-                          :--nocolor
-                          :--noheading
-                          :--number
-                          :--column
-                          :--nobreak
-                          :--smart-case
-                          :--hidden
-                          ; "--skip-vcs-ignores"
-                          ; "-g" "!.git/"
-                          :--ignore
-                          :.git
-                          :--follow])
+(telescope.setup
+  {:defaults
+   {:vimgrep_arguments ["ag" "--nocolor" "--noheading"
+                        "--number" "--column" "--nobreak"
+                        "--smart-case" "--hidden" "--follow" ; "--skip-vcs-ignores"
+                        ; "-g" "!.git/"
+                        ]}})

-(telescope.load_extension :projects)
-(telescope.load_extension :yank_history)

-(telescope.setup {;; :defaults {: vimgrep_arguments}
-                  :pickers {:buffers {:mappings {:n {:d :delete_buffer}}}}
-                  :extensions {:projects {:projects {}}}})
-
-(util.lnnoremap :fc "Telescope commands")
-(util.lnnoremap :fC "Telescope command_history")
 (util.lnnoremap :ff "Telescope git_files hidden=true")
-(util.lnnoremap :f- "Telescope find_files")
+(util.lnnoremap :f- "Telescope file_browser")
 (util.lnnoremap :fg "Telescope live_grep")
-(util.lnnoremap "*" "Telescope grep_string")
+(util.lnnoremap :* "Telescope grep_string")
 (util.lnnoremap :fb "Telescope buffers")
-(util.lnnoremap :fd "Telescope diagnostics")
 (util.lnnoremap :fH "Telescope help_tags")
-(util.lnnoremap :fh "Telescope oldfiles")
-(util.lnnoremap :fp "Telescope projects")
 (util.lnnoremap :fm "Telescope keymaps")
 (util.lnnoremap :fM "Telescope marks")
+(util.lnnoremap :fh "Telescope oldfiles")
 (util.lnnoremap :ft "Telescope filetypes")
+(util.lnnoremap :fc "Telescope commands")
+(util.lnnoremap :fC "Telescope command_history")
 (util.lnnoremap :fq "Telescope quickfix")
 (util.lnnoremap :fl "Telescope loclist")
+(util.lnnoremap :fsa "Telescope lsp_code_actions")
 (util.lnnoremap :fsi "Telescope lsp_implementations")
 (util.lnnoremap :fsr "Telescope lsp_references")
 (util.lnnoremap :fsS "Telescope lsp_document_symbols")
 (util.lnnoremap :fss "Telescope lsp_workspace_symbols")
-(util.lnnoremap :fy "Telescope yank_history")
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/toggleterm.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/toggleterm.fnl
@@ -1,27 +0,0 @@
-(local toggleterm (require :toggleterm))
-
-(toggleterm.setup {:open_mapping "<c-\\>"
-                   :start_in_insert true
-                   :insert_mappings true
-                   ;; whether or not the open mapping applies in insert mode
-                   :terminal_mappings true
-                   ;; whether or not the open mapping applies in the opened terminals
-                   :persist_size true
-                   :persist_mode true
-                   ;; if set to true (default) the previous terminal mode will be remembered
-                   :autochdir true})
-
-(fn set-terminal-keymaps []
-  (vim.keymap.set :t :<esc> "<C-\\><C-n>")
-  (vim.keymap.set :t :jk "<C-\\><C-n>")
-  (vim.keymap.set :t :<C-h> "<Cmd>wincmd h<CR>")
-  (vim.keymap.set :t :<C-j> "<Cmd>wincmd j<CR>")
-  (vim.keymap.set :t :<C-k> "<Cmd>wincmd k<CR>")
-  (vim.keymap.set :t :<C-l> "<Cmd>wincmd l<CR>")
-  (vim.keymap.set :t :<C-w> "<C-\\><C-n><C-w>"))
-
-(vim.api.nvim_create_user_command :SetTerminalKeymaps set-terminal-keymaps {})
-
-(vim.api.nvim_create_autocmd [:TermOpen]
-                             {:pattern "term://*"
-                              :callback set-terminal-keymaps})
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/treesitter.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/treesitter.fnl
@@ -1,31 +1,22 @@
-(local treesitter-configs (require :nvim-treesitter.configs))
+(module dotfiles.plugin.treesitter
+  {autoload {treesitter nvim-treesitter.configs}})

-(treesitter-configs.setup {:highlight {:enable true
-                                       ;; :additional_vim_regex_highlighting false
-                                       :additional_vim_regex_highlighting [:org]}
-                           :ensure_installed :all
-                           ; [:org]
-                           :rainbow {:enable true
-                                     :extended_mode true
-                                     ; Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
-                                     :max_file_lines 10000
-                                     ; Do not enable for files with more than 1000 lines, int
-                                     :colors ["#dc322f"
-                                              ; red
-                                              "#b58900"
-                                              ; yellow
-                                              "#d33682"
-                                              ; magenta
-                                              "#859900"
-                                              ; green
-                                              "#2aa198"
-                                              ; cyan
-                                              "#268bd2"
-                                              ; blue
-                                              "#6c71c4"
-                                              ; violet / brmagenta
-                                              ]
-                                     ; table of hex strings
-                                     }})
+(treesitter.setup
+  {:highlight {:enable true
+               :additional_vim_regex_highlighting false}

-; lua print(require('nvim-treesitter.parsers').get_parser():language_for_range({ require('nvim-treesitter.ts_utils').get_node_at_cursor():range() }):lang())
+   :rainbow {:enable true
+             :extended_mode true ; Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
+             :max_file_lines 10000 ; Do not enable for files with more than 1000 lines, int
+             :colors [
+                      :#dc322f ; red
+                      :#b58900 ; yellow
+                      :#d33682 ; magenta
+                      :#859900 ; green
+                      :#2aa198 ; cyan
+                      :#268bd2 ; blue
+                      :#6c71c4 ; violet / brmagenta
+                      ] ; table of hex strings
+             }
+   :playground {:enable true}
+   })
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/whichkey.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/whichkey.fnl
@@ -1,3 +0,0 @@
-(let [which-key (require :which-key)]
-  (when which-key
-    (which-key.setup {})))
--- a/nvim/.config/nvim/fnl/dotfiles/plugin/yanky.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugin/yanky.fnl
@@ -1,32 +0,0 @@
-(local yanky (require :yanky))
-
-(yanky.setup {:ring {:history_length 100
-                     :storage :shada
-                     :sync_with_numbered_registers true
-                     :cancel_event :update}
-              :system_clipboard {:sync_with_ring true}})
-
-(vim.keymap.set :n :p "<Plug>(YankyPutAfter)")
-(vim.keymap.set :n :P "<Plug>(YankyPutBefore)")
-(vim.keymap.set :n :gp "<Plug>(YankyGPutAfter)")
-(vim.keymap.set :n :gP "<Plug>(YankyGPutBefore)")
-(vim.keymap.set :n :<c-n> "<Plug>(YankyCycleForward)")
-(vim.keymap.set :n :<c-p> "<Plug>(YankyCycleBackward)")
-
-(vim.keymap.set :n "]p" "<Plug>(YankyPutIndentAfterLinewise)")
-(vim.keymap.set :n "[p" "<Plug>(YankyPutIndentBeforeLinewise)")
-(vim.keymap.set :n "]P" "<Plug>(YankyPutIndentAfterLinewise)")
-(vim.keymap.set :n "[P" "<Plug>(YankyPutIndentBeforeLinewise)")
-
-(vim.keymap.set :n :>p "<Plug>(YankyPutIndentAfterShiftRight)")
-(vim.keymap.set :n :<p "<Plug>(YankyPutIndentAfterShiftLeft)")
-(vim.keymap.set :n :>P "<Plug>(YankyPutIndentBeforeShiftRight)")
-(vim.keymap.set :n :<P "<Plug>(YankyPutIndentBeforeShiftLeft)")
-
-(vim.keymap.set :n :=p "<Plug>(YankyPutAfterFilter)")
-(vim.keymap.set :n :=P "<Plug>(YankyPutBeforeFilter)")
-
-(vim.keymap.set :x :p "<Plug>(YankyPutAfter)")
-(vim.keymap.set :x :P "<Plug>(YankyPutBefore)")
-(vim.keymap.set :x :gp "<Plug>(YankyGPutAfter)")
-(vim.keymap.set :x :gP "<Plug>(YankyGPutBefore)")
--- a/nvim/.config/nvim/fnl/dotfiles/plugins.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/plugins.fnl
@@ -1,115 +1,88 @@
-(local packer (require :packer))
-(local core (require :nfnl.core))
+(module dotfiles.plugins
+  {autoload {nvim aniseed.nvim
+             a aniseed.core
+             ;; util dotfiles.util
+             packer packer

-(fn safe-require-plugin-config [name]
+             }
+   ;; require {minpac minpac}
+   })
+
+
+(defn safe-require-plugin-config [name]
  (let [(ok? val-or-err) (pcall require (.. :dotfiles.plugin. name))]
    (when (not ok?)
      (print (.. "dotfiles error: " val-or-err)))))

-(fn use [pkgs]
+(defn- use [pkgs]
  "Iterates through the arguments as pairs and calls packer's use function for
  each of them. Works around Fennel not liking mixed associative and sequential
  tables as well."
-  (packer.startup (fn [use]
-                    (each [name opts (pairs pkgs)]
-                      (-?> (. opts :mod) (safe-require-plugin-config))
-                      (use (core.assoc opts 1 name))))))
+  (packer.startup
+    (fn [use]
+      (each [name opts (pairs pkgs)]
+          (-?> (. opts :mod) (safe-require-plugin-config))
+          (use (a.assoc opts 1 name))
+        ))))

-(local packages {:Olical/nfnl {}
-                 :Olical/conjure {:mod :conjure}
-                 :Olical/fennel.vim {}
-                 :ahmedkhalf/project.nvim {}
-                 :airblade/vim-gitgutter {}
-                 :akinsho/toggleterm.nvim {:mod :toggleterm}
-                 :clojure-vim/vim-jack-in {}
-                 :christianrondeau/vim-base64 {}
-                 :dhruvasagar/vim-table-mode {}
-                 :folke/lsp-colors.nvim {}
-                 :folke/which-key.nvim {:mod :whichkey}
-                 :gbprod/yanky.nvim {:mod :yanky}
-                 :hashivim/vim-terraform {}
-                 :HiPhish/rainbow-delimiters.nvim {}
-                 :hrsh7th/nvim-cmp {:requires [:hrsh7th/cmp-buffer
-                                               :hrsh7th/cmp-emoji
-                                               :hrsh7th/cmp-nvim-lsp
-                                               :hrsh7th/cmp-nvim-lua
-                                               :hrsh7th/cmp-path
-                                               :hrsh7th/cmp-vsnip
-                                               :hrsh7th/vim-vsnip-integ
-                                               :L3MON4D3/LuaSnip
-                                               :PaterJason/cmp-conjure
-                                               :saadparwaiz1/cmp_luasnip]
-                                    :mod :cmp}
-                 :hrsh7th/vim-vsnip {}
-                 :hrsh7th/vim-vsnip-integ {}
-                 :Iron-E/nvim-soluarized {}
-                 :jiangmiao/auto-pairs {}
-                 :nvimtools/none-ls.nvim {:mod :null-ls
-                                          :requires [:nvim-lua/plenary.nvim]}
-                 :junegunn/vim-easy-align {:mod :easyalign}
-                 :kovisoft/paredit {:mod :paredit
-                                    :require [:nvim-treesitter/nvim-treesitter]}
-                 :kristijanhusak/vim-dadbod-completion {}
-                 :kristijanhusak/vim-dadbod-ui {}
-                 :L3MON4D3/LuaSnip {:mod :luasnip}
-                 :lifepillar/vim-solarized8 {}
-                 :lukas-reineke/headlines.nvim {:mod :headlines}
-                 ;   :michaelb/sniprun {:run "bash ./install.sh" :mod :sniprun}
-                 :mrjones2014/smart-splits.nvim {:mod :smartsplits}
-                 :mechatroner/rainbow_csv {}
-                 :MunifTanjim/nui.nvim {}
-                 :neovim/nvim-lspconfig {:mod :lspconfig}
-                 :norcalli/nvim-colorizer.lua {:mod :colorizer}
-                 :nvim-neo-tree/neo-tree.nvim {:branch :v3.x
-                                               :require [:nvim-lua/plenary.nvim
-                                                         :nvim-tree/nvim-web-devicons
-                                                         ; not strictly required, but recommended
-                                                         :MunifTanjim/nui.nvim
-                                                         ; :3rd/image.nvim, ; Optional image support in preview window: See `# Preview Mode` for more information
-                                                         ]}
-                 :nvim-orgmode/orgmode {:mod :orgmode}
-                 :nvim-telescope/telescope.nvim {:requires [[:nvim-lua/popup.nvim]
-                                                            [:nvim-lua/plenary.nvim]]
-                                                 :mod :telescope}
-                 :nvim-tree/nvim-web-devicons {}
-                 :nvim-treesitter/nvim-treesitter {:run ":TSUpdate"
-                                                   :mod :treesitter}
-                 :nvim-treesitter/playground {}
-                 :radenling/vim-dispatch-neovim {}
-                 :RaafatTurki/hex.nvim {:mod :hex}
-                 :rafamadriz/friendly-snippets {}
-                 :skywind3000/asyncrun.vim {}
-                 ;; :tjdevries/sg.nvim {:run "cargo build --workspace"
-                 ;;                     :dependencies [:nvim-lua/plenary.nvim]}
-                 ;; :tpope/vim-classpath {}
-                 :tpope/vim-dadbod {}
-                 :tpope/vim-dispatch {}
-                 :tpope/vim-fugitive {:mod :fugitive}
-                 :tpope/vim-git {}
-                 :tpope/vim-pathogen {}
-                 :tpope/vim-rails {}
-                 :tpope/vim-repeat {}
-                 :tpope/vim-rhubarb {}
-                 :tpope/vim-surround {}
-                 :tpope/vim-unimpaired {}
-                 :tpope/vim-vinegar {}
-                 :wbthomason/packer.nvim {:mod :packer}
-                 ;; :williamboman/nvim-lsp-installbuilder {}
-                 :williamboman/mason.nvim {:mod :mason
-                                           :requires [:williamboman/mason-lspconfig.nvim
-                                                      :neovim/nvim-lspconfig]}
-                 ; NeoVim lsp server installs
-                 ; :p00f/nvim-ts-rainbow {}
-                 ; :luochen1990/rainbow {}
-                 ; :thecontinium/asyncomplete-conjure.vim {}
-                 ; :jose-elias-alvarez/null-ls.nvim {:mod :null-ls
-                 ;                                   :requires [:nvim-lua/plenary.nvim]}
-                 }
-       ; :tpope/vim-fireplace {} ; Clojure ; :tpope/vim-sexp-mappings-for-regular-people {}
-       )
+
+(def- packages
+  {
+   :Olical/aniseed {}
+   :Olical/conjure { :mod :conjure } ; Clojure
+   :Olical/fennel.vim {} ; Fennel
+   :airblade/vim-gitgutter {} ; Git
+   :airblade/vim-gitgutter {} ; Git
+   :clojure-vim/vim-jack-in {} ; Conjure support - jack-in with nrepl dependencies
+   :folke/lsp-colors.nvim {}
+   :hashivim/vim-terraform {} ; Terraform
+   :hrsh7th/nvim-cmp {:requires [:hrsh7th/cmp-buffer
+                                 :hrsh7th/cmp-nvim-lsp
+                                 :hrsh7th/cmp-vsnip
+                                 :hrsh7th/vim-vsnip-integ
+                                 :PaterJason/cmp-conjure]
+                      :mod :cmp} ; autocomplete
+   :hrsh7th/vim-vsnip {}
+   :hrsh7th/vim-vsnip-integ {}
+   :Iron-E/nvim-soluarized {}
+   :jiangmiao/auto-pairs {} ; backets, parens, and quotes in pairs
+   :junegunn/vim-easy-align {:mod :easyalign}
+   :kovisoft/paredit {}
+   :kristijanhusak/vim-dadbod-completion {}
+   :kristijanhusak/vim-dadbod-ui {}
+   :neovim/nvim-lspconfig {:mod :lspconfig} ; NeoVim  lsp config
+   :norcalli/nvim-colorizer.lua {:mode :colorizer}
+   :nvim-telescope/telescope.nvim {:requires [[:nvim-lua/popup.nvim] [:nvim-lua/plenary.nvim]] :mod :telescope}
+   :nvim-treesitter/nvim-treesitter {:run ":TSUpdate" :mod :treesitter :requires [:nvim-treesitter/playground]}
+   :nvim-treesitter/playground {}
+   :p00f/nvim-ts-rainbow {}
+   :radenling/vim-dispatch-neovim {} ; Clojure
+   :skywind3000/asyncrun.vim {} ; :AsyncRun
+   :tpope/vim-classpath {}
+   :tpope/vim-dadbod {}
+   :tpope/vim-dispatch {} ; Conjure support - jack-in with nrepl dependencies
+   :tpope/vim-fugitive {} ; Git
+   :tpope/vim-git {} ; Git Commit Message
+   :tpope/vim-pathogen {}
+   :tpope/vim-rails {}
+   :tpope/vim-repeat {}
+   :tpope/vim-surround {}
+   :tpope/vim-unimpaired {}
+   :tpope/vim-vinegar {}
+   :wbthomason/packer.nvim {:mod :packer}
+   :williamboman/nvim-lsp-installer {} ; NeoVim lsp server installs
+
+   ; :luochen1990/rainbow {}
+   ; :thecontinium/asyncomplete-conjure.vim {}
+  }
+
+; :tpope/vim-fireplace {} ; Clojure
+; :tpope/vim-sexp-mappings-for-regular-people {}
+  )

 (use packages)

+
 ;;   call minpac#add('dense-analysis/ale') " Linting
 ;;   call minpac#add('editorconfig/editorconfig-vim')
 ;;   call minpac#add('elixir-lang/vim-elixir') " Elixir
--- a/nvim/.config/nvim/fnl/dotfiles/terraform-helpers.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/terraform-helpers.fnl
@@ -1,14 +0,0 @@
-(fn append-to-buf [bufno lines]
-  (when lines
-    (vim.aip.nvim_buf_set_lines bufno -1 -1 false lines)))
-
-(var tf-log-bufno nil)
-
-;; (fn terraform-import []
-;;   (vim.fn.jobstart [:terraform :import :-no-color address id]
-;;                    {:stdout_buffered true
-;;                     :on_stdout (fn [_ data]
-;;                                  (append-to-buf tf-log-bufno data))}))
-;; 
-; (nu.fn-bridge :ZoomToggle :dotfiles.zoom-toggle :zoom-toggle {:return false})
-; (u.nnoremap :<C-W>z ":call ZoomToggle()<CR>")
--- a/nvim/.config/nvim/fnl/dotfiles/ts-utils.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/ts-utils.fnl
@@ -1,15 +0,0 @@
-(local core (require :nfnl.core))
-
-(fn root [bufnr lang]
-  (let [parser (vim.treesitter.get_parser bufnr lang {})
-        tree (core.first (: parser :parse))]
-    (: tree :root)))
-
-(fn make-query [lang query-string]
-  (let [query (vim.treesitter.query.parse lang "(headline (stars) @stars)")]
-    (fn [bufnr]
-      (let [root-node (root bufnr lang)
-            iter-captures (query.iter_captures query root-node bufnr 0 -1)]
-        iter-captures))))
-
-{: root : make-query}
--- a/nvim/.config/nvim/fnl/dotfiles/util.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/util.fnl
@@ -1,40 +1,21 @@
-(local a (require :nfnl.core))
+(module dotfiles.util
+  {autoload
+   {a aniseed.core}
+   require
+   {nvim aniseed.nvim}})

-(fn fn? [x]
-  (= :function (type x)))

-(fn noremap [mode from to opts]
-  (let [local? (a.get opts :local?)
-        opts (a.assoc opts :local? nil)
-        map-opts (a.merge opts {:noremap true :silent true})
-        to (if (fn? to)
-               to
-               (.. ":" to :<cr>))
+(defn noremap [mode from to opts]
+  (let [map-opts {:noremap true :silent true}
+        to (.. ":" to "<cr>")
        buff-num (a.get opts :buff-num)]
-    (if (or local? buff-num)
-        (vim.keymap.set mode from to
-                        (a.merge map-opts {:buffer (or buff-num 0)}))
-        (vim.keymap.set mode from to map-opts))))

-(fn nnoremap [from to opts] (noremap :n from to opts))
+    (if (or (a.get opts :local?) buff-num )
+      (nvim.buf_set_keymap (or buff-num 0) mode from to map-opts)
+      (nvim.set_keymap mode from to map-opts))))

-(fn tnoremap [from to opts] (noremap :t from to opts))
+(defn nnoremap [from to opts]
+  (noremap :n from to opts))

-(fn inoremap [from to opts] (noremap :i from to opts))
-
-(fn vnoremap [from to opts] (noremap :v from to opts))
-
-(fn lnnoremap [from to opts] (nnoremap (.. :<leader> from) to opts))
-
-(fn ltnoremap [from to opts] (noremap :v (.. :<leader> from) to opts))
-
-(fn lvnoremap [from to opts] (noremap :t (.. :<leader> from) to opts))
-
-{: noremap
- : nnoremap
- : tnoremap
- : inoremap
- : vnoremap
- : lnnoremap
- : ltnoremap
- : lvnoremap}
+(defn lnnoremap [from to]
+  (nnoremap (.. "<leader>" from) to))
--- a/nvim/.config/nvim/fnl/dotfiles/zoom-toggle.fnl
+++ b/nvim/.config/nvim/fnl/dotfiles/zoom-toggle.fnl
@@ -1,18 +1,24 @@
-(local u (require :dotfiles.util))
+(module dotfiles.zoom-toggle
+  {autoload
+   {a aniseed.core}
+   require
+   {anenv aniseed.env
+    nvim aniseed.nvim
+    nu aniseed.nvim.util
+    u dotfiles.util}})

 (var unzoom! nil)

-(fn zoom-toggle []
+(defn zoom-toggle []
  (if unzoom!
-      (do
-        (vim.cmd unzoom!)
-        (set unzoom! nil))
-      (do
-        (set unzoom! (vim.fn.winrestcmd))
-        (vim.fn.resize)
-        (vim.fn.vertical :resize))))
+    (do
+      (nvim.command unzoom!)
+      (set unzoom! nil))
+    (do
+      (set unzoom! (nvim.fn.winrestcmd))
+      (nvim.ex.resize)
+      (nvim.ex.vertical :resize))))

-(vim.api.nvim_create_user_command :ZoomToggle zoom-toggle {})

-(u.nnoremap :<M-z> ":call ZoomToggle()<CR>")
-(u.tnoremap :<M-z> "<c-\\><c-n>:call ZoomToggle()<CR>")
+(nu.fn-bridge :ZoomToggle :dotfiles.zoom-toggle :zoom-toggle {:return false})
+(u.nnoremap :<C-W>z ":call ZoomToggle()<CR>")
--- a/nvim/.config/nvim/init.lua
+++ b/nvim/.config/nvim/init.lua
@@ -4,7 +4,7 @@ local fn = vim.fn
 local pack_path = fn.stdpath("data") .. "/site/pack"
 local fmt = string.format

-function ensure(user, repo)
+function ensure (user, repo)
  -- Ensures a given github.com/USER/REPO is cloned in the pack/packer/start directory.
  local install_path = fmt("%s/packer/start/%s", pack_path, repo, repo)
  if fn.empty(fn.glob(install_path)) > 0 then
@@ -15,13 +15,10 @@ end

 -- Bootstrap essential plugins required for installing and loading the rest.
 ensure("wbthomason", "packer.nvim")
-- ensure("Olical", "aniseed")
-ensure("lifepillar", "vim-solarized8")
+ensure("Olical", "aniseed")

 -- Enable Aniseed's automatic compilation and loading of Fennel source code.
-- vim.g["aniseed#env"] = {
--   module = "dotfiles.init",
--   compile = true
-- }
--
-require 'dotfiles.init'
+vim.g["aniseed#env"] = {
+  module = "dotfiles.init",
+  compile = true
+}
--- a/nvim/.config/nvim/lua/dotfiles/conceal.lua
+++ b/nvim/.config/nvim/lua/dotfiles/conceal.lua
@@ -1,30 +0,0 @@
-- [nfnl] fnl/dotfiles/conceal.fnl
-local u = require("dotfiles.util")
-local conceals = {defn = "\240\157\145\147", fn = "\206\187", lambda = "\206\187", ["and"] = "\226\136\167", ["&&"] = "\226\136\167", ["or"] = "\226\136\168", ["||"] = "\226\136\168", ["not"] = "\194\172", ["!"] = "\194\172", ["for"] = "\226\136\128", ["in"] = "\226\136\136", ["true"] = "\226\138\164", ["false"] = "\226\138\165"}
-local function setup_conceals()
-  vim.fn.clearmatches()
-  for the_match, replacement in pairs(conceals) do
-    local the_match0 = ("\\<" .. the_match .. "\\>")
-    vim.fn.matchadd("Conceal", the_match0, 0, -1, {conceal = replacement})
-  end
-  vim.wo.conceallevel = 2
-  vim.wo.concealcursor = "nvc"
-  return nil
-end
-local function toggle_conceal()
-  if (0 == vim.wo.conceallevel) then
-    vim.wo.conceallevel = 2
-    return nil
-  else
-    vim.wo.conceallevel = 0
-    return nil
-  end
-end
-vim.api.nvim_create_user_command("ToggleConceal", toggle_conceal, {})
-vim.api.nvim_create_user_command("SetupConceals", setup_conceals, {})
-u.nnoremap("<leader>ts", "call ToggleConceal()")
-local pretty_filetypes = {"fennel", "clojure"}
-for _, ftype in pairs(pretty_filetypes) do
-  vim.api.nvim_create_autocmd({"FileType"}, {pattern = ftype, callback = setup_conceals})
-end
-return {["setup-conceals"] = setup_conceals}
--- a/nvim/.config/nvim/lua/dotfiles/core.lua
+++ b/nvim/.config/nvim/lua/dotfiles/core.lua
@@ -1,46 +0,0 @@
-- [nfnl] fnl/dotfiles/core.fnl
-local a = require("nfnl.core")
-local u = require("dotfiles.util")
-vim.cmd.set("shortmess+=c")
-vim.cmd.set("path+=**")
-vim.cmd.set("wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/*")
-local function safe_source(filename)
-  local glob = vim.fn.glob(filename)
-  if not a["empty?"](glob) then
-    return vim.fn.source(filename)
-  else
-    return nil
-  end
-end
-local backup_dir = (vim.fn.glob("$HOME") .. "/.vim/backup")
-local undo_dir = (vim.fn.glob("$HOME") .. "/.vim/backup")
-local on_opts = {"autoindent", "autoread", "expandtab", "exrc", "hlsearch", "ignorecase", "incsearch", "number", "ruler", "secure", "shiftround", "showcmd", "showmatch", "smartcase", "splitbelow", "splitright", "termguicolors", "title", "undofile", "wildmenu"}
-local val_based_opts = {laststatus = 2, encoding = "utf-8", history = 500, redrawtime = 5000, scrolloff = 3, guifont = "Hasklig", guifontwide = "Hasklig", background = "dark", backupdir = backup_dir, directory = backup_dir, grepprg = "ag --vimgrep", tags = "tags", updatetime = 300, signcolumn = "auto:1-3", colorcolumn = {81, 100}, cmdheight = 2, undodir = undo_dir, undolevels = 1000, undoreload = 10000, foldmethod = "expr", foldexpr = "nvim_treesitter#foldexpr()", foldlevelstart = 100, foldlevel = 99, tabstop = 2, shiftwidth = 2, softtabstop = 2, mouse = "", list = true, listchars = "tab:\226\158\165\\ ,trail:\194\183,nbsp:\226\150\160", backspace = "indent,eol,start", wildmode = "list:longest,list:full", wrap = false}
-local append_val_opts = {diffopt = "algorithm:patience"}
-local function set_opt(_2_)
-  local opt = _2_[1]
-  local val = _2_[2]
-  vim.opt[a.str(opt)] = val
-  return nil
-end
-local function set_opt_2b(_3_)
-  local opt = _3_[1]
-  local val = _3_[2]
-  local existing_opt_val = a.get(vim.o, opt)
-  vim.opt[a.str(opt)] = a.str(existing_opt_val, ",", val)
-  return nil
-end
-local function set_opt_on(opt)
-  return set_opt({opt, true})
-end
-a.map(set_opt_on, on_opts)
-a["map-indexed"](set_opt, val_based_opts)
-a["map-indexed"](set_opt_2b, append_val_opts)
-vim.cmd.syntax("on")
-vim.cmd.colorscheme("solarized8")
-vim.api.nvim_create_autocmd({"vimenter"}, {pattern = "*", command = "colorscheme solarized8", nested = true})
-local function make_fennel_scratch()
-  return vim.cmd("new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel")
-end
-vim.api.nvim_create_user_command("FennelScratchBuffer", make_fennel_scratch, {})
-return u.nnoremap("<leader>fsb", ":call FennelScratchBuffer ()<CR>")
--- a/nvim/.config/nvim/lua/dotfiles/init.lua
+++ b/nvim/.config/nvim/lua/dotfiles/init.lua
@@ -1,23 +0,0 @@
-- [nfnl] fnl/dotfiles/init.fnl
-local a = require("nfnl.core")
-local str = require("nfnl.string")
-local fs = require("nfnl.fs")
-local function require_all()
-  local require_exclusions = a["->set"]({"init"})
-  local function _1_(_241)
-    return ("dotfiles." .. _241)
-  end
-  local function _2_(_241)
-    return not a["contains?"](require_exclusions, _241)
-  end
-  local function _3_(_241)
-    return a.first(str.split(_241, ".fnl"))
-  end
-  return a.map(_1_, a.filter(_2_, a.map(_3_, fs.relglob("fnl/dotfiles", "*.fnl"))))
-end
-require("dotfiles.core")
-require("dotfiles.plugins")
-require("dotfiles.mapping")
-require("dotfiles.conceal")
-require("dotfiles.zoom-toggle")
-return a.println("(re)loaded")
--- a/nvim/.config/nvim/lua/dotfiles/mapping.lua
+++ b/nvim/.config/nvim/lua/dotfiles/mapping.lua
@@ -1,38 +0,0 @@
-- [nfnl] fnl/dotfiles/mapping.fnl
-local util = require("dotfiles.util")
-local nfnl = require("nfnl.api")
-local function noremap(mode, from, to)
-  return vim.keymap.set(mode, from, to, {noremap = true})
-end
-local function _1_()
-  nfnl["compile-all-files"](vim.fn.stdpath("config"))
-  return vim.cmd.source((vim.fn.stdpath("config") .. "/init.lua"))
-end
-vim.keymap.set("n", "<leader>`", _1_)
-noremap("n", "<Enter>", ":nohlsearch<Enter>/<BS>")
-noremap("n", "<leader>zz", ":normal! 1z=<cr>")
-noremap("i", "<C-V><C-O>", ":set paste<CR><C-R><C-R>+<C-O>:set nopaste<CR>")
-noremap("n", "<F5>", "\"=strftime(\"%F\")<CR>p")
-noremap("i", "<F5>", "<C-R>=strftime(\"%F\")<CR>")
-noremap("n", "<M-5>", "\"=trim(system('date -u'))<CR>p")
-noremap("i", "<M-5>", "<C-R>=trim(system('date -u'))<CR>")
-noremap("v", "<leader>ah", "S<a href=\"\" target=\"_blank\" rel=\"nopener noreferrer\"><CR>")
-noremap("v", "<leader>ml", "xi[<c-r>\"]()<esc>")
-noremap("n", "<C-e>", "3<C-e>")
-noremap("n", "<C-y>", "3<C-y>")
-noremap("n", "<C-k>", "[e")
-noremap("n", "<C-j>", "]e")
-noremap("v", "<C-k>", "[egv")
-noremap("v", "<C-j>", "]egv")
-noremap("n", "<leader>jpp", ":%!python -m json.tool --indent=2<CR>")
-noremap("c", "w!!", "w !sudo tee % >/dev/null")
-noremap("n", "gnh", ":GitGutterNextHunk<CR>")
-noremap("n", "gph", ":GitGutterPrevHunk<CR>")
-noremap("n", "gsh", ":GitGutterStageHunk<CR>")
-noremap("n", "<leader>mv", ":AsyncRun -mode=bang open -a Marked\\ 2.app '%:p'<cr>")
-vim.api.nvim_create_autocmd({"FileType"}, {pattern = "sql", command = "nmap <leader>s vap<leader>S"})
-noremap("n", "Q", ":.!bash <CR>")
-util.lvnoremap("tw", "<C-U>s/\\s\\+$//ge<CR>:nohlsearch<Enter>/<BS>")
-util.lnnoremap("tw", "<C-U>.s/\\s\\+$//ge<CR>:nohlsearch<Enter>/<BS>")
-util.lnnoremap("<C-k>", ":set scrollback=1 | :set scrollback 100000<cr>", {silent = true})
-return util.ltnoremap("<C-k>", "<C-\\><C-n><leader><C-l>i", {silent = true})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/cmp.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/cmp.lua
@@ -1,18 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/cmp.fnl
-local cmp = require("cmp")
-local luasnip = require("luasnip")
-local cmp_src_menu_items = {buffer = "buff", conjure = "conj", nvim_lsp = "lsp"}
-local cmp_srcs = {{name = "nvim_lsp"}, {name = "nvim_lua"}, {name = "luasnip"}, {name = "vsnip"}, {name = "conjure"}, {name = "buffer"}, {name = "orgmode"}, {name = "emoji", max_item_count = 8}}
-local cmp0 = require("cmp")
-local function _1_(entry, item)
-  item.menu = (cmp_src_menu_items[entry.source.name] or "")
-  return item
-end
-local function _2_(args)
-  if args then
-    return luasnip.lsp_expand(args.body)
-  else
-    return nil
-  end
-end
-return cmp0.setup({formatting = {format = _1_}, mapping = {["<C-p>"] = cmp0.mapping.select_prev_item(), ["<C-n>"] = cmp0.mapping.select_next_item(), ["<C-b>"] = cmp0.mapping.scroll_docs(( - 4)), ["<C-f>"] = cmp0.mapping.scroll_docs(4), ["<C-Space>"] = cmp0.mapping.complete(), ["<C-e>"] = cmp0.mapping.close(), ["<C-y>"] = cmp0.mapping.confirm({select = true})}, snippet = {expand = _2_}, sources = cmp_srcs})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/colorizer.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/colorizer.lua
@@ -1,3 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/colorizer.fnl
-local colorizer = require("colorizer")
-return colorizer.setup({"*"}, {RGB = true, RRGGBB = true, names = true, RRGGBBAA = true, rgb_fn = true, hsl_fn = true, css = true, css_fn = true})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/conjure.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/conjure.lua
@@ -1,8 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/conjure.fnl
-local core = require("nfnl.core")
-local conjure_config = require("conjure.config")
-vim.g["conjure#mapping#doc_word"] = "gk"
-vim.g["conjure#client#clojure#nrepl#mapping#session_clone"] = "sC"
-vim.g["conjure#extract#tree_sitter#enabled"] = true
-conjure_config["assoc-in"]({"filetypes"}, core.concat(conjure_config.filetypes(), {"markdown"}))
-return conjure_config["assoc-in"]({"filetype", "markdown"}, "conjure.client.clojure.nrepl")
--- a/nvim/.config/nvim/lua/dotfiles/plugin/dadbodui.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/dadbodui.lua
@@ -1,2 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/dadbodui.fnl
-
--- a/nvim/.config/nvim/lua/dotfiles/plugin/easyalign.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/easyalign.lua
@@ -1,3 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/easyalign.fnl
-local util = require("dotfiles.util")
-return util.noremap("v", "<leader><bslash>", "EasyAlign*<Bar>")
--- a/nvim/.config/nvim/lua/dotfiles/plugin/fugitive.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/fugitive.lua
@@ -1,11 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/fugitive.fnl
-local util = require("dotfiles.util")
-local function bufmap(mode, from, to)
-  return util.noremap(mode, from, to, {["local?"] = true})
-end
-local function map_fugitive_keys()
-  bufmap("n", "<leader>gp", ":Git pull<CR>")
-  bufmap("n", "<leader>gP", ":Git push<CR>")
-  return bufmap("n", "<leader>gF", ":Git push -f<CR>")
-end
-return vim.api.nvim_create_autocmd({"FileType"}, {pattern = "fugitive", callback = map_fugitive_keys})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/headlines.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/headlines.lua
@@ -1,3 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/headlines.fnl
-local headlines = require("headlines")
-return nil
--- a/nvim/.config/nvim/lua/dotfiles/plugin/hex.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/hex.lua
@@ -1,7 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/hex.fnl
-local hex = require("hex")
-if hex then
-  return hex.setup()
-else
-  return nil
-end
--- a/nvim/.config/nvim/lua/dotfiles/plugin/lspconfig.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/lspconfig.lua
@@ -1,153 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/lspconfig.fnl
-local a = require("nfnl.core")
-local u = require("dotfiles.util")
-local lsp = require("vim.lsp")
-local lspconfig = require("lspconfig")
-local cmp_nvim_lsp = require("cmp_nvim_lsp")
-local function bufmap(mode, from, to, opts)
-  return u.noremap(mode, from, to, a.merge({["local?"] = true}, opts))
-end
-local function nbufmap(from, to, opts)
-  return bufmap("n", from, to, opts)
-end
-local function xbufmap(from, to, opts)
-  return bufmap("x", from, to, opts)
-end
-local function lsp_execute_command(client, cmd, ...)
-  local buf_uri = vim.uri_from_bufnr(0)
-  local cursor = vim.api.nvim_win_get_cursor(0)
-  local r = (a.first(cursor) - 1)
-  local c = a.second(cursor)
-  local opts = {buf_uri, r, c}
-  local args = a.concat(opts, {...})
-  return client.request_sync("workspace/executeCommand", {command = cmd, arguments = args}, nil, 0)
-end
-vim.diagnostic.config({signs = {text = {[vim.diagnostic.severity.ERROR] = "\226\152\162\239\184\143", [vim.diagnostic.severity.WARN] = "\226\154\160\239\184\143", [vim.diagnostic.severity.INFO] = "\226\132\185\239\184\143", [vim.diagnostic.severity.HINT] = "\240\159\148\142"}}})
-local core_nmappings = {gd = "lua vim.lsp.buf.definition()", gD = "lua vim.lsp.buf.declaration()", gi = "lua vim.lsp.buf.implementation()", gr = "lua vim.lsp.buf.references()", K = "lua vim.lsp.buf.hover()", ["[g"] = "lua vim.diagnostic.goto_prev()", ["]g"] = "lua vim.diagnostic.goto_next()", ["<leader>ca"] = "lua vim.lsp.buf.code_action()", ["<leader>cl"] = "lua vim.lsp.codelens.run()", ["<leader>ic"] = "lua vim.lsp.buf.incoming_calls()", ["<leader>sld"] = "lua vim.diagnostic.open_float(nil, {source = 'always'})", ["<leader>rn"] = "lua vim.lsp.buf.rename()", ["<leader>fa"] = "lua vim.lsp.buf.format()"}
-local client_nmappings = {clojure_lsp = {}}
-local client_command_lnmappings
-local function _1_()
-  return vim.fn.input("Namespace name: ")
-end
-local function _2_()
-  return vim.fn.input("Namespace name: ")
-end
-local function _3_()
-  return vim.fn.input("Namespace as: ")
-end
-local function _4_()
-  return vim.fn.input("Namespace name: ")
-end
-local function _5_()
-  return vim.fn.input("Definition name: ")
-end
-local function _6_()
-  return vim.fn.input("Function name: ")
-end
-local function _7_()
-  return vim.fn.input("Binding name: ")
-end
-local function _8_()
-  return vim.fn.input("File name: ")
-end
-local function _9_()
-  return vim.fn.input("Binding name: ")
-end
-local function _10_()
-  return vim.fn.input("Function name: ")
-end
-local function _11_()
-  return vim.fn.input("")
-end
-client_command_lnmappings = {clojure_lsp = {ai = {"add-import-to-namespace", {_1_}}, am = {"add-missing-libspec", {}}, as = {"add-require-suggestion", {_2_, _3_, _4_}}, cc = {"cycle-coll", {}}, cn = {"clean-ns", {}}, cp = {"cycle-privacy", {}}, ct = {"create-test", {}}, df = {"drag-forward", {}}, db = {"drag-backward", {}}, dk = {"destructure-keys", {}}, ed = {"extract-to-def", {_5_}}, ref = {"extract-function", {_6_}}, el = {"expand-let", {}}, fe = {"create-function", {}}, il = {"introduce-let", {_7_}}, is = {"inline-symbol", {}}, ma = {"resolve-macro-as", {}}, mf = {"move-form", {_8_}}, ml = {"move-to-let", {_9_}}, pf = {"promote-fn", {_10_}}, sc = {"change-collection", {_11_, "input('Collection type: ')"}}, sm = {"sort-map", {}}, tf = {"thread-first-all", {}}, tF = {"thread-first", {}}, tl = {"thread-last-all", {}}, tL = {"thread-last", {}}, ua = {"unwind-all", {}}, uw = {"unwind-thread", {}}}}
-local server_specific_opts = {}
-local function bind_client_mappings(client)
-  local client_name = a.get(client, "name")
-  local mappings = a.get(client_nmappings, client_name)
-  local command_lnmappings = a.get(client_command_lnmappings, client_name)
-  if mappings then
-    for mapping, cmd in pairs(mappings) do
-      nbufmap(mapping, cmd, {})
-    end
-  else
-  end
-  if command_lnmappings then
-    for lnmapping, command_mapping in pairs(command_lnmappings) do
-      local lsp_cmd = a.first(command_mapping)
-      local mapping = ("<leader>" .. lnmapping)
-      local cmd
-      local function _13_()
-        local opts
-        do
-          local s = ""
-          for _i, opt in ipairs(a.second(command_mapping)) do
-            local _14_
-            if ("function" == type(opt)) then
-              _14_ = opt()
-            else
-              _14_ = opt
-            end
-            s = (s .. _14_)
-          end
-          opts = s
-        end
-        return lsp_execute_command(client, lsp_cmd, opts)
-      end
-      cmd = _13_
-      nbufmap(mapping, cmd, {desc = ("LSP command `" .. lsp_cmd .. "`")})
-    end
-    return nil
-  else
-    return nil
-  end
-end
-local function on_attach(client, bufnr)
-  for mapping, cmd in pairs(core_nmappings) do
-    nbufmap(mapping, cmd, {})
-  end
-  xbufmap("<leader>fa", "lua vim.lsp.buf.format()", {desc = "Format buffer"})
-  vim.api.nvim_set_option_value("omnifunc", "v:lua.vim.lsp.omnifunc", {buf = 0})
-  bind_client_mappings(client)
-  if client.server_capabilities.documentHighlightProvider then
-    for hlgroup, base_group in pairs({LspReferenceRead = "SpecialKey", LspReferenceText = "SpecialKey", LspReferenceWrite = "SpecialKey"}) do
-      vim.api.nvim_set_hl(0, hlgroup, a.merge(vim.api.nvim_get_hl_by_name(base_group, true), {italic = true, foreground = "#6c71c4", background = "NONE"}))
-    end
-    local group = vim.api.nvim_create_augroup("LspDocumentHighlight", {clear = true})
-    local function _17_()
-      return vim.lsp.buf.document_highlight()
-    end
-    vim.api.nvim_create_autocmd({"CursorHold", "CursorHoldI"}, {group = group, pattern = "<buffer>", callback = _17_})
-    local function _18_()
-      return vim.lsp.buf.clear_references()
-    end
-    vim.api.nvim_create_autocmd({"CursorMoved"}, {group = group, pattern = "<buffer>", callback = _18_})
-  else
-  end
-  if client.server_capabilities.documentFormattingProvider then
-    local function _20_()
-      return vim.lsp.buf.format()
-    end
-    vim.api.nvim_create_autocmd({"BufWritePre"}, {pattern = "<buffer>", callback = _20_})
-  else
-  end
-  return print("LSP Client Attached.")
-end
-local base_server_opts
-do
-  local capabilities = cmp_nvim_lsp.default_capabilities(lsp.protocol.make_client_capabilities())
-  base_server_opts = {on_attach = on_attach, capabilities = capabilities, flags = {debounce_text_changes = 150}}
-end
-local function default_server_handler(server_name)
-  local specific_opts = a.get(server_specific_opts, server_name, {})
-  local server_opts = a.merge(base_server_opts, specific_opts)
-  return vim.lsp.config(server_name, server_opts)
-end
-local function setup_handlers(language_servers)
-  for _, server_name in pairs(language_servers) do
-    default_server_handler(server_name)
-  end
-  return nil
-end
-u.nnoremap("<leader>li", "LspInfo")
-vim.api.nvim_create_user_command("LspExecuteCommand", lsp_execute_command, {nargs = "+"})
-return {on_attach = on_attach, ["default-server-handler"] = default_server_handler, ["setup-handlers"] = setup_handlers}
--- a/nvim/.config/nvim/lua/dotfiles/plugin/luasnip.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/luasnip.lua
@@ -1,32 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/luasnip.fnl
-local luasnip = require("luasnip")
-local select_choice = require("luasnip.extras.select_choice")
-if luasnip then
-  local function _1_()
-    if luasnip.expand_or_jumpable() then
-      return luasnip.expand_or_jump()
-    else
-      return nil
-    end
-  end
-  vim.keymap.set({"i", "s"}, "<C-k>", _1_, {silent = true})
-  local function _3_()
-    if luasnip.jumpable(-1) then
-      return luasnip.jump(-1)
-    else
-      return nil
-    end
-  end
-  vim.keymap.set({"i", "s"}, "<C-j>", _3_, {silent = true})
-  local function _5_()
-    if luasnip.choice_active() then
-      return luasnip.choice(1)
-    else
-      return nil
-    end
-  end
-  vim.keymap.set("i", "<C-l>", _5_)
-  return vim.keymap.set("i", "<C-u>", select_choice)
-else
-  return nil
-end
--- a/nvim/.config/nvim/lua/dotfiles/plugin/mason.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/mason.lua
@@ -1,14 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/mason.fnl
-local mason = require("mason")
-local mason_lspconf = require("mason-lspconfig")
-local lspconfig = require("dotfiles.plugin.lspconfig")
-local function setup()
-  mason.setup({ui = {icons = {package_installed = "\226\156\147"}}})
-  if mason_lspconf then
-    mason_lspconf.setup({ensure_installed = {"lua_ls"}, automatic_enable = true})
-    return lspconfig["setup-handlers"](mason_lspconf.get_installed_servers())
-  else
-    return nil
-  end
-end
-return setup()
--- a/nvim/.config/nvim/lua/dotfiles/plugin/nfnl.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/nfnl.lua
@@ -1,3 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/nfnl.fnl
-local nfnl = require("nfnl")
-return nfnl.setup({compile_on_write = true})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/null-ls.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/null-ls.lua
@@ -1,9 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/null-ls.fnl
-local null_ls = require("null-ls")
-local lspconfig = require("dotfiles.plugin.lspconfig")
-if null_ls then
-  local null_ls_server_options = {sources = {null_ls.builtins.formatting.stylua, null_ls.builtins.formatting.fnlfmt}, on_attach = lspconfig.on_attach}
-  return null_ls.setup(null_ls_server_options)
-else
-  return nil
-end
--- a/nvim/.config/nvim/lua/dotfiles/plugin/orgbullets.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/orgbullets.lua
@@ -1,41 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/orgbullets.fnl
-local core = require("nfnl.core")
-local conceal = require("dotfiles.conceal")
-local ts_utils = require("dotfiles.ts-utils")
-local stars = {"\226\151\137", "\226\166\190", "\226\151\139", "\226\156\184", "\226\156\191", "\226\156\182", "\226\128\162", "\226\128\163"}
-local stars_query = "(headline (stars) @stars)"
-local function star_index(heading_level)
-  local star_count = core.count(stars)
-  local idx = math.fmod(heading_level, star_count)
-  if (0 < idx) then
-    return idx
-  else
-    return star_count
-  end
-end
-local extmark_namespace = vim.api.nvim_create_namespace("HeaderStars")
-local star_captures = ts_utils["make-query"]("org", stars_query)
-local function gen_star_extmarks()
-  if ("org" == vim.bo.filetype) then
-    local bufnr = vim.api.nvim_get_current_buf()
-    local star_count = core.count(stars)
-    vim.api.nvim_buf_clear_namespace(bufnr, extmark_namespace, 0, -1)
-    for id, node, metadata in star_captures(bufnr) do
-      local start_line,start_col,end_row,end_col = node:range()
-      local heading_level
-      if (start_line == end_row) then
-        heading_level = (end_col - start_col)
-      else
-        heading_level = nil
-      end
-      local star = core.get(stars, star_index(heading_level))
-      local replacement = string.format(core.str("%", (2 + heading_level), "s"), star)
-      vim.api.nvim_buf_set_extmark(bufnr, extmark_namespace, start_line, start_col, {end_col = end_col, end_row = end_row, virt_text = {{replacement, {}}}, virt_text_pos = "overlay", hl_mode = "combine"})
-    end
-    return nil
-  else
-    return nil
-  end
-end
-local group = vim.api.nvim_create_augroup("HeaderStars", {clear = true})
-return vim.api.nvim_create_autocmd({"FileChangedShellPost", "Syntax", "TextChanged", "InsertLeave", "WinScrolled"}, {group = group, callback = conceal["setup-conceals"]})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/orgmode.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/orgmode.lua
@@ -1,4 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/orgmode.fnl
-local orgmode = require("orgmode")
-orgmode.setup({org_agenda_files = {"~/Dropbox/org/*", "~/my-orgs/**/*"}, org_default_notes_file = "~/Dropbox/org/refile.org", mappings = {org = {org_toggle_checkbox = "<C-.>"}}})
-return require("dotfiles.plugin.orgbullets")
--- a/nvim/.config/nvim/lua/dotfiles/plugin/packer.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/packer.lua
@@ -1,4 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/packer.fnl
-local u = require("dotfiles.util")
-u.nnoremap("<leader>pi", "PackerInstall")
-return u.nnoremap("<leader>pu", "PackerUpdate")
--- a/nvim/.config/nvim/lua/dotfiles/plugin/paredit.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/paredit.lua
@@ -1,93 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/paredit.fnl
-local a = require("nfnl.core")
-local treesitter = require("dotfiles.plugin.treesitter")
-local ts_parsers = require("nvim-treesitter.parsers")
-local ts_utils = require("nvim-treesitter.ts_utils")
-local languagetree = require("vim.treesitter.languagetree")
-vim.g.paredit_smartjump = 1
-local function list_member_3f(xs, x)
-  local function _1_(_241)
-    return (x == _241)
-  end
-  return a.some(_1_, a.vals(xs))
-end
-local function bool__3eint(bool)
-  if bool then
-    return 1
-  else
-    return 0
-  end
-end
-local function int__3ebool(x)
-  if (0 == x) then
-    return false
-  else
-    return true
-  end
-end
-local function toggle_global_21(x)
-  vim.g[x] = bool__3eint(not int__3ebool(a.get(vim.g, x)))
-  return nil
-end
-local function language_at_cursor()
-  local parser = ts_parsers.get_parser()
-  local current_node = ts_utils.get_node_at_cursor()
-  local range
-  if current_node then
-    range = {current_node:range()}
-  else
-    range = nil
-  end
-  local lang
-  if range then
-    lang = languagetree.language_for_range(parser, range)
-  else
-    lang = nil
-  end
-  if lang then
-    return lang:lang()
-  else
-    return nil
-  end
-end
-local function parser_language()
-  local parser = ts_parsers.get_parser()
-  if parser then
-    return parser:lang()
-  else
-    return nil
-  end
-end
-local paredit_langs = {"clojure", "fennel", "hy", "janet", "julia", "lfe", "lisp", "racket", "scheme", "shen"}
-local paredit_host_langs = {"org", "markdown", "asciidoc"}
-local function host_lang_in_3f(langs)
-  return list_member_3f(langs, parser_language())
-end
-local function paredit_lang_3f(lang)
-  return list_member_3f(paredit_langs, lang)
-end
-local function TreeSitterLangParedit()
-  if host_lang_in_3f(paredit_host_langs) then
-    local cursor_lang = language_at_cursor()
-    if cursor_lang then
-      vim.g.paredit_mode = bool__3eint(paredit_lang_3f(cursor_lang))
-      return vim.fn.PareditInitBuffer()
-    else
-      return nil
-    end
-  else
-    return nil
-  end
-end
-local function _10_()
-  return vim.fn.PareditInitBalancingAllBracketsBuffer()
-end
-vim.api.nvim_create_autocmd({"FileType"}, {pattern = "ruby", callback = _10_})
-local function _11_()
-  return vim.fn.PareditInitBalancingAllBracketsBuffer()
-end
-vim.api.nvim_create_autocmd({"FileType"}, {pattern = "javascript", callback = _11_})
-local function _12_()
-  return vim.fn.PareditInitBalancingAllBracketsBuffer()
-end
-return vim.api.nvim_create_autocmd({"FileType"}, {pattern = "terraform", callback = _12_})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/smartsplits.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/smartsplits.lua
@@ -1,19 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/smartsplits.fnl
-local smart_splits = require("smart-splits")
-if smart_splits then
-  smart_splits.setup()
-  vim.keymap.set("n", "<M-S-h>", smart_splits.resize_left)
-  vim.keymap.set("n", "<M-S-j>", smart_splits.resize_down)
-  vim.keymap.set("n", "<M-S-k>", smart_splits.resize_up)
-  vim.keymap.set("n", "<M-S-l>", smart_splits.resize_right)
-  vim.keymap.set("n", "<M-h>", smart_splits.move_cursor_left)
-  vim.keymap.set("n", "<M-j>", smart_splits.move_cursor_down)
-  vim.keymap.set("n", "<M-k>", smart_splits.move_cursor_up)
-  vim.keymap.set("n", "<M-l>", smart_splits.move_cursor_right)
-  vim.keymap.set("n", "<leader><leader>h", smart_splits.swap_buf_left)
-  vim.keymap.set("n", "<leader><leader>j", smart_splits.swap_buf_down)
-  vim.keymap.set("n", "<leader><leader>k", smart_splits.swap_buf_up)
-  return vim.keymap.set("n", "<leader><leader>l", smart_splits.swap_buf_right)
-else
-  return nil
-end
--- a/nvim/.config/nvim/lua/dotfiles/plugin/telescope.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/telescope.lua
@@ -1,28 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/telescope.fnl
-local util = require("dotfiles.util")
-local telescope = require("telescope")
-local vimgrep_arguments = {"ag", "--nocolor", "--noheading", "--number", "--column", "--nobreak", "--smart-case", "--hidden", "--ignore", ".git", "--follow"}
-telescope.load_extension("projects")
-telescope.load_extension("yank_history")
-telescope.setup({pickers = {buffers = {mappings = {n = {d = "delete_buffer"}}}}, extensions = {projects = {projects = {}}}})
-util.lnnoremap("fc", "Telescope commands")
-util.lnnoremap("fC", "Telescope command_history")
-util.lnnoremap("ff", "Telescope git_files hidden=true")
-util.lnnoremap("f-", "Telescope find_files")
-util.lnnoremap("fg", "Telescope live_grep")
-util.lnnoremap("*", "Telescope grep_string")
-util.lnnoremap("fb", "Telescope buffers")
-util.lnnoremap("fd", "Telescope diagnostics")
-util.lnnoremap("fH", "Telescope help_tags")
-util.lnnoremap("fh", "Telescope oldfiles")
-util.lnnoremap("fp", "Telescope projects")
-util.lnnoremap("fm", "Telescope keymaps")
-util.lnnoremap("fM", "Telescope marks")
-util.lnnoremap("ft", "Telescope filetypes")
-util.lnnoremap("fq", "Telescope quickfix")
-util.lnnoremap("fl", "Telescope loclist")
-util.lnnoremap("fsi", "Telescope lsp_implementations")
-util.lnnoremap("fsr", "Telescope lsp_references")
-util.lnnoremap("fsS", "Telescope lsp_document_symbols")
-util.lnnoremap("fss", "Telescope lsp_workspace_symbols")
-return util.lnnoremap("fy", "Telescope yank_history")
--- a/nvim/.config/nvim/lua/dotfiles/plugin/toggleterm.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/toggleterm.lua
@@ -1,14 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/toggleterm.fnl
-local toggleterm = require("toggleterm")
-toggleterm.setup({open_mapping = "<c-\\>", start_in_insert = true, insert_mappings = true, terminal_mappings = true, persist_size = true, persist_mode = true, autochdir = true})
-local function set_terminal_keymaps()
-  vim.keymap.set("t", "<esc>", "<C-\\><C-n>")
-  vim.keymap.set("t", "jk", "<C-\\><C-n>")
-  vim.keymap.set("t", "<C-h>", "<Cmd>wincmd h<CR>")
-  vim.keymap.set("t", "<C-j>", "<Cmd>wincmd j<CR>")
-  vim.keymap.set("t", "<C-k>", "<Cmd>wincmd k<CR>")
-  vim.keymap.set("t", "<C-l>", "<Cmd>wincmd l<CR>")
-  return vim.keymap.set("t", "<C-w>", "<C-\\><C-n><C-w>")
-end
-vim.api.nvim_create_user_command("SetTerminalKeymaps", set_terminal_keymaps, {})
-return vim.api.nvim_create_autocmd({"TermOpen"}, {pattern = "term://*", callback = set_terminal_keymaps})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/treesitter.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/treesitter.lua
@@ -1,3 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/treesitter.fnl
-local treesitter_configs = require("nvim-treesitter.configs")
-return treesitter_configs.setup({highlight = {enable = true, additional_vim_regex_highlighting = {"org"}}, ensure_installed = "all", rainbow = {enable = true, extended_mode = true, max_file_lines = 10000, colors = {"#dc322f", "#b58900", "#d33682", "#859900", "#2aa198", "#268bd2", "#6c71c4"}}})
--- a/nvim/.config/nvim/lua/dotfiles/plugin/whichkey.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/whichkey.lua
@@ -1,7 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/whichkey.fnl
-local which_key = require("which-key")
-if which_key then
-  return which_key.setup({})
-else
-  return nil
-end
--- a/nvim/.config/nvim/lua/dotfiles/plugin/yanky.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugin/yanky.lua
@@ -1,23 +0,0 @@
-- [nfnl] fnl/dotfiles/plugin/yanky.fnl
-local yanky = require("yanky")
-yanky.setup({ring = {history_length = 100, storage = "shada", sync_with_numbered_registers = true, cancel_event = "update"}, system_clipboard = {sync_with_ring = true}})
-vim.keymap.set("n", "p", "<Plug>(YankyPutAfter)")
-vim.keymap.set("n", "P", "<Plug>(YankyPutBefore)")
-vim.keymap.set("n", "gp", "<Plug>(YankyGPutAfter)")
-vim.keymap.set("n", "gP", "<Plug>(YankyGPutBefore)")
-vim.keymap.set("n", "<c-n>", "<Plug>(YankyCycleForward)")
-vim.keymap.set("n", "<c-p>", "<Plug>(YankyCycleBackward)")
-vim.keymap.set("n", "]p", "<Plug>(YankyPutIndentAfterLinewise)")
-vim.keymap.set("n", "[p", "<Plug>(YankyPutIndentBeforeLinewise)")
-vim.keymap.set("n", "]P", "<Plug>(YankyPutIndentAfterLinewise)")
-vim.keymap.set("n", "[P", "<Plug>(YankyPutIndentBeforeLinewise)")
-vim.keymap.set("n", ">p", "<Plug>(YankyPutIndentAfterShiftRight)")
-vim.keymap.set("n", "<p", "<Plug>(YankyPutIndentAfterShiftLeft)")
-vim.keymap.set("n", ">P", "<Plug>(YankyPutIndentBeforeShiftRight)")
-vim.keymap.set("n", "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)")
-vim.keymap.set("n", "=p", "<Plug>(YankyPutAfterFilter)")
-vim.keymap.set("n", "=P", "<Plug>(YankyPutBeforeFilter)")
-vim.keymap.set("x", "p", "<Plug>(YankyPutAfter)")
-vim.keymap.set("x", "P", "<Plug>(YankyPutBefore)")
-vim.keymap.set("x", "gp", "<Plug>(YankyGPutAfter)")
-return vim.keymap.set("x", "gP", "<Plug>(YankyGPutBefore)")
--- a/nvim/.config/nvim/lua/dotfiles/plugins.lua
+++ b/nvim/.config/nvim/lua/dotfiles/plugins.lua
@@ -1,29 +0,0 @@
-- [nfnl] fnl/dotfiles/plugins.fnl
-local packer = require("packer")
-local core = require("nfnl.core")
-local function safe_require_plugin_config(name)
-  local ok_3f, val_or_err = pcall(require, ("dotfiles.plugin." .. name))
-  if not ok_3f then
-    return print(("dotfiles error: " .. val_or_err))
-  else
-    return nil
-  end
-end
-local function use(pkgs)
-  local function _2_(use0)
-    for name, opts in pairs(pkgs) do
-      do
-        local tmp_3_ = opts.mod
-        if (nil ~= tmp_3_) then
-          safe_require_plugin_config(tmp_3_)
-        else
-        end
-      end
-      use0(core.assoc(opts, 1, name))
-    end
-    return nil
-  end
-  return packer.startup(_2_)
-end
-local packages = {["Olical/nfnl"] = {}, ["Olical/conjure"] = {mod = "conjure"}, ["Olical/fennel.vim"] = {}, ["ahmedkhalf/project.nvim"] = {}, ["airblade/vim-gitgutter"] = {}, ["akinsho/toggleterm.nvim"] = {mod = "toggleterm"}, ["clojure-vim/vim-jack-in"] = {}, ["christianrondeau/vim-base64"] = {}, ["dhruvasagar/vim-table-mode"] = {}, ["folke/lsp-colors.nvim"] = {}, ["folke/which-key.nvim"] = {mod = "whichkey"}, ["gbprod/yanky.nvim"] = {mod = "yanky"}, ["hashivim/vim-terraform"] = {}, ["HiPhish/rainbow-delimiters.nvim"] = {}, ["hrsh7th/nvim-cmp"] = {requires = {"hrsh7th/cmp-buffer", "hrsh7th/cmp-emoji", "hrsh7th/cmp-nvim-lsp", "hrsh7th/cmp-nvim-lua", "hrsh7th/cmp-path", "hrsh7th/cmp-vsnip", "hrsh7th/vim-vsnip-integ", "L3MON4D3/LuaSnip", "PaterJason/cmp-conjure", "saadparwaiz1/cmp_luasnip"}, mod = "cmp"}, ["hrsh7th/vim-vsnip"] = {}, ["hrsh7th/vim-vsnip-integ"] = {}, ["Iron-E/nvim-soluarized"] = {}, ["jiangmiao/auto-pairs"] = {}, ["nvimtools/none-ls.nvim"] = {mod = "null-ls", requires = {"nvim-lua/plenary.nvim"}}, ["junegunn/vim-easy-align"] = {mod = "easyalign"}, ["kovisoft/paredit"] = {mod = "paredit", require = {"nvim-treesitter/nvim-treesitter"}}, ["kristijanhusak/vim-dadbod-completion"] = {}, ["kristijanhusak/vim-dadbod-ui"] = {}, ["L3MON4D3/LuaSnip"] = {mod = "luasnip"}, ["lifepillar/vim-solarized8"] = {}, ["lukas-reineke/headlines.nvim"] = {mod = "headlines"}, ["mrjones2014/smart-splits.nvim"] = {mod = "smartsplits"}, ["mechatroner/rainbow_csv"] = {}, ["MunifTanjim/nui.nvim"] = {}, ["neovim/nvim-lspconfig"] = {mod = "lspconfig"}, ["norcalli/nvim-colorizer.lua"] = {mod = "colorizer"}, ["nvim-neo-tree/neo-tree.nvim"] = {branch = "v3.x", require = {"nvim-lua/plenary.nvim", "nvim-tree/nvim-web-devicons", "MunifTanjim/nui.nvim"}}, ["nvim-orgmode/orgmode"] = {mod = "orgmode"}, ["nvim-telescope/telescope.nvim"] = {requires = {{"nvim-lua/popup.nvim"}, {"nvim-lua/plenary.nvim"}}, mod = "telescope"}, ["nvim-tree/nvim-web-devicons"] = {}, ["nvim-treesitter/nvim-treesitter"] = {run = ":TSUpdate", mod = "treesitter"}, ["nvim-treesitter/playground"] = {}, ["radenling/vim-dispatch-neovim"] = {}, ["RaafatTurki/hex.nvim"] = {mod = "hex"}, ["rafamadriz/friendly-snippets"] = {}, ["skywind3000/asyncrun.vim"] = {}, ["tpope/vim-dadbod"] = {}, ["tpope/vim-dispatch"] = {}, ["tpope/vim-fugitive"] = {mod = "fugitive"}, ["tpope/vim-git"] = {}, ["tpope/vim-pathogen"] = {}, ["tpope/vim-rails"] = {}, ["tpope/vim-repeat"] = {}, ["tpope/vim-rhubarb"] = {}, ["tpope/vim-surround"] = {}, ["tpope/vim-unimpaired"] = {}, ["tpope/vim-vinegar"] = {}, ["wbthomason/packer.nvim"] = {mod = "packer"}, ["williamboman/mason.nvim"] = {mod = "mason", requires = {"williamboman/mason-lspconfig.nvim", "neovim/nvim-lspconfig"}}}
-return use(packages)
--- a/nvim/.config/nvim/lua/dotfiles/terraform-helpers.lua
+++ b/nvim/.config/nvim/lua/dotfiles/terraform-helpers.lua
@@ -1,10 +0,0 @@
-- [nfnl] fnl/dotfiles/terraform-helpers.fnl
-local function append_to_buf(bufno, lines)
-  if lines then
-    return vim.aip.nvim_buf_set_lines(bufno, -1, -1, false, lines)
-  else
-    return nil
-  end
-end
-local tf_log_bufno = nil
-return nil
--- a/nvim/.config/nvim/lua/dotfiles/ts-utils.lua
+++ b/nvim/.config/nvim/lua/dotfiles/ts-utils.lua
@@ -1,17 +0,0 @@
-- [nfnl] fnl/dotfiles/ts-utils.fnl
-local core = require("nfnl.core")
-local function root(bufnr, lang)
-  local parser = vim.treesitter.get_parser(bufnr, lang, {})
-  local tree = core.first(parser:parse())
-  return tree:root()
-end
-local function make_query(lang, query_string)
-  local query = vim.treesitter.query.parse(lang, "(headline (stars) @stars)")
-  local function _1_(bufnr)
-    local root_node = root(bufnr, lang)
-    local iter_captures = query.iter_captures(query, root_node, bufnr, 0, -1)
-    return iter_captures
-  end
-  return _1_
-end
-return {root = root, ["make-query"] = make_query}
--- a/nvim/.config/nvim/lua/dotfiles/util.lua
+++ b/nvim/.config/nvim/lua/dotfiles/util.lua
@@ -1,44 +0,0 @@
-- [nfnl] fnl/dotfiles/util.fnl
-local a = require("nfnl.core")
-local function fn_3f(x)
-  return ("function" == type(x))
-end
-local function noremap(mode, from, to, opts)
-  local local_3f = a.get(opts, "local?")
-  local opts0 = a.assoc(opts, "local?", nil)
-  local map_opts = a.merge(opts0, {noremap = true, silent = true})
-  local to0
-  if fn_3f(to) then
-    to0 = to
-  else
-    to0 = (":" .. to .. "<cr>")
-  end
-  local buff_num = a.get(opts0, "buff-num")
-  if (local_3f or buff_num) then
-    return vim.keymap.set(mode, from, to0, a.merge(map_opts, {buffer = (buff_num or 0)}))
-  else
-    return vim.keymap.set(mode, from, to0, map_opts)
-  end
-end
-local function nnoremap(from, to, opts)
-  return noremap("n", from, to, opts)
-end
-local function tnoremap(from, to, opts)
-  return noremap("t", from, to, opts)
-end
-local function inoremap(from, to, opts)
-  return noremap("i", from, to, opts)
-end
-local function vnoremap(from, to, opts)
-  return noremap("v", from, to, opts)
-end
-local function lnnoremap(from, to, opts)
-  return nnoremap(("<leader>" .. from), to, opts)
-end
-local function ltnoremap(from, to, opts)
-  return noremap("v", ("<leader>" .. from), to, opts)
-end
-local function lvnoremap(from, to, opts)
-  return noremap("t", ("<leader>" .. from), to, opts)
-end
-return {noremap = noremap, nnoremap = nnoremap, tnoremap = tnoremap, inoremap = inoremap, vnoremap = vnoremap, lnnoremap = lnnoremap, ltnoremap = ltnoremap, lvnoremap = lvnoremap}
--- a/nvim/.config/nvim/lua/dotfiles/zoom-toggle.lua
+++ b/nvim/.config/nvim/lua/dotfiles/zoom-toggle.lua
@@ -1,17 +0,0 @@
-- [nfnl] fnl/dotfiles/zoom-toggle.fnl
-local u = require("dotfiles.util")
-local unzoom_21 = nil
-local function zoom_toggle()
-  if unzoom_21 then
-    vim.cmd(unzoom_21)
-    unzoom_21 = nil
-    return nil
-  else
-    unzoom_21 = vim.fn.winrestcmd()
-    vim.fn.resize()
-    return vim.fn.vertical("resize")
-  end
-end
-vim.api.nvim_create_user_command("ZoomToggle", zoom_toggle, {})
-u.nnoremap("<M-z>", ":call ZoomToggle()<CR>")
-return u.tnoremap("<M-z>", "<c-\\><c-n>:call ZoomToggle()<CR>")
--- a/test.md
+++ b/test.md
@@ -1,21 +0,0 @@
-# Some heading
-
-```fennel
-(print)
-  (* 21
-   (+ 1 3))
-```
-
-some clojure
-
-```clojure
-(print
- )(* 21
-  (+ 1 3))
-```
-
-some python
-
-```python
-print( 1 + 3 ) + 3
-```
--- a/test.org
+++ b/test.org
@@ -1,50 +0,0 @@
-* test
-** test level 2
-*** test level 3
-**** test level 4
-***** test level 5
-****** test level 6
-******* test level 7
-******** test level 8
-********* test level 9
-********** test level 10
-
-* test 3
-* test 4
-
-  #+NAME: x
-  3
-
- [ ] something
- [X] something else 
- [-] half done  ∂
-
-Some fennel
-
-#+begin_example ex1
-dfs
-#+end_example
-
-#+name: random
-#+begin_src fennel
-(print )
-(+ 1 (* 3 7))
-#+end_src
-
-#+results:
-
-Some Clojure
-
-#+begin_src clojure
-(println (* 3 )(+ 1 2) )
-#+end_src
-
-#+begin_src python :results silent :exports code :var n=0
-print(1 + 3)
-#+end_src
-
-
-#+begin_src
-print(+ 1 3)
-#+end_src
-
--- a/tmux.conf
+++ b/tmux.conf
@@ -1,9 +1,6 @@
 set -g prefix C-a
 unbind C-b

-set -g xterm-keys on
-set -s extended-keys on
-
 set -g history-file ~/.tmux_history

 set -s escape-time 1
@@ -11,8 +8,6 @@ set -s escape-time 1
 set -g base-index 1
 setw -g pane-base-index 1

-set -g main-pane-width 160
-
 bind r source-file ~/.tmux.conf \; display "Reloaded!"
 bind -r '`' clear-history \; display "History Cleared!"

@@ -38,8 +33,8 @@ setw -g mouse off

 # set -g default-terminal "xterm-256:color"
 # set -g default-terminal "${TERM}"
-set -g default-terminal "tmux-256color"
-set -g history-limit 55000
+set -s default-terminal "tmux-256color"
+set -g history-limit 6000

 set -g window-status-style dim
 set -g window-status-current-style bright
@@ -51,9 +46,8 @@ set -g status-right '#(~/dotfiles/bin/tmux_battery_charge_indicator.sh) #[bg=whi
 set -g update-environment "DISPLAY SSH_ASKPASS SSH_AGENT_PID SSH_CONNECTION WINDOWID XAUTHORITY"
 set-environment -g 'SSH_AUTH_SOCK' ~/.ssh/ssh_auth_sock

-# set -as terminal-overrides ',xterm-256color:RGB'
-set -as terminal-features ',tmux-256color:RGB'
-set-option -sa terminal-overrides ',tmux-256color:RGB'
+# set -as terminal-overrides ',xterm-257color:RGB'
+set -as terminal-features ',xterm-256color:RGB'

 # Undercurl
 set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support
@@ -61,31 +55,3 @@ set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support
 set -as terminal-overrides ',*:Setulc=\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'  # underscore colours - needs tmux-3.0

 set-option -g focus-events on
-
-
-# Smart pane switching with awareness of Vim splits.
-# See: https://github.com/christoomey/vim-tmux-navigator
-is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
-    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|n?vim?x?)(diff)?$'"
-bind-key -n M-S-h if-shell "$is_vim" 'send-keys M-S-h'  'resize-pane -L 3'
-bind-key -n M-S-j if-shell "$is_vim" 'send-keys M-S-j'  'resize-pane -D 3'
-bind-key -n M-S-k if-shell "$is_vim" 'send-keys M-S-k'  'resize-pane -U 3'
-bind-key -n M-S-l if-shell "$is_vim" 'send-keys M-S-l'  'resize-pane -R 3'
-
-bind-key -n M-h if-shell "$is_vim" 'send-keys M-h' 'select-pane -L'
-bind-key -n M-j if-shell "$is_vim" 'send-keys M-j' 'select-pane -D'
-bind-key -n M-k if-shell "$is_vim" 'send-keys M-k' 'select-pane -U'
-bind-key -n M-l if-shell "$is_vim" 'send-keys M-l' 'select-pane -R'
-
-tmux_version='$(tmux -V | sed -En "s/^tmux ([0-9]+(.[0-9]+)?).*/\1/p")'
-if-shell -b '[ "$(echo "$tmux_version < 3.0" | bc)" = 1 ]' \
-    "bind-key -n 'C-\\' if-shell \"$is_vim\" 'send-keys C-\\'  'select-pane -l'"
-if-shell -b '[ "$(echo "$tmux_version >= 3.0" | bc)" = 1 ]' \
-    "bind-key -n 'C-\\' if-shell \"$is_vim\" 'send-keys C-\\\\'  'select-pane -l'"
-
-bind-key -T copy-mode-vi 'M-S-h' select-pane -L
-bind-key -T copy-mode-vi 'M-S-j' select-pane -D
-bind-key -T copy-mode-vi 'M-S-k' select-pane -U
-bind-key -T copy-mode-vi 'M-S-l' select-pane -R
-bind-key -T copy-mode-vi 'M-S-\' select-pane -l
-
--- a/utils/curl-time-format.txt
+++ b/utils/curl-time-format.txt
@@ -1,8 +0,0 @@
-     time_namelookup:  %{time_namelookup}s\n
-        time_connect:  %{time_connect}s\n
-     time_appconnect:  %{time_appconnect}s\n
-    time_pretransfer:  %{time_pretransfer}s\n
-       time_redirect:  %{time_redirect}s\n
-  time_starttransfer:  %{time_starttransfer}s\n
-                     ----------\n
-          time_total:  %{time_total}s\n
--- a/utils/utils/curl-time-format.txt
+++ b/utils/utils/curl-time-format.txt
@@ -1,8 +0,0 @@
-     time_namelookup:  %{time_namelookup}s\n
-        time_connect:  %{time_connect}s\n
-     time_appconnect:  %{time_appconnect}s\n
-    time_pretransfer:  %{time_pretransfer}s\n
-       time_redirect:  %{time_redirect}s\n
-  time_starttransfer:  %{time_starttransfer}s\n
-                     ----------\n
-          time_total:  %{time_total}s\n
				`@@ -1,2 +0,0 @@`
				`-- [nfnl] fnl/dotfiles/plugin/dadbodui.fnl`