fix namespace reference

plus lots of fnlfmt updates

git/.gitconfig

@@ -0,0 +1,29 @@
+# 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
+[merge]
+  ff = only
+[push]
+  autoSetupRemote = true
+[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

nvim/.config/nvim/fnl/dotfiles/conceal.fnl

@@ -21,6 +21,8 @@
                :false :⊥
 ;; and
 ;; or
+;; if-not
+;; when-not
 ;; (not
 ;; None        | ∅
 ;; true, false | ⊤, ⊥ (top and bottom from logic)
@@ -46,16 +48,18 @@
     (set nvim.wo.conceallevel 2)
     (set nvim.wo.conceallevel 0)))
 
+;(setup-conceals)
+;(toggle-conceal)
 ;(if true true false)
 
 
 (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()")
+(u.nnoremap :<leader>tc "call ToggleConceal()")
 
 (def pretty-filetypes [:fennel
                        :clojure])
 
-; (each [_ ftype (pairs pretty-filetypes)]
-;   (nvim.ex.autocmd :FileType ftype :call "SetupConceals()"))
-; 
+(each [_ ftype (pairs pretty-filetypes)]
+  (nvim.ex.autocmd :FileType ftype :call "SetupConceals()"))
+

nvim/.config/nvim/fnl/dotfiles/core.fnl

@@ -1,121 +1,115 @@
-(module dotfiles.core
-  {autoload
-   {a aniseed.core}
-   require
-   {anenv aniseed.env
-    nvim aniseed.nvim
-    nu aniseed.nvim.util
-    u dotfiles.util
-    }})
+(module dotfiles.core {autoload {a aniseed.core}
+                       require {anenv aniseed.env
+                                nvim aniseed.nvim
+                                nu aniseed.nvim.util
+                                u dotfiles.util}})
 
+(nvim.ex.set :shortmess+=c)
 
-(nvim.ex.set "shortmess+=c") ; don't give |ins-completion-menu| messages.
-(nvim.ex.set "path+=**")
+; don't give |ins-completion-menu| messages.
+(nvim.ex.set :path+=**)
 (nvim.ex.set "wildignore+=*.o,*.obj,.git,*.rbc,*.class,.svn,vendor/gems/*")
 
-(defn- safe-source
-  [filename]
-  (let [glob (nvim.fn.glob filename)]
-    (if (not (a.empty? glob))
-      (nvim.ex.source filename))))
+(defn- safe-source [filename]
+       (let [glob (nvim.fn.glob filename)]
+         (if (not (a.empty? glob))
+             (nvim.ex.source filename))))
 
-(a.map safe-source ["~/.vimrc" "~/.vimrc.local"])
+; (a.map safe-source ["~/.vimrc" "~/.vimrc.local"])
 
+(def- backup-dir (.. (nvim.fn.glob :$HOME) :/.vim/backup))
+(def- undo-dir (.. (nvim.fn.glob :$HOME) :/.vim/backup))
 
-(def- backup-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))
-(def- undo-dir (.. (nvim.fn.glob "$HOME") "/.vim/backup"))
+(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])
 
-(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
-           ])
+(def- 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 [80 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:·,"
+                      :backspace "indent,eol,start"
+                      ;allow backspacing over everything in insert mode
+                      :wildmode "list:longest,list:full"
+                      :wrap false})
 
+(defn- 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
-   })
-
-(defn- set-opt
-  [[opt val]]
-  (tset vim.opt (a.str opt) val))
-
-(defn- 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)
 
-(nvim.ex.syntax "on")
-(nvim.ex.colorscheme :soluarized)
+(nvim.ex.syntax :on)
+;; (nvim.ex.colorscheme :soluarized)
+(nvim.ex.colorscheme :solarized8)
 
-
-
-(nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "solarized8")
+;; (nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "soluarized")
+(nvim.ex.autocmd :vimenter "*" :++nested :colorscheme :solarized8)
 ;(nvim.ex.autocmd "vimenter" "*"  "luafile" "treesitter.lua")
 ;
 ; (nvim.fn.glob "~/.vimrc.local")
 
-(defn make-fennel-scratch
-  []
-  (nvim.command "new | setlocal bt=nofile bh=wipe nobl noswapfile nu filetype=fennel"))
+(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})
 
-(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}))
+(defn compile-fnl [] (print :recompiling)
+      (anenv.init {:force true :init :dotfiles.init}))
 
 (nu.fn-bridge :AniseedCompile :dotfiles.core :compile-fnl {:return false})

nvim/.config/nvim/fnl/dotfiles/init.fnl

@@ -5,11 +5,12 @@
    {nvim aniseed.nvim}})
 
 
-(require :dotfiles.plugins)
 (require :dotfiles.core)
+(require :dotfiles.plugins)
 (require :dotfiles.mapping)
 (require :dotfiles.conceal)
 (require :dotfiles.zoom-toggle)
 
 ;(nvim.ex.source "~/.vimrc")
 
+(a.println "(re)loaded")

nvim/.config/nvim/fnl/dotfiles/mapping.fnl

@@ -1,39 +1,47 @@
 (module dotfiles.mapping
-  {autoload {nvim aniseed.nvim
-             nu aniseed.nvim.util
-             core aniseed.core}})
+        {autoload {nvim aniseed.nvim
+                   nu aniseed.nvim.util
+                   core aniseed.core
+                   util dotfiles.util}})
 
-(defn- noremap [mode from to]
-  "Sets a mapping with {:noremap true}."
-  (nvim.set_keymap mode from to {:noremap true}))
+(defn- noremap [mode from to] "Sets a mapping with {:noremap true}."
+       (nvim.set_keymap mode from to {:noremap true}))
 
 ; (set nvim.g.mapleader "\\")
 
-(noremap :n "<leader>`" ":source ~/.config/nvim/init.lua<CR>")
-(noremap :n "<leader>!" ":call AniseedCompile()<CR>")
+(defn aniseed-reload []
+      (each [k _ (ipairs package.loaded)]
+        (when (string.match k "^dotfiles%..+")
+          (tset package.loaded k nil)))
+      ((. (require :aniseed.env) :init) {:module :dotfiles.init :compile true})
+      (core.println "aniseed reloaded!"))
+
+(vim.keymap.set :n "<leader>`" aniseed-reload)
+
+; (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>")
 
 ; 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
@@ -54,8 +62,9 @@
 (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")
+(nvim.ex.autocmd :FileType :sql :nmap :<leader>s :vap<leader>S)
 
+(noremap :n :Q ":.!bash <CR>")

nvim/.config/nvim/fnl/dotfiles/plugin/cmp.fnl

@@ -1,42 +1,39 @@
-(module dotfiles.plugin.cmp
-  {autoload {nvim aniseed.nvim}})
+(module dotfiles.plugin.cmp {autoload {nvim aniseed.nvim luasnip luasnip}})
 
+(module config.plugin.cmp {autoload {nvim aniseed.nvim cmp cmp}})
 
-(module config.plugin.cmp
-  {autoload {nvim aniseed.nvim
-             cmp cmp}})
+(def- cmp-src-menu-items {:buffer :buff :conjure :conj :nvim_lsp :lsp})
 
-(def- cmp-src-menu-items
-  {:buffer "buff"
-   :conjure "conj"
-   :nvim_lsp "lsp"})
-
-(def- cmp-srcs
-  [{:name :nvim_lsp}
-   {:name :vsnip}
-   {:name :conjure}
-   {:name :buffer}])
+(def- cmp-srcs [{:name :nvim_lsp}
+                {:name :nvim_lua}
+                {:name :luasnip}
+                {:name :vsnip}
+                {:name :conjure}
+                {:name :buffer}
+                {:name :orgmode}
+                {:name :emoji :max_item_count 8}])
 
 ;; 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)
-                        :<CR> (cmp.mapping.confirm {:behavior cmp.ConfirmBehavior.Insert
-                                                    :select true})}
-
+                        :<C-y> (cmp.mapping.confirm {;; :behavior cmp.ConfirmBehavior.Insert
+                                                     :select true})}
               :snippet {:expand (fn [args]
-                                  (nvim.fn.vsnip#anonymous args.body))}
+                                  (if args
+                                      (luasnip.lsp_expand 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>'

nvim/.config/nvim/fnl/dotfiles/plugin/colorizer.fnl

@@ -1,13 +1,13 @@
 (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
-                  })
+(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
+                   })

nvim/.config/nvim/fnl/dotfiles/plugin/compe.fnl

@@ -25,6 +25,7 @@
                 :nvim_lsp true
                 :nvim_lua true
                 :conjure true
+                :orgmode true
                 :vsnip true
                 :vim_dadbod_completion true}})))
 

nvim/.config/nvim/fnl/dotfiles/plugin/conjure.fnl

@@ -6,6 +6,7 @@
 ; (set nvim.g.conjure#eval#result_register "*")
 ; (set nvim.g.conjure#log#botright true)
 (set nvim.g.conjure#mapping#doc_word "gk")
+(set nvim.g.conjure#client#clojure#nrepl#mapping#session_clone :sC)
 (set nvim.g.conjure#extract#tree_sitter#enabled true)
 
 (conjure-config.assoc-in [:filetypes] (a.concat (conjure-config.filetypes) [:markdown] ))

nvim/.config/nvim/fnl/dotfiles/plugin/fugitive.fnl

@@ -0,0 +1,9 @@
+(module dotfiles.plugin.fugitive
+  {autoload {nvim aniseed.nvim
+             nu aniseed.nvim.util
+             core aniseed.core
+             util dotfiles.util}})
+
+(nvim.ex.autocmd :FileType :fugitive :nmap :<buffer> :<leader>gp ":Git pull<CR>")
+;; Determine load time of fugitive
+(nvim.ex.autocmd :FileType :fugitive :nmap :<buffer> :<leader>gP ":Git push<CR>" )

nvim/.config/nvim/fnl/dotfiles/plugin/headlines.fnl

@@ -0,0 +1,2 @@
+(module dotfiles.plugin.headlines
+  {autoload {headlines headlines}})

nvim/.config/nvim/fnl/dotfiles/plugin/lspconfig.fnl

@@ -1,134 +1,159 @@
 (module dotfiles.plugin.lspconfig
-  {autoload
-   {a aniseed.core
-    u dotfiles.util
-    nvim aniseed.nvim
-    nu aniseed.nvim.util
-    }
-   })
+        {autoload {a aniseed.core
+                   u dotfiles.util
+                   nvim aniseed.nvim
+                   lsp vim.lsp
+                   nu aniseed.nvim.util
+                   cmp_nvim_lsp cmp_nvim_lsp}})
 
-(defn bufmap [mode from to]
-  (u.noremap mode from to {:local? true}))
+(defn bufmap [mode from to] (u.noremap mode from to {:local? true}))
 
-(defn nbufmap [from to]
-  (bufmap :n from to))
-
-(defn xbufmap [from to]
-  (bufmap :x from to))
+(defn nbufmap [from to] (bufmap :n from to))
 
+(defn xbufmap [from to] (bufmap :x from to))
 
 (defn define-sign [level sign]
-  (let [sign-level (.. "DiagnosticSign" level)]
-    (nvim.fn.sign_define sign-level
-                     {:texthl sign-level
-                      :text sign
-                      :numhl sign-level})))
+      (let [sign-level (.. :DiagnosticSign level)]
+        (nvim.fn.sign_define sign-level
+                             {:texthl sign-level :text sign :numhl sign-level})))
 
 ; (define-sign :Error "☢️")
 ; (define-sign :Warn  "⚠️")
 ; (define-sign :SignHint "🔎")
 ; (define-sign :Info  "ℹ️")
-(define-sign :Error "X")
-(define-sign :Warn  "!")
+(define-sign :Error :X)
+(define-sign :Warn "!")
 (define-sign :SignHint "?")
-(define-sign :Info  "i")
+(define-sign :Info :i)
 
 (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()"
-  })
+     {: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()"})
 
 (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: '))"
-   }
-  })
+     {: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 client-command-lnmappings
+     {:clojure_lsp {:ai [:add-import-to-namespace
+                         ["input('Namespace name: ')"]]
+                    :am [:add-missing-libspec []]
+                    :as [:add-require-suggestion
+                         ["input('Namespace name: ')"
+                          "input('Namespace as: ')"
+                          "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 ["input('Definition name: ')"]]
+                    :ef [:extract-function ["input('Function name: ')"]]
+                    :el [:expand-let []]
+                    :fe [:create-function []]
+                    :il [:introduce-let ["input('Binding name: ')"]]
+                    :is [:inline-symbol []]
+                    :ma [:resolve-macro-as []]
+                    :mf [:move-form ["input('File name: ')"]]
+                    :ml [:move-to-let ["input('Binding name: ')"]]
+                    :pf [:promote-fn ["input('Function name: ')"]]
+                    :sc [:change-collection ["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 []]}})
 
 (defn bind-client-mappings [client]
-  (let [client-name (a.get client :name)
-        mappings (a.get client-nmappings client-name)]
-    (when mappings
-      (each [mapping cmd (pairs mappings)]
-        (nbufmap mapping cmd)))))
+      (let [client-name (a.get client :name)
+            mappings (a.get client-nmappings client-name)
+            command-lnmappings (a.get client-command-lnmappings 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)
+                  opts-str (accumulate [s "" i opt (ipairs (a.second command-mapping))]
+                             (.. s ", " opt))
+                  mapping (.. :<leader> lnmapping)
+                  cmd (.. "call LspExecuteCommand('" lsp-cmd "'" opts-str ")")]
+              (nbufmap mapping cmd))))))
 
 (defn on_attach [client bufnr]
-  (each [mapping cmd (pairs core-nmappings)]
-    (nbufmap mapping cmd))
+      (each [mapping cmd (pairs core-nmappings)]
+        (nbufmap mapping cmd)) ; x mode mappings
+      (xbufmap :<leader>fa "lua vim.lsp.buf.format()")
+      ; --   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)
+      (if client.server_capabilities.documentFormattingProvider
+          (nvim.ex.autocmd :BufWritePre :<buffer> ":lua vim.lsp.buf.format()"))
+      ;  (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."))
 
-  ; x mode mappings
-  (xbufmap :<leader>fa "lua vim.lsp.buf.formatting_sync()")
+(when-let [lspi (require :nvim-lsp-installer)]
+          (let [capabilities (cmp_nvim_lsp.update_capabilities (lsp.protocol.make_client_capabilities))]
+            (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})))
+            (defn setup-servers []
+                  (lspi.on_server_ready (fn [server]
+                                          (let [opts {: on_attach
+                                                      : capabilities
+                                                      :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} })))
+                  )
+            (defn on-post-install [] (setup-servers) (nvim.ex.bufdo :e))
+            (setup-servers)
+            (set lspi.post_install_hook on-post-install)
+            (nu.fn-bridge :LspExecuteCommand :dotfiles.plugin.lspconfig
+                          :lsp-execute-command {:return false})
+            (u.nnoremap :<leader>li :LspInfo)))
 
-; --   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)
-  (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."))
-
-(let [lspi (require :nvim-lsp-installer)]
-  (when lspi
-
-    (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})))
-
-    (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} })))
-      )
-
-    (defn on-post-install []
-      (setup-servers)
-      (nvim.ex.bufdo :e))
-
-    (setup-servers)
-
-    (set lspi.post_install_hook on-post-install)
-    (nu.fn-bridge :LspExecuteCommand :dotfiles.plugin.lspconfig :lsp-execute-command {:return false})
-
-    (u.nnoremap :<leader>li "LspInfo")))
+(comment (let [lspi (require :nvim-lsp-installer)
+               ;lspconfig (require :lspconfig)
+               servers (lspi.get_installed_servers)]
+           (each [_ server (pairs servers)]
+             (a.pr server))))

nvim/.config/nvim/fnl/dotfiles/plugin/luasnip.fnl

@@ -0,0 +1,19 @@
+(module dotfiles.plugin.luasnip
+        {autoload {nvim aniseed.nvim util dotfiles.util luasnip luasnip}
+         require {select_choice luasnip.extras.select_choice}})
+
+(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)

nvim/.config/nvim/fnl/dotfiles/plugin/null-ls.fnl

@@ -0,0 +1,13 @@
+(module dotfiles.plugin.null-ls
+        {autoload {nvim aniseed.nvim
+                   a aniseed.core
+                   nu aniseed.nvim.util
+                   null-ls null-ls
+                   lspconfig dotfiles.plugin.lspconfig}})
+
+(def 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)

nvim/.config/nvim/fnl/dotfiles/plugin/orgbullets.fnl

@@ -0,0 +1,47 @@
+(module dotfiles.plugin.orgbullets
+        {autoload {nvim aniseed.nvim a aniseed.core ts-utils dotfiles.ts-utils}})
+
+(def stars ["◉" "⦾" "○" "✸" "✿" "✶" "•" "‣"])
+
+(def stars-query "(headline (stars) @stars)")
+
+(defn star-index [heading-level]
+      (let [star-count (a.count stars)
+            idx (math.fmod heading-level star-count)]
+        (if (< 0 idx)
+            idx
+            star-count)))
+
+(defonce extmark-namespace (vim.api.nvim_create_namespace :HeaderStars))
+
+(def star-captures (ts-utils.make-query :org stars-query))
+
+(defn gen-star-extmarks []
+      (when (= :org vim.bo.filetype)
+        (let [bufnr (vim.api.nvim_get_current_buf)
+              star-count (a.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 (a.get stars (star-index heading-level))
+                  replacement (string.format (a.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 (nvim.create_augroup :HeaderStars {:clear true})]
+  (nvim.create_autocmd [:FileChangedShellPost
+                        :Syntax
+                        :TextChanged
+                        :InsertLeave
+                        :WinScrolled]
+                       {: group
+                        ;; :pattern [:*.org]
+                        :callback gen-star-extmarks}))

nvim/.config/nvim/fnl/dotfiles/plugin/orgmode.fnl

@@ -0,0 +1,8 @@
+(module dotfiles.plugin.orgmode {autoload {orgmode orgmode}})
+
+(orgmode.setup_ts_grammar)
+
+(orgmode.setup {:org_agenda_files ["~/Dropbox/org/*" "~/my-orgs/**/*"]
+                :org_default_notes_file "~/Dropbox/org/refile.org"})
+
+(require :dotfiles.plugin.orgbullets)

nvim/.config/nvim/fnl/dotfiles/plugin/paredit.fnl

@@ -0,0 +1,61 @@
+(module dotfiles.plugin.paredit
+        {autoload {nvim aniseed.nvim
+                   a aniseed.core
+                   nu aniseed.nvim.util
+                   paredit paredit
+                   ts-parsers nvim-treesitter.parsers
+                   ts-utils nvim-treesitter.ts_utils
+                   languagetree vim.treesitter.languagetree}})
+
+(defn list-member? [xs x] (a.some #(= x $1) (a.vals xs)))
+
+(defn bool->int [bool] (if bool 1 0))
+
+(defn 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))))
+
+(defn parser-language [] (let [parser (ts-parsers.get_parser)]
+                           (when parser
+                             (parser:lang))))
+
+(def- paredit-langs [:clojure
+                     :fennel
+                     :hy
+                     :janet
+                     :julia
+                     :lfe
+                     :lisp
+                     :racket
+                     :scheme
+                     :shen])
+
+(def- paredit-host-langs [:org :markdown :asciidoc])
+
+(defn- host-lang-in? [langs] (list-member? langs (parser-language)))
+
+(defn paredit-lang? [lang] (list-member? paredit-langs lang))
+
+(defn TreeSitterLangParedit []
+      (when (host-lang-in? paredit-host-langs)
+        (when-let [cursor-lang (language-at-cursor)]
+                  (->> cursor-lang
+                       (paredit-lang?)
+                       (bool->int)
+                       (set nvim.g.paredit_mode))
+                  (nvim.fn.PareditInitBuffer))))
+
+; (nvim.del_augroup_by_name "BabeliteParedit")
+; (nvim.get_autocmds {:group "BabeliteParedit"})
+
+; (let [group (nvim.create_augroup "BabeliteParedit" {:clear true})]
+;   (nvim.create_autocmd ["CursorHold" "CursorMoved"]
+;                        {:group group
+;                         ;:pattern ["*.org" "*.md"]
+;                         :callback TreeSitterLangParedit}))
+; 

nvim/.config/nvim/fnl/dotfiles/plugin/treesitter.fnl

@@ -1,9 +1,15 @@
 (module dotfiles.plugin.treesitter
-  {autoload {treesitter nvim-treesitter.configs}})
+  {autoload {treesitter nvim-treesitter
+             ts_utils nvim-treesitter.ts_utils
+             treesitter-configs nvim-treesitter.configs}})
 
-(treesitter.setup
+(treesitter-configs.setup
   {:highlight {:enable true
-               :additional_vim_regex_highlighting false}
+               ;; :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
@@ -19,3 +25,5 @@
                       ] ; table of hex strings
              }
    })
+
+; lua print(require('nvim-treesitter.parsers').get_parser():language_for_range({ require('nvim-treesitter.ts_utils').get_node_at_cursor():range() }):lang())

nvim/.config/nvim/fnl/dotfiles/plugin/whichkey.fnl

@@ -0,0 +1,5 @@
+(module dotfiles.plugin.whichkey
+  {autoload {which-key which-key}})
+
+(which-key.setup {})
+

nvim/.config/nvim/fnl/dotfiles/plugins.fnl

@@ -1,87 +1,92 @@
-(module dotfiles.plugins
-  {autoload {nvim aniseed.nvim
-             a aniseed.core
-             ;; util dotfiles.util
-             packer packer
-
-             }
-   ;; require {minpac minpac}
-   })
-
+(module dotfiles.plugins {autoload {nvim aniseed.nvim
+                                    a aniseed.core
+                                    ;; util dotfiles.util
+                                    packer packer}
+                          ;; 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)))))
+      (let [(ok? val-or-err) (pcall require (.. :dotfiles.plugin. name))]
+        (when (not ok?)
+          (print (.. "dotfiles error: " val-or-err)))))
 
-(defn- use [pkgs]
-  "Iterates through the arguments as pairs and calls packer's use function for
+(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 (a.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))))))
 
-
-(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}
-   :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 {}
-  )
+(def- packages {:Olical/aniseed {}
+                :Olical/conjure {:mod :conjure}
+                :Olical/fennel.vim {}
+                :airblade/vim-gitgutter {}
+                :clojure-vim/vim-jack-in {}
+                :dhruvasagar/vim-table-mode {}
+                :folke/lsp-colors.nvim {}
+                :folke/which-key.nvim {:mod :whichkey}
+                :hashivim/vim-terraform {}
+                :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 {}
+                :jose-elias-alvarez/null-ls.nvim {:mod :null-ls
+                                                  :requires [:nvim-lua/plenary.nvim]}
+                :junegunn/vim-easy-align {:mod :easyalign}
+                :kovisoft/paredit {:mod :paredit}
+                :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}
+                :neovim/nvim-lspconfig {:mod :lspconfig}
+                :norcalli/nvim-colorizer.lua {:mod :colorizer}
+                :nvim-orgmode/orgmode {:mod :orgmode}
+                :nvim-telescope/telescope.nvim {:requires [[:nvim-lua/popup.nvim]
+                                                           [:nvim-lua/plenary.nvim]]
+                                                :mod :telescope}
+                :nvim-treesitter/nvim-treesitter {:run ":TSUpdate"
+                                                  :mod :treesitter}
+                :nvim-treesitter/playground {}
+                :p00f/nvim-ts-rainbow {}
+                :radenling/vim-dispatch-neovim {}
+                :rafamadriz/friendly-snippets {}
+                :skywind3000/asyncrun.vim {}
+                :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-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

nvim/.config/nvim/fnl/dotfiles/ts-utils.fnl

@@ -0,0 +1,12 @@
+(module dotfiles.ts-utils {autoload {nvim aniseed.nvim a aniseed.core}})
+
+(defn root [bufnr lang] (let [parser (vim.treesitter.get_parser bufnr lang {})
+                              tree (a.first (: parser :parse))]
+                          (: tree :root)))
+
+(defn make-query [lang query-string]
+      (let [query (vim.treesitter.parse_query 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))))

tmux.conf

@@ -33,8 +33,8 @@ setw -g mouse off
 
 # set -g default-terminal "xterm-256:color"
 # set -g default-terminal "${TERM}"
-set -s default-terminal "tmux-256color"
-set -g history-limit 6000
+set -g default-terminal "tmux-256color"
+set -g history-limit 15000
 
 set -g window-status-style dim
 set -g window-status-current-style bright
@@ -46,8 +46,9 @@ 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-257color:RGB'
-set -as terminal-features ',xterm-256color:RGB'
+# set -as terminal-overrides ',xterm-256color:RGB'
+set -as terminal-features ',tmux-256color:RGB'
+set-option -sa terminal-overrides ',tmux-256color:RGB'
 
 # Undercurl
 set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support