add null-ls language server

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)]
+(each [_ ftype (pairs pretty-filetypes)]
-;   (nvim.ex.autocmd :FileType ftype :call "SetupConceals()"))
+  (nvim.ex.autocmd :FileType ftype :call "SetupConceals()"))
-; 
+

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

@@ -19,8 +19,7 @@
     (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"))
@@ -61,10 +60,11 @@
    :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
+   :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
@@ -76,8 +76,9 @@
    :tabstop 2
    :shiftwidth 2
    :softtabstop 2
+   :mouse ""
    :list true
-    :listchars "tab:➥\\ ,trail:·"
+   :listchars "tab:➥\\ ,trail:·,"
    :backspace "indent,eol,start"    ;allow backspacing over everything in insert mode
    :wildmode "list:longest,list:full"
    :wrap false
@@ -100,7 +101,7 @@
 
 
 
-(nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "solarized8")
+;(nvim.ex.autocmd "vimenter" "*" "++nested" "colorscheme" "solarized8")
 ;(nvim.ex.autocmd "vimenter" "*"  "luafile" "treesitter.lua")
 ;
 ; (nvim.fn.glob "~/.vimrc.local")

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,7 +1,9 @@
 (module dotfiles.mapping
   {autoload {nvim aniseed.nvim
              nu aniseed.nvim.util
-             core aniseed.core}})
+             core aniseed.core
+             util dotfiles.util
+             }})
 
 (defn- noremap [mode from to]
   "Sets a mapping with {:noremap true}."

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

@@ -13,9 +13,12 @@
 
 (def- cmp-srcs
   [{:name :nvim_lsp}
+   {:name :nvim_lua}
    {:name :vsnip}
    {:name :conjure}
-   {:name :buffer}])
+   {:name :buffer}
+   {:name :orgmode}
+   {:name :emoji :max_item_count 8}])
 
 ;; Setup cmp with desired settings
 (let [cmp (require :cmp)]

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

@@ -1,7 +1,7 @@
 (module dotfiles.plugin.colorizer
   {autoload {colorizer colorizer}})
 
-(colorizer.setup {"*" {}}
+(colorizer.setup [:*]
                   {:RGB      true ; #RGB hex codes, like #F00
                    :RRGGBB   true ; #RRGGBB hex codes, like #00FF00
                    :names    true ; "Name" codes like Blue

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,41 +1,31 @@
 (module dotfiles.plugin.lspconfig
-  {autoload
+        {autoload {a aniseed.core
-   {a aniseed.core
                    u dotfiles.util
                    nvim aniseed.nvim
-    nu aniseed.nvim.util
+                   nu aniseed.nvim.util}})
-    }
-   })
 
-(defn bufmap [mode from to]
+(defn bufmap [mode from to] (u.noremap mode from to {:local? true}))
-  (u.noremap mode from to {:local? true}))
 
-(defn nbufmap [from to]
+(defn nbufmap [from to] (bufmap :n from to))
-  (bufmap :n from to))
-
-(defn xbufmap [from to]
-  (bufmap :x from to))
 
+(defn xbufmap [from to] (bufmap :x from to))
 
 (defn define-sign [level sign]
-  (let [sign-level (.. "DiagnosticSign" level)]
+      (let [sign-level (.. :DiagnosticSign level)]
         (nvim.fn.sign_define sign-level
-                     {:texthl sign-level
+                             {:texthl sign-level :text sign :numhl 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 :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.definition()"
       :gD "lua vim.lsp.buf.declaration()"
       :gi "lua vim.lsp.buf.implementation()"
       :gr "lua vim.lsp.buf.references()"
@@ -46,62 +36,94 @@
       :<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()"
+      ;; 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.formatting_sync()"
+      :<leader>fa "lua vim.lsp.buf.format()"})
-  })
 
 (def client-nmappings
-  {:clojure_lsp
+     {:clojure_lsp {:<leader>cn "call LspExecuteCommand('clean-ns')"
-   {
-    :<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: '))"
+                    :<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)]
+            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)))))
+            (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))
+        (nbufmap mapping cmd)) ; x mode mappings
-
+      (xbufmap :<leader>fa "lua vim.lsp.buf.format()")
-  ; x mode mappings
+      ; --   buf_set_keymap('n', 'gs', '<Cmd>lua vim.lsp.buf.document_symbol()<CR>', opts)
-  (xbufmap :<leader>fa "lua vim.lsp.buf.formatting_sync()")
+      ; --   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', 'gs', '<Cmd>lua vim.lsp.buf.document_symbol()<CR>', opts)
+      ; --   buf_set_keymap('n', '<leader>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
-; --   buf_set_keymap('n', 'gS', '<Cmd>lua vim.lsp.buf.workspace_symbol()<CR>', opts)
+      ; --   buf_set_keymap('n', '<leader>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
-; --   buf_set_keymap('n', 'gt', '<cmd>lua vim.lsp.buf.type_definition()<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>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
+      ; --   buf_set_keymap('n', '<leader>q', '<cmd>lua vim.lsp.diagnostic.set_loclist()<CR>', opts)
-; --   buf_set_keymap('n', '<leader>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
+      ; --   buf_set_keymap('n', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<CR>", opts)
-; --   buf_set_keymap('n', '<leader>wl', '<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>', opts)
+      ; --   buf_set_keymap('x', '<leader>ic', "<cmd>lua vim.lsp.buf.incoming_calls()<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 :BufWritePre :<buffer> :lua
-;  (nvim.ex.autocmd "BufEnter,CursorHold,InsertLeave" :<buffer> :lua "vim.lsp.codelens.refresh()")
+                       "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'})]]
+      ;  -- 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)
@@ -109,26 +131,26 @@
                 c (a.second cursor)
                 opts [buf-uri r c]
                 args (a.concat opts [...])]
-        (vim.lsp.buf.execute_command {:command cmd
+            (vim.lsp.buf.execute_command {:command cmd :arguments args})))
-                                      :arguments args})))
-
     (defn setup-servers []
           (lspi.on_server_ready (fn [server]
-                              (let [opts {:on_attach on_attach :flags {:debounce_text_changes 150} }]
+                                  (let [opts {: 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))
-    (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})
+    (nu.fn-bridge :LspExecuteCommand :dotfiles.plugin.lspconfig
+                  :lsp-execute-command {:return false})
+    (u.nnoremap :<leader>li :LspInfo)))
 
-    (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/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,3 @@
+(module dotfiles.plugin.orgbullets
+  {autoload {org-bullets org-bullets}})
+

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" })

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

@@ -0,0 +1,76 @@
+(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

@@ -2,9 +2,7 @@
   {autoload {nvim aniseed.nvim
              a aniseed.core
              ;; util dotfiles.util
-             packer packer
+             packer packer}
-
-             }
    ;; require {minpac minpac}
    })
 
@@ -33,11 +31,17 @@
    :Olical/fennel.vim {} ; Fennel
    :airblade/vim-gitgutter {} ; Git
    :airblade/vim-gitgutter {} ; Git
+   :akinsho/org-bullets.nvim {:mod :orgbullets}
    :clojure-vim/vim-jack-in {} ; Conjure support - jack-in with nrepl dependencies
+   :dhruvasagar/vim-table-mode {} ; table creation and formatting
    :folke/lsp-colors.nvim {}
+   :folke/which-key.nvim {:mod :whichkey}
    :hashivim/vim-terraform {} ; 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
                                  :PaterJason/cmp-conjure]
@@ -46,21 +50,27 @@
    :hrsh7th/vim-vsnip-integ {}
    :Iron-E/nvim-soluarized {}
    :jiangmiao/auto-pairs {} ; backets, parens, and quotes in pairs
+   :jose-elias-alvarez/null-ls.nvim {:mod :null-ls
+                                     :requires [:nvim-lua/plenary.nvim]}
    :junegunn/vim-easy-align {:mod :easyalign}
-   :kovisoft/paredit {}
+   :kovisoft/paredit {:mod :paredit}
    :kristijanhusak/vim-dadbod-completion {}
    :kristijanhusak/vim-dadbod-ui {}
+   :lukas-reineke/headlines.nvim {:mod :headlines}
+;   :michaelb/sniprun {:run "bash ./install.sh" :mod :sniprun}
    :neovim/nvim-lspconfig {:mod :lspconfig} ; NeoVim  lsp config
-   :norcalli/nvim-colorizer.lua {:mode :colorizer}
+   :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 {} ; 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-fugitive {:mod :fugitive} ; Git
    :tpope/vim-git {} ; Git Commit Message
    :tpope/vim-pathogen {}
    :tpope/vim-rails {}

tmux.conf

@@ -34,7 +34,7 @@ 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 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-overrides ',xterm-256color:RGB'
 set -as terminal-features ',xterm-256color:RGB'
+set-option -sa terminal-overrides ',xterm-256color:RGB'
 
 # Undercurl
 set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support